* 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.
* If we pick up on keyup, it might be a keypress from somewhere else
(like a dialog) that was released on our control. Instead we should
look for keydown.
* We forward a different range of ports to each device so we can pick
and choose which to communicate with based on its index.
* The index is encoded in the 'hostname' like so: adb:X:deviceidhere
* Whenever we want to interact with an android device we always specify
the device, never leave it to a default.
* Generally this means removing ref out parameters and instead returning
values. In a couple of cases we will want to avoid copies in future
either by returning const references (e.g. to the pipeline state which
is immutable).
* At the same time, some pointless bool return values that were always
true and didn't indicate errors have been removed. They can be added
again if an error condition comes back.
* Some free functions still have out parameters as C linkage doesn't
allow returning user types by value.
* The C# UI still invokes into C wrappers for all the C++ classes, which
handle taking the return value and doing a copy into an out parameter
still for compatibility.
* Things like addressing modes, stencil operations, and other things the
UI didn't need to know about previously were only exposed as string
values to be passed through and displayed.
* Now we describe these with enums so the API can be properly
introspected and used by consumers that might want to know the actual
values of these states.
* This gives a little nicer syntax, a bit better type safety, and also
reflects better for SWIG bindings. Overall it's a minor change but
better.
* We don't update the C# UI at all, since it's soon to be removed and
not worth the effort/code churn.
* For now so we're ABI compatible with C#, all enums are uint32_t, but
that is an obvious optimisation in future to reduce struct packing.
* We avoid 'None' as an enum value, because it's a reserved word in
python so will cause problems generating bindings.
* This is a possible fix for a case where render work triggered by mouse
movements (such as pixel and vertex picking) can happen faster than it
executes, leading to a backlog of render commands and a noticeable lag
which only gets worse the more you move the mouse until everything
seems to be unresponsive or laggy (especially if you then trigger a
blocking command like event change, which will block the whole UI
until the queued picks happen).
* Since a new pick coming in will override and make redundant the
previous pick, we allow the render commands to do just that. If a new
command comes in, we remove any previous commands with the same tag
and put the command in the first match (this prevents a tagged invoke
always being pushed to the back of the queue).
- Fix sorting to respect visual ordering by ID, including parent.
- Provide Ctrl-A to 'Select All'. Note that there is an extant
bug with the redraw where renderdocui will not repaint when
it gets focus back.
* This most commonly happens launching an Android program that takes a
while to launch, or if you're launching a program with the delay for
debugger option set.
* Instead of the whole UI hanging, you'll get a progress dialog to
appear while it's waiting.
* Always at least pick the current instance, even if no others are
visible
* Only apply to VS output picking. Inputs either don't vary with inst ID
or are trivial (all verts identical) depending on the element selected
* Respect the currently selected element instead of always picking
the position output
* If we're selecting a different instance, we have to queue the vertex
selection because otherwise the refreshing of rows breaks it
* I received a few crash reports with a disposed buffer viewer still
doing work. My theory is that some operation took long enough that the
user was able to close the viewer (perhaps *because* it was taking a
long time) and subsequent work then didn't handle the window having
been closed.
baldurk