* 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.
Using "1" here was very specific to the build system, as noted by the comment.
When run on systems with older APIs install, it resulted in java compile errors.
* 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.
* 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.
* Previously the cmake build would put librenderdoc.so in a /bin folder
in the source folder so the qt creator project could link against a
fixed path when just opening the project solo.
* This won't scale though for fetching the SWIG outputs from cmake, and
it's ugly to modify the source folder for out-of-source builds.
* Instead we have cmake generate a qt creator include file with all of
the settings and paths needed, and pass the CMAKE_BINARY_DIR into
qmake when building. This does mean that when opening the project in
qt creator you need to specify CMAKE_DIR=/path/to/build though.
* As a bonus, this means we can let cmake identify where python is and
have qt creator link against it rather than having to hardcode include
paths etc.
* 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.
* The functions are still exported and that's all renderdocui cares for.
* The interface is no longer to be used so gets in the way of the
generated SWIG bindings.
* 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.
In some cases when the renderdoccmd/qrenderdoc is linked the linker
ignores the libEGL.so and only uses the librenderdoc.so.
This is because the renderdoc shared library provides the
same symbols as the libEGL.so. However we need to keep the
libEGL.so as we are using RTLD_NEXT in the renderdoc shared
library.
* Truly, this is a sad day. But unfortunately many dependencies are just
not supported and it's increasingly difficult to stay on VS2010.
* In an ideal world, the IDE and compiler would be decoupled, but that's
not the case.
* A 64-bit install has an x86 subfolder to capture 32-bit programs. If
a 32-bit program then launches a 64-bit program we need to 'promote'
back to run the original bitness to capture it.
* It's still not supported to capture 64-bit in general from just a
32-bit install as the support files aren't included.
* Using OS-specific append writing functions instead of simple fopen/
fwrite/fclose we can guarantee that multiple processes writing to the
same log file won't trash or interleave their log output.
* To make the logs readable the PID is now included along with the
project/timestamp.
* After that, we make sure that when we launch a program we set the
output log to the same file as the parent UI. This keeps all the logs
together and removes user confusion over which logfile is needed.
* We also move all of RenderDoc's temporary files under a RenderDoc
folder in the temp folder, instead of scattering the files in the root
* This also fixes the problem of capturing 32-bit programs with 64-bit
RenderDoc failing to properly insert environment variables and
error'ing when it tries to do it directly.
* This allows qrenderdoc to link properly when opened directly in
qtcreator, as otherwise it doesn't know where to link to the generated
librenderdoc.so somewhere in CMake's build directory
* This is similar to the button on the capture dialog of the windows UI,
except on linux the situation is a bit more complex as layers can be
registered in two different system locations (one for distro packages
and one for non-distro stuff), as well as in $HOME.
* On linux we make sure the json always contains an absolute path so we
can tell from any given build whether or not a json is our own or not.
* By default we now install the json to /etc since /usr is reserved for
proper distro packages, and shouldn't be written to by 'make install'.
There's a CMake variable for overriding this for anyone who wants to
make install into a custom folder (maybe for packaging).
baldurk