* Previously this would be treated as std430 due to being 'tight' array packed,
even though std430 only allows as tight as the base alignment - which for a
float3 is 16-bytes still.
* 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)
* We still need to handle multiple elements in the root of a struct specially by
commenting out the fixed members, but the final element needs to go through
the normal DeclareStruct() path to handle things like per-column padding in
matrices etc.
* These map more naturally to python tuples and are easier to wrap in and out.
* We also tidy up the FloatVecVal etc and standardise the members of
ShaderValue.
* This is a leftover artifact from before we had general extended type support
and double was the only non-32 bit type we handled. Now we support most type
formats so doubles are just CompType::Float with 8 byte width
baldurk