* This API is now intended to be forward and backward compatible as much
as possible. Meaning applications should be able to run without
changing on many RenderDoc versions after the one they are built
against without breaking.
* All function pointers are fetched at once in one versioned GetAPI()
function, to save on constant GetProcAddress/dlsym'ing.
* Otherwise, it's largely similar to the previous API.
* This is tracking my fork of the Khronos repository
https://github.com/baldurk/glslang on branch 'renderdoc'. See that
branch for my local changes. Only a subset of files is included
* This is kind of arbitrary at the moment, but in future when D3D12 and
Vulkan drivers appear, not everyone who builds RenderDoc will want to
build all drivers, so making them separate projects makes it more easy
to disable/remove them.
* Doesn't compile yet! Just splitting this up logically so the change is
a bit easier to digest.
* I've commented and organised a bit better the gl_hookset.h hook list.
* The function hooks are set up for all of the ARB_dsa entry points.
Those that are semnatically identical to EXT_dsa are set up as aliases
(with EXT_ being canonical, so we can fall back if ARB_dsa isn't
supported - see comments in gl_hookset.h).
* Implemented the new functions except for the glTexture* family and the
glCreate* family. No deduplication of code yet.
* As with EXT_dsa we "promote" to the DSA function for serialisation,
but since unlike EXT_dsa we can't assume ARB_dsa is present, instead
we emulate those functions that we might use unconditionally but may
not be present.
* The implementation needs the fine dFdx/dFdy variants, which are only
available in GLSL 4.50 and above. Without that support we fall back
to the normal dFdx/dFdy which are implementation dependent. In my
quick test on nvidia it so happened that it was still fine, but that's
not guaranteed.
* Client code can enumerate the IDs of counters that are supported -
some of these will be general, some will be IHV specific. It can also
request descriptions of the counters to determine the type of data or
units. This can be used to 'discover' counters that aren't hard
coded into renderdoc. I'll want to at least reserve IHV ranges so that
counter IDs are globally unique, and ideally IHV counters will also be
predeclared where possible.
* Also the refactor removes some ugly rdctype::array use outside of the
replay layer and replaces it just with std::vector, which is a nice
bonus.
* This makes it easier for my auto build scripts (i.e. without xcopy use
I can run them from msysgit bash).
* pdblocate now has Profile32&Release32 vs Profile64&Release64. This was
the easiest way to do it as it has to be compiled in 32bit to interact
with DIA, but we want it copied to the solutions output folder (x64/...
or Win32/...)
* This means that all APIs pass byte string types. ALL strings everywhere
in the entire codebase must be assumed to be and treated as UTF-8 content
not ASCII.
* Gets rid of all the horrible %hs specifiers that caused warnings on
linux! Hooray.
* We convert to wide strings, or use wide characters, only when necessary
to use the Win32 API. Some windows specific code will stay in wide chars
just for convenience.
* Files are already serialised as UTF-8 strings for linux/windows binary
compatibility, so this change doesn't break backwards compatibility.
* Until I have a sample that uses it, I'm not going to attempt to serialise
the tiled resource API. It has a lot of other potential knock-ons too
(e.g. to initial contents).
* Same implementation as D3D11 essentially
* Split out the texture sampling from texdisplay.frag into its own file so
it can be reused. Also removed the discard;s from the texture sample
functions and moved them up into the texture display function.
* renderdoc/api/replay/ contains all the headers for using the replay and
analysis side of renderdoc (like in a UI or auto-testing tool)
* renderdoc/api/app/ contains the headers if you wanted to write a
renderdoc-aware application.
* This means people building on VS2013 don't need to rebuild breakpad
locally to link successfully.
* Committed binaries built on VS2012 Update 4 and VS Express 2013 for
Desktop, which will hopefully work for everyone.
* Sync objects need special handling because the identifier is an opaque
pointer and so we can't use the existing GLResource stuff. Instead to
handle this, we assign a GLuint ourselves and keep a mapping around
to map GLuint<->GLsync. Everything else works as usual from the GLuint
* Remove legacy wrapped functions that were only hacked-in to get
glxgears working as a proof of concept.
* Split out groups of wrapped functions into separate files by type
* Use it to serialise in/out initial state at the start of each captured
frame.
* Serialise active texture and buffer bindings (indexed and non-indexed).
baldurk