* In D3D12 if the user passes NULL for the UAV or SRV descriptor when calling
Create*View we don't have the runtime to generate a default one for us when we
query, we'll just have nothing stored. So instead when we need to generate a
default "whole resource" descriptor to look up.
* QNetworkAccessManager is supposed to be asynchronous and threaded internally,
but calling get() the first time can take multiple *seconds* while it
initialises proxy data and loads ssl libraries.
* Qt's threading rules are so strict it's impossible to feasibly move
QNetworkAccessManager to another thread.
* Instead we use Qt's cross-thread signals and slots to move the whole thing
into a wrapper object. It's stupid.
* GenerateGLSLShader is reasonably expensive because it uses glslang to
preprocess the shaders. If we can cache the input hash and look up the cache
with that hash then we can skip it entirely.
* If we default to D3D11 at construction time, if we have persist data (very
likely) and it's for another API then we'll have to destroy the D3D11 viewer
and recreate the other API's viewer.
* It seems like on nv windows we need to explicitly rebind the main context to
the main thread and give each worker thread its own window, to prevent the
worker thread from being unable to bind its context sometimes.
* The spec says we only return a function pointer for device or device-child
functions. In practice the loader wraps instances and physical devices so when
calling a direct GDPA returned function the loader won't unwrap it so we won't
get our proper wrapped objects and will crash.
* If we keep the page set in the command buffer and destroy it on reset, we'll
free the pages behind the baked chunks that we stored. If a capture records
and resets a command buffer multiple times within a capture we need to store
multiple baked command buffers.
* So instead we give the baked commands ownership of those pages and reset them
when the baked commands record is destroyed (either because the command buffer
has been reset as it was before - or if we hold onto a reference during
capture then after the capture is done).
* We tune the pipeline state view and texture viewer to only iterate over a
small list of dynamically used binds in the (vastly more common) case where
unused binds are not being shown.
* This simplifies the code flow because we can be sure that we always have
cached read-only/read-write resources (this was true before, but now it's
clear).
* Using the auto-resizing mode of RDHeaderView resizes based on the whole column
every time, which is wasteful when only a few lines are added to a large log.
* We also reverse Python_ADDITIONAL_VERSIONS so it finds the newest one. It
doesn't seem like there's a way in general to make these match, so we hope
that searching from newest to oldest will find the same in both - or at least
it makes it easier for the user to fix by installing the newest in both.
* It seems like packaging of these two is inconsistent, and pyside2 dev files
being available doesn't always imply shiboken2 dev files are present. Be safe
and check both.
* GL needs special handling because cubemaps need to be treated partially as
arrays to select the target, then not as arrays when the data is retrieved.
* On vulkan command pools aren't necessarily reset often or at all, individual
command buffers are. So the chunk allocator needs to support freeing subsets
of pages. When a command buffer ends we force that page to finish up and store
a list of the pages the command buffer used, which can then be reset back when
the command buffer is reset.
baldurk