I do have a patch coming in soon which addresses a few more of these cases. But to provide a bit of context, this is mostly a compiler issue specific to Metal, rather than a fundamental problem with how the code "should" work. Metal Shading Language doesn't have a concept of Global-scope within shaders, which means that certain global variables as in GL cannot be declared. Constant globals are allowed, however, in order to emulate GLSL globals, the Metal generated shader wraps a class around the entire GLSL implementation, such that it creates an effective global scope through class members.

There is a compiler issue here where while expressions remain constant, for array/matrix types, due to the ability to perform random access on these, which cannot be resolved at compile time , the compiler allocates them within thread local memory using a chunk of the temporary register file. The performance impact comes when the local memory requirements for the shader exceed the reasonable limit available for each shader core, causing a decrease in occupancy, as memory has to be split across several cores per execution instance. (In the worst case, this can result in a 1/16th of the total performance).

There is a secondary caveat that the compiler also cannot handle constexpr within a class, and instead must use static constexpr, but due to another limitation, using static constexpr can often be invalid in Metal, due to the requirement to declare a scope for variables. This should not be the case, but moving constant declarations within function scope is the least impactful way to work-around this.

One other option would be to hoist constant expressions outside of the class wrapper, but this would require more complex parsing and increase shader translation time.

Certainly not ideal, and hopefully something which could be done more cleanly in the future.

So TL;DR unfortunately, constexpr does not work as expected due to memory scope (thread, threadgroup, device, constant) being incompatible with static constexpr within the shader's class body, due to how the generated Metal shaders wrap the GLSL implementation.