* Since we're updating a single member struct in-place and not starting
from a clean slate, we need to be sure to unset state values instead
of just skipping them and assuming the default is empty.
* If the export doesn't need buffers, we export directly from the loaded
capture file instead of re-loading it.
* Add progress bars for the load step so it shows what's happening
instead of looking stalled.
* Reduce compression rate on XML+ZIP buffers as it took too long trying
to compress when exporting large captures.
* If we're aligned up past the size of the allocation (possible if we
apply bufferImageGranularity due to the incoming allocation being
image and the last allocation in the block being a buffer) the next
required offset would be past the size, so avail = block.size - offs
would overflow and we'd try to allocate past the end of the block.
* This is a backwards-incompatible change, so it's done here before v1.0
so that we can freely break compatibility and not need to define a lot
of ugly compatibility code.
* The primary motivation is to make the serialised data more uniform
and have fewer special cases where the serialised form is naturally
defined from the functions/structs in question.
* There are still some special cases or variances but they should be
more isolated and only where really necessary.
* Remove some cases in the D3D12 struct serialising where we were
directly serialising child struct members in the parent struct.
* We now try to match argument/struct member order as closely as
possible.
* Serialising an array with a count no longer reads the count back out
into that variable, counts must be serialised separately. This means
all members/arguments are explicitly present in the structured data
and also eliminates the awkward case where a count needed to be
serialised separately after an array if we want to have the count be
a valid number even if the array could be NULL. It also means we don't
need the FIXED_COUNT() macro since array lengths can be plain values
and don't have to be a reference type.
* GLES separable programs are completely broken, so we need to just go
back to ye-olde style of linking shaders together. On GLES this is
particularly painful as it means we have to version match whatever
shader the user was using.
* Previously we were relying on the pipeline info create to initialise
the reflection for an entry point, now we do it on demand wherever it
is needed.
* As explained in the code, if we repoint an input variable to refer to
a previously declared private type, it might start referencing forward
in the SPIR-V which is invalid. So to fix this and be safe, we just
move the variable to the end.
* We want to make sure every section always has at least one word in it
so we can unambiguously tell which section we're appending to. If the
debug section is empty, it's hard to tell the difference between
appending to the entry point section and inserting into the debug
section, so we add a nop that will get stripped out later.
* The reason is if comparing directly against the end of a section, we
could skip over it if the section ends in a nop and the next section
starts in a nop. Instead < will always work as expected.
* If we don't track their lifetimes specifically, then we can end up
with the situation where an application makes more state objects over
the course of its rendering than is legal (there can only be a max
4096 unique state objects of each time). This could happen if an
application creates state objects each frame with slight variances,
but then releases them again.
* ID3D11Device::CreateInputLayout will fail if we pass a NULL descriptor
array pointer, even though 0xdeadbeef will work so it doesn't actually
use the pointer at all.
baldurk