* The core class is now responsible for tracking the active window and
cycling through, so it can cycle through multiple APIs.
* For GL we only set up associations for capturable windows, and only
those that present (since helper windows are often created). Since
GL doesn't really have a 'this window is done rendering' call, we just
decay old windows that haven't presented in >5 seconds.
* Also on GL, legacy/uncapturable windows aren't associated so they will
not cycle to at all.
* The embedding API now expects a device pointer and window handle to
set active window or start/end a capture. You can still pass NULLs if
there is only one API active.
* Previously if a temporary log was saved once, it would be moved there,
so the user could in theory delete it and lose the only copy of the
log.
* Now the temporary log is held until it's closed in the UI, to be able
to be saved again. If the user saves the log though, this will stop
any "unsaved log" prompts in the main UI window, so there is nothing
stopping the user from saving the log, deleting that copy, then
closing and they'll lose the log without prompt.
* This means that the timeline bar will show use as read/write/clear etc
and that right clicking on textures in the texture viewer will show
the events where that texture is used for rendering, for reading, and
so on.
* This is a concession towards non-core capturing, as it's fairly easy
to support this fallback case without having a negative effect on the
proper path.
* We serialise out whether an index buffer was bound, and if it wasn't
we serialise the array passed as a parameter, and upload it into a
temporary index buffer we generate (so that the replay is correct at
least).
* I think technically the indirect parameter for glDrawElementsIndirect
can point to client memory, and the elements array-of-arrays in
glMultiDrawElements can definitely point to client memory, but I'm
assuming that no-one would do that. I certainly hope they wouldn't!
* The option will enable monospaced fonts for all data displays, like
the list of events, API calls, etc as well as pipeline displays, entry
of filename/directory in the capture window and many other places.
Pure UI labelling etc mostly still stays as a serif font.
* A few sizes of controls were tweaked (like headers in the pipeline
windows) so that they didn't just barely overflow with the larger
font.
* While looking at this, it became obvious that buffer viewers and
constant bufferviewers should always display in monospaced regardless,
so that has been changed.
* If CreateContextAttribs is not used to create the context, the overlay
will run in super-duper old mode using immediate mode calls and fixed
function pipeline. This way it should display on (in theory) any GL
app. Capturing will be prevented.
* Compatibility profile contexts are still allowed, but a warning is
displayed in the overlay.
* If CreateContextAttribs is used to create a < 3.2 version context, we
go down the same path as for legacy contexts, except with an accurate
overlay message (just that the version isn't supported).
* This prevents the app requesting an ID3D11Debug, getting the *real*
one, and then escaping our little jail of QueryInterface interfaces.
In particular, an app is likely to ask for ID3D11Debug then ask for
ID3D11InfoQueue and we want to control use of that ourselves,
particularly when we're tracking debug device messages.
* We handle them mostly as a series of rows, adding only the first row
as a varying name, but incrementing the stride for each to account for
the space taken up by a matrix.
* The trace count could be less than the number of instructions if flow
control causes some instructions to be skipped (and higher if some
were repeated!). There's no need to validate this value anyway, RunTo
will bail when it hits the end of the trace if the number is too high.
* For everything but vertex shaders to make a separable program we need
to redeclare gl_in and gl_out. If both of these end up in the same
string the second insertion was trampling the first one - now they
will both go in properly.
* Errors like syntax and runtime errors in python are thrown as
exceptions. So for when we invoke onto the renderer thread to do some
work, we need to be able to catch those exceptions otherwise the whole
program dies. So over the execute, temporarily switch the thread into
a catching-exception mode, which then gets rethrown on the invoker's
thread.
* Note that BeginInvoke shouldn't be used by python since the callback
might happen after the execution has finished (there's no way to wait
at the moment).
* SetDst called into a scalar destination operand expect the source to
be in .x of the parameter, regardless of mask. So in a couple of cases
where we're assigning from a vector we need to do the mask apply
by hand. Bit messy, but there are only a couple of exceptions
* ld_structured was just looking for UAVs before, but this opcode is
also used for SRVs and we need to find the right declaration to get
the stride correctly (otherwise we'll either get 0 if there are no
UAVs, or pick a UAV incorrectly!)
* Previously we'd expect to run through the same algorithm to generate
the drawcall nodes, but fill in the existing nodes. However this
completely broke down when some nodes weren't created because they
were empty. Now instead we just iterate the nodes that are there and
look up any values in the timing results.
* If buffer wasn't a multiple of 4, a Buffer.BlockCopy call could crash
* Unsigned byte indices (for GL) weren't supported
* Post-transform index buffer was assumed to just be uints, but in fact
it is the same size as the drawcall's existing indices.
* You can't set SplitterDistance unless both MinSize values will be
respected, which needs a big enough window. Smaller than that, we just
have to skip setting the size.
* Note at the time of committing there are still some warnings in MS
headers that you might need to suppress in a couple of files.
* 3rd party code just has the warnings suppressed for ease of merging.
* The majority of warning fixes were for local variables shadowing
other locals, function parameters, or members. In most cases they
weren't a problem, but in some cases it was potentially dangerous!
* What gets listed as a 'drawcall' is a bit fuzzy - previously it was
drawing calls, dispatches and clears, but you could make a good
argument for these to be included as well. As a semi-experiment, these
calls are now included and will be listed in the event browser.
* Other calls can change resources like direct buffer or texture uploads
and Map() type calls, but these remain as API calls listed between
draw calls. Again this is mostly an arbitrary distinction.
* D3D11 logs are backwards compatible, GL logs are not (although it'd
be relatively simple, GL logs will likely break backwards compat soon
anyway, so not worth supporting it now only to break it soon).
baldurk