* When a port is specified (with the usual :12345 suffix on the hostname) we use
that for remote replay connections. We disable target control enumeration
since that requires a port _range_ and captured applications self-assign those
ports. Those can still be accessed via a normal unsuffixed remote specifier -
even if there is no remote server running on the default port.
Depth stencil resolve attachments were not being serialized and exposed in the pipeline state view. This change serializes the attachment id for the depth-stencil resolve attachment so that it can show up in the pipeline state view.
Update name of depth/stencil in pipeline viewer
Fix clang formatting
Update struct type
* Newly written shaders and any updated shaders can now use pre-defined macros
to abstract away binding differences between APIs, so custom shaders will be
more portable in particular shaders written in HLSL for D3D or GLSL on OpenGL
won't break on vulkan because they refer to incorrect binds.
* When we've applied a custom shader we're now displaying from our internal
custom shader output texture which means we need to ignore some display
properties. These are already ignored in RenderTexture where the custom shader
is applied, but we also need to ignore it in the context display.
* The crash handler gets destroyed and recreated when we need to change creation
parameters, and this races against anything else trying to use it to register
or unregister memory regions.
* In partcular when initialising the replay we recreated the crash handler right
after kicking off the GPU enumeration.
* We add a read/write lock so there's no significant added contention on most
paths (even though it's not really high traffic in any case) to prevent this
kind of problem in future.
* If we hit a fatal error during initialisation, the structured file pointer
still points at the temporary serialiser's structured file. It's not until we
finish loading that we swap it into the driver-stored file that we can safely
return and detach ownership of.
* 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.
* This is a deliberate break of compatibility since the field is now often
empty, for non-markers. This means code will get a more explicit error when
the name is being referenced, so it can be updated to fetch the name it needs
as needed.
* There's not a good accepted terminology for this kind of event, and for
historical reasons 'drawcall' has been the accepted term, even though
that can be quite confusing when a dispatch or a copy is a 'drawcall'.
* This is particularly highlighted by the event browser filters where
$draw() includes draws and dispatches, but $dispatch() only includes
dispatches, it's hard to intuitively understand why $draw() matches all
of these calls.
* As a result we've defined the term 'action' to cover these types of
events in the same way that we defined 'event' in the first place to
mean a single atomic API call.
* Fake markers now need a real event ID. We don't want to have to remap all
events in a capture between UI and replay driver, so instead we assign non-
contiguous events above the normal range and expect the UI to handle it.
* All drawcalls now contain events, even markers. We no longer add virtual "API
Events", it gets added to the marker pop or command buffer close.
* Note that we will still default filter out marker pops, meaning this is a
slight behaviour change as API events will no longer be easily selectable.
However we're adding the ability to show all events which will be preferred.
* This in particular means push constants and specialization constants on vulkan
but also applies to root-value cbuffers on D3D12.
* GL bare uniforms are not feasible to expose in this way.
* We already link to the chunk index and the chunk metadata contains the
callstack, there's no need for a duplicate copy when there may be many
APIEvents in a capture
baldurk