* 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.
* This was previously needed to be stencil-before-depth to workaround an
nvidia driver bug, but now depth-before-stencil works around a RADV
hang and it no longer seems to be necessary for nvidia.
* The RADV issue is being fixed upstream but this is a 'free' workaround
until that arrives.
* Since we don't mark descriptor sets or the written data as referenced
until the descriptor set is actually used, any writes for sets that
are otherwise unused might be missing the necessary objects.
* This is harmless though so we just make sure not to warn about them
being missing as it gets spammy.
baldurk