* This is primarily for the benefit of GL/VK where we need to feature-detect for
some extensions or functionality that requires selecting a device, e.g. D3D12
can be more easily detected with a quick check.
* We'll run this once and cache the results when running tests from python so we
can do a better job of filtering out tests that the current machine doesn't
support.
* On GL addressing modes are called wrap modes, and the wrap value is then known
as repeat. If we don't 'localise' this then it can be confusing to show that
it is "Wrap".
* XGetGeometry will only work on X IDs so we had a wrap/unwrap pass for
GLXWindows, but that fails for pbuffers and there's no need when
glXQueryDrawable can query sizes just as well.
* rdcstr no longer inherits from rdcarray, it implements all functionality
itself.
* There are now three representations:
- Heap-allocated, same as how rdcarray behaves.
- Local-allocated, for small strings we store them in a union array.
- Compile-time literal, only created from user-defined literals.
* The main observation is that a lot of RenderDoc's strings are compile-time
literals either from struct names, member names, or stringified enum values.
Storing these directly and allowing them to be moved and copied quickly saves
on allocations and time. When the string is modified, it's copied to one of the other formats.
* Now that the dirty list is only read once at the start of the frame we can
mark resources dirty mid-frame freely and don't have to defer that. The
internal resource manager locking prevents us from adding to the list while it
is being modified.
* This is primarily around initial states - either a resource which is from a
previous frame and maybe wasn't dirtied and needs initial states created for
it when it's modified mid-frame, or a resource that's created and destroyed
all within one frame.
* This is only intended to handle the case where a new program is created mid
frame and linked for the first time, and we need the initial contents chunk to
get location translation among other things. We don't yet handle programs
being re-linked multiple times mid-frame.
* glUniformBlockBinding can be changed at runtime and previously pushing all
instances of it into the resource record means it would be overwritten by any
bindings retrieved by the initial contents. That's fine (if redundant) if they
aren't changed afterwards, but if they are changed then this will be wrong.
* If we only copy the slot contents without converting Vk* handles to IDs then
we run the risk that the resource will be deleted and re-allocated mid frame
before we do that at serialise time.
* Instead we fetch IDs immediately and serialise as IDs, then look up the
handles on replay
baldurk