* It's annoying to have the constant buffer view reset and collapse
everything, especially if moving between draws where the variables are
the same because the shader hasn't changed.
* We can just compare the previous set of variables to the new set and
if the types and structures (member variables etc) are the same, then
just update the values in-place.
* Tacking -official onto the git hash was a hack only needed on windows,
and since we want more information it doesn't scale.
* Instead we track anything we need to know about the version in
separate variables, like whether it's a stable build or a nightly/
local build. Or if it's built by a downstream distribution then the
version number for the downstream build.
* Since we're promoting everything, we reset the behaviour of
RDTreeWidget so that it's not doing anything different by default.
* RDTreeWidget's interface is a bit different, exposing some useful
things like a single selected item and so on.
* We also can't set columns in the Qt Creator UI anymore, so we set them
from code.
* We previously were only checking if all lookups had completed before
self-deleting, but we also need to make sure nothing externally is
still holding onto the dialog.
* This allows us to return complex types like byte arrays or pairs of
status & render handle.
* Also in future more introspection of the capture file will be possible
and this provides an easy extension to that without adding new entry
points.
* In python it's not as quick to get ~0U since ints aren't unsigned or
fixed size. Adding named constants makes it easier for people to use
the right values, and C++ users can still pass ~0U.
* 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.
* Note, this API is still in-flux and beta, so there may still be some
more changes before it's 'stable', and even then it will still be
subject to some amount of change.
* This API is then exposed to python via SWIG bindings and hides
internals that don't need to be visible, and means the actual API is
easier to work with.
* We also use this API to reduce inter-dependencies between different
windows that need to interact with each other at a high level.
* The naming is python/standard RenderDoc TitleCase method names, not
Qt style camelCase methods.
# Conflicts:
# qrenderdoc/Windows/PipelineState/D3D11PipelineStateViewer.cpp
# qrenderdoc/Windows/TextureViewer.cpp
* 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 goes all the way back to the first iterations where these were
the only structures and 'Fetch' referred to them returning data from
the core code to the UI.
baldurk