* This way it can be used from Qt or any other UI as well.
* The pipes are created internally and just passed as stdin to the
renderdoccmd processes instead of being named pipes.
* These structs were no longer used since the memory wholeMemBuf was
added, and they had some confusing enum usage that triggered static
analysis warnings.
* When descriptor sets are invalidated and we have stale bindings around
we cannot bind them or it will lead to invalid behaviour and crashes.
* However it's possible for set 0 to be invalid/stale and set 1 to be
valid and required, so we can't bail out at the first invalid set. We
keep iterating and bind all valid compatible sets.
* When we do a partial replay we truncate the render pass to only have
one subpass, but pipelines are created for a particular subpass. So
at creation time we create a new pipeline that points to subpass 0 so
we can use it later together with the truncated render passes.
* This is far more likely when you start capturing at the start of the
program, but it can happen any other time if you get unlucky.
* Normally we expect the preparation of initial states for programs to
get all the data ready, but if the program is created during the frame
capture then that's after preparation, so we need to instead fetch and
serialise the data at the end of the frame while serialising initial
contents.
* This isn't reliable in GL since context creation is such a mess, but
we go from the first attribs-based context create to the next present.
* Should allow capturing early setup and creation before the first
render.
* The proxy replay driver might not report an 'internal' ID that doesn't
have a true live ID, so instead we take responsibility for reporting
it. The proxy will still return its details when prompted.
* Requires binary plugins to function from the RGA repository. These
will be included with distributions (nightly and stable builds) where
possible, however D3D disassembly currently requires the AMD driver
DLL which cannot be distributed. Placing it in the folder with the
other files will automatically work.
* This allows better identification of a shader from its reflection
bundle. The entry point was already 'optionally' in the debug info
struct which is no longer a great location for it.
* For APIs where the entry point isn't contractual and it might not be
listed, instead we just fall back to 'main'. This means that the UI
or anyone fetching the info can be guaranteed that some sensible entry
point will be listed.
* Also for the debug info, remove the 'entryFile' index and instead just
guarantee that as much as possible the entry point will be in the
first file in the list.
* When Common_preElements was removed, it lost some serialised data.
Although we don't need it anymore, we at least need to serialise the
bool indicating no data came from memory so that the serialisation
lines up.
List of exposed GL ES extensions:
* GL_EXT_clip_cull_distance
* GL_EXT_debug_label
* GL_EXT_debug_marker
* GL_EXT_blend_minmax
* GL_EXT_draw_elements_base_vertex
* GL_EXT_texture_type_2_10_10_10_REV
* GL_OES_draw_elements_base_vertex
All of these extensions already have implementations in RenderDoc
there was just missing entries in the allowed extensions list.
* This causes all devices to be included in the capture, when that isn't
what we want. If the application creates and destroys some devices
they must not be included in the capture or we end up with multiple
devices and can use them in a inconsistent manner.
* The active m_Device is still marked as referenced in the frame so it
will be pulled in that way.
* If the application did some CPU side synchronisation that's not
visible in the capture (unlike a queue Wait() which we replay as a GPU
sync) then there might be overlap that causes simultaneous use
problems. So instead we sync between submissions on different queues
to ensure we don't overlap by accident.
* When referencing all resources we use this function to determine what
should be excluded, and in this case we want to make sure that e.g.
the device record and any swapchain records are included, but the
queue/list records or frame capture record should be omitted as they
will be included specially.
* Since D3D12 doesn't allow recording to multiple commands at once, if
we end up doing a partial replay and including a data upload that uses
a list to upload, we need a separate list and allocator.
* There's still an issue lurking that the compressed size is stored as
32-bit on disk, but at least now we don't store the uncompressed size
as 64-bit but track it as 32-bit.
* The serialisation is going to change Soon(tm) anyway so this
workaround should be enough for now, since hopefully compressed size
is comfortably below uncompressed size.
baldurk