* The GL clip origin when changed from lower left to upper left will also invert
the face culling sense. This is deliberate to counteract the fact that
otherwise CW wound triangles would be CCW wound, so the flip means that if
GL_CCW is the front face state and back faces are culled, then visibly CCW
wound triangles will be culled.
* Unifying these views means that constant buffers have all the same
reformatting and it avoids having multiple paths for what is now effectively
the same control (a buffer can either have fixed data, repeating data, or
both)
* GL and Vulkan allow buffers to have fixed variables before a trailing AoS
unbounded array. These fixed variables can't be easily displayed in a table
and previously we skipped them. Now we display these in a tree format.
* We also support formats which don't have an unbounded array at all and display
these just with the tree. This will allow the BufferViewer to subsume the
capabilities of the ConstantBufferPreviewer (though it needs to handle opaque
non-buffer-backed variables, and slot-following).
* These elements are consumed but not shown, so the offsets of subsequent
elements still act as if they're there. This may be more convenient than
specifying a manual offset on the next element or a struct size.
* This allows the calling code to pass a hint of what packing is known or likely
to be used, meaning less generated manual offsetting/padding when the implicit
rules cover it.
* Instead of having a global tight/non-tight we now let the format string
specify the packing rules (defaulting to scalar - i.e. tight packing as
before), and use the resulting properties to calculate packing.
* This is primarily for GL/VK where the packing rules are not pre-defined and
are also not explicitly reflected, so we instead see what rules are broken
along the way to get the most conservative ruleset we can (that way minimising
the need for manual offset decorations)
* There are several different API packing rulesets - GL has std140 and std430
(and packed/shared, which is implementation defined but is likely to be
similar to one of these or more conservative), VK effectively has rules for
those both, as well as scalar packing which is close to C packing. D3D has one
ruleset for cbuffer packing similar to std140, and effectively scalar for
structured resources.
* These rulesets are quite similar and only differ by the properties here. There
is one exception in the handling of empty structs - but in GLSL these are
illegal so we will take the HLSL interpretation and always treat them as 0
bytes.
* Most of the main entry points that can fail with relevant reasons now has a
way of specifying a message to return with it. This message can be displayed
to the user to give more information or context about an error.
* Newly written shaders and any updated shaders can now use pre-defined macros
to abstract away binding differences between APIs, so custom shaders will be
more portable in particular shaders written in HLSL for D3D or GLSL on OpenGL
won't break on vulkan because they refer to incorrect binds.
Jake Turner