* This applies when selecting a marker region, the effective EID is the one
actually replayed to an represented in the UI. As-if it were directly
selected.
* We create an instance during early android startup to force our library to
stay loaded, but we shouldn't try to enable any debug extensions because on
some android devices that can cause problems.
* In v1.15 if you upgraded from a previous version and had a renderdoc config
file then the persistent storage storing the filters would get loaded with an
empty variant map, so the defaults could be set. However if you had no config
file at all this wouldn't happen so no defaults would be set.
* We detect the case where we load an old profile and it has blank current
filter or saved filters, and fill in the defaults now. If the filter has been
customised or some saved filters exist, respectively, we don't touch them.
* We check for errors to try to catch them as soon as possible, and early-out
return even in the middle of functions. The idea being even if this leaves us
in a weird state we won't get called again as the replay controller will
detect the error and substitute out a dummy driver.
* The UI will become non-functional and the backend will be replaced with a do-
nothing one that keeps things alive without needing error bulletproofing
everywhere in the real backend.
* These are the only handles returned up by reference from the replay driver,
dynamically allocating them means that we can steal/move the ownership of
these and keep them valid even after the replay driver is destroyed.
* Note - ShaderDebugTrace is also returned by reference but it is already
dynamically allocated like this.
* Instead of storing the API pipeline states in the replay driver and returning
pointers, we store them in the replay controller and write into it from the
replay driver.
* This will allow us to remove the replay driver and still keep any previously
obtained references/pointers to the pipeline state valid.
* On GL you can specify a vertex attribute that's stored as int but gets
converted to float with glVertexAttribFormat instead of glVertexAttribIFormat.
However if the shader accepts an int this is invalid and the value is
undefined - we emulate this as the float bits being read as int directly, but
that's not guaranteed behaviour.
* Normally we don't emulate this kind of mis-cast behaviour and just display the
type of data passed to the shader, but in this case GL lets you specify three
types (stored as int, cast to float, read as int) so our normal behaviour of
just showing the input can be more misleading than normal.
Improve D3D12 action callback match the Vulkan callback.
1.D3D12 action callback add Misc type callback to process copies/clears/etc actions.
2.D3D12GPUTimerCallback, D3D12AMDActionCallback, D3D12QuadOverdrawCallback and D3D12InitPostVSCallback implement Misc type callbacks.
3.Modify D3D12CommandData::HandlePreCallback to be consistent with Vulkan, and add the ActionFlags parameter.
4.Define corresponding macros for the action callbacks of Draw, Dispatch, Execute Bundle, Copy, and Clear commands.
* This means we'll jump to the nearest _visible_ result, rather than just the
next result whether or not it's visible. This also applies to EID searches,
when doing a go-to on a particular EID we'll end up jumping to the next
visible EID.
* If a storage resource is only referenced in a copy as a destination and gets
CompleteWrite state, this may be inaccurate because we no longer track
descriptor set access to images or buffers. That means there could be an
earlier use of the resource in a read/write fashion but on replay we would
clear it for initial states.
* For images this is easy as we can fix this up at the end of the frame, for
memory we need to iterate over all storage buffers and update the memrefs on
their bindings.
baldurk