* Subresource handling is more consistent - we pass around a struct now that
contains the array slice, mip level, and sample. We remove the concept of
'MSAA textures count samples as extra slices within the real slices' and
internalise that completely. This also means we have a consistent set
everywhere that we need to refer to a subresource.
* Functions that used to be in the ReplayOutput and use a couple of implicit
parameters from the texture viewer configuration are now in the
ReplayController and take them explicitly. This includes GetMinMax,
GetHistogram, and PickPixel.
* Since these functions aren't ReplayOutput relative, if you want to decode the
custom shader texture or the overlay texture you need to pass that ID
directly.
* We also only use GIT_COMMIT_HASH where necessary to avoid rebuilding many
files for no reason, including splitting version.cpp out into a separate
project as we do with VS since otherwise changing its preprocessor defines
rebuilds the whole renderdoc project.
* At the same time, move the git hash to be internal only so we don't have to
try to link version.cpp into other projects like renderdoccmd or qrenderdoc.
* This invokes run_tests.py with any arguments but specifies the renderdoc
module and python module paths automatically. Only works if built within the
project repo itself as otherwise it won't locate the test script
* Previously it would be swallowed and processed as the argument to the test
command itself. We need to do a little manual parsing and stop cmdline from
doing too much work.
* This option will now toggle on the behaviour to fill undefined buffer contents
with a marker value, both if they're created without data (it will be zero
filled instead) or mapped with discard (it will keep the old contents
instead).
* There were too many hard to find problems or misconceptions about the buffer
filling for it to be useful. Now it will be opt-in instead.
* This option has always been a mixed bag - when originally written captures
weren't compressed at all so saving the cost of a initial contents on a
gbuffer would have a significant savings.
* Now with compression the savings are lesser, and it's a source of
bugs/confusion for the case where either a bug is caused by leaking data from
the previous frame or worse still the contents are discarded incorrectly.
* D3D11 will now behave as the other APIs will - saving initial contents
whenever needed even if they seem like they might not be used.
* If android studio or other android tools are open when a package is
launched for debugging, they greedily jump on it and connect which
prevents us from connecting.
* If the export doesn't need buffers, we export directly from the loaded
capture file instead of re-loading it.
* Add progress bars for the load step so it shows what's happening
instead of looking stalled.
* Reduce compression rate on XML+ZIP buffers as it took too long trying
to compress when exporting large captures.
* On windows, the change in a global GIT_COMMIT_HASH define in each
project needing it meant a full rebuild every time the commit changed.
* Ideally we'd set the define only on one file in each project, but
MSBuild doesn't seem to support that. Instead we make a new tiny
project that compiles a single cpp exporting a global var, and
reference that global var in each other project.
* Mostly used for passing a progress float back during a long blocking
call like opening a capture or doing a copy.
* This is much more feasible for python to bind to.
* In several cases we just use a tiny lambda that updates a float anyway
since we can't push the progress directly into a progress dialog, but
need to let it query from a temporary in-between float.
* We enforce a naming scheme more strongly - types, member functions,
and enum values must be UpperCaseCamel, and member variables must be
lowerCaseCamel. No underscores allowed.
* eventId not eventID or EID, and Id preferred to ID in general. Also
for resourceId.
* Removed some lingering hungarian m_Foo naming.
* Some pipeline state structs that are almost identical between the
different APIs are pulled out into common structs. Where something
doesn't make sense (e.g. viewport enable for vulkan) it will just be
set to a sensible default (in that case always true).
* Changed scissors to be x/y & width/height instead of sometimes
left/top/right/bottom
* Abbreviations are discouraged, e.g. operation not op, function not
func.
* When opening a capture file, a format is now available to allow
easy import from another format without a completely different
interface. Only rdc files can be replayed, but any other file can
load and access structured data through the same interface.
* The replay initialisation and capture writing interfaces also use the
RDCFile instead of passing filenames or Serialisers around directly.
Driver initialisation parameters are now entirely private, and don't
need to be exposed - any agnostic metadata like thumbnail, driver, etc
are all accessed via the RDCFile container itself.
* Callstack resolution is now part of the container file, not the
back-end via way of its Serialiser.
* Importers/Exporters to other non-RDC formats are registered in a
similar way to replay/remote drivers.
* It is also then possible to construct an RDC file from thin air, by
creating an empty RDCFile container and filling it with data, then
requesting it to be written to disk.
* Note that while this is public and uses std::string, because it's a
template with specialisations in a .inl the string never crosses a
module boundary - each including module has its own implementation.
* This will be used as part of the upcoming serialisation refactor.
* Some POD structs are still given ToStr implementations as we haven't
yet switched over the serialisation system to expect all structs to
have serialise functions.
* Since these types are more prevalent than originally designed, it
makes more sense to remove the namespace for ease of typing/naming.
* Also add a specialised type 'bytebuf' for an array of bytes.
* This makes mapping easier to SWIG since there's no special casing for
namespaced arrays. Especially so for nested cases like
rdctype::array<rdctype::str> -> rdcarray<rdcstr>
* For the most part the interface is stl-compatible, but we have a few
little changes of our own for convenience.
* This class is still needed after deleting the C# UI, because we don't
want to pass C++ stl structs over module boundaries and possibly run
into hard to diagnose incompatibilities.
baldurk