* The DrawcallDescription children is mutable, so we don't need a
separate struct for that purpose in D3D11/GL where there's no side
data to carry along with (where draws are late-bound when submitted).
* This will be used in future to record the exact entry point the application
called, instead of just the function that we serialised (so calls aren't
falsely promoted to DSA variants, etc).
* Where the same enum value is used in multiple cases this then picks
the GL version. This is especially important when the same value is
used for radically different enum values.
* The new serialiser system will not handle the container file itself,
so we've separated it out to deal in sections and stream I/O to read
from and write to sections.
* We also add the ability to choose the compression scheme for a section
instead of always using LZ4. LZ4 will still be used on the fly for
fast write performance, but then RDC files can be re-compressed for
savings offline.
* This I/O will form the basis of the new serialiser - it will simply
read to or write from one of these I/O streams. Then that stream can
come from a file, go to a memory buffer, or go through a compressor
or decompressor transparently.
* It also allows a unified way of writing over sockets instead of
needing special socket helper functions.
* With this commit, the code isn't used aside from in tests.
* Note that while this is public and uses std::string, because it's a
template with specialisations in a .inl the string never crosses a
module boundary - each including module has its own implementation.
* This will be used as part of the upcoming serialisation refactor.
* Some POD structs are still given ToStr implementations as we haven't
yet switched over the serialisation system to expect all structs to
have serialise functions.
* We have some special handling to allow SWIG wrapping of these types:
SDFile owns the chunks and buffers within, and each object owns its
children. Copying is disallowed except from SWIG where we assume the
wrapper is handling lifetime management for its objects externally.
* Previously we would convert from python to C++ arrays immediately by
copying, and vice-versa convert TO python immediately by creating a
new python list by copying.
* This however behaves rather poorly in common situations, e.g.:
> foo.bar.append(5)
Would not append 5 to foo.bar, but copy foo.bar to a temporary, append
5 to it, then destroy it leaving foo.bar untouched.
* Instead we leave the C++ array type as a pointer for as long as we can
and instead implement the python sequence API as extensions/slots that
work in-place on the original array.
* Since these types are more prevalent than originally designed, it
makes more sense to remove the namespace for ease of typing/naming.
* Also add a specialised type 'bytebuf' for an array of bytes.
* This makes mapping easier to SWIG since there's no special casing for
namespaced arrays. Especially so for nested cases like
rdctype::array<rdctype::str> -> rdcarray<rdcstr>
* For the most part the interface is stl-compatible, but we have a few
little changes of our own for convenience.
* This class is still needed after deleting the C# UI, because we don't
want to pass C++ stl structs over module boundaries and possibly run
into hard to diagnose incompatibilities.
* The directories are flattened since the #include paths aren't
relative and instead just #include "file.h". The recommended
solution is just to flatten the directory structure.
* This can happen if the resource was not included in the capture, but
there was a descriptor passed (i.e. not NULL desc which is handled
separately) which specifies some parameters, but leaves the format
as UNKNOWN.
baldurk