sparse buffers are not cpu-readable, so any mapping requires that they
use a staging buffer, either the stream uploader for writes or a manual
copy for readback

future work here should attempt to resolve two perf issues:
* sparse allocations should be allocated dynamically using a suballocator
* readback shouldn't allocate a huge staging buffer

so many structs

make this handling more consistent

ensure the reset function is only called once when the screen flag is set

more consistent handling and some code size reduction

enforce device lost status always

make this a little more flexible for the non-DONTBLOCK case

tired of adding more and more bool flags here

fixes a bunch of validation errors

instead of manually creating the ivci, there's already a util function for
that which will handle everything

also only set layer info if there are multiple layers

allow creating views of different types than the base resource

this is only applicable to things that go through the hook, not for internal
surfaces

dynamic state required because pipeline hashing for this would be too pita

not even going to attempt to figure out how to efficiently hash this

this works by flagging the next barrier to use the current sample locations
so that everything works as expected during decompression

this needs to be stored as a persistent thing on the ctx so it can be
reused without needing to be recalculated

this will be reused

just smashing in some caps and intrinsics

this is a bit more sensible since a forced flush is going to require
refs and layouts be reapplied

put all the maybes in one place

this should work the same way as argb/abgr

the base formats are supported, so these should fall into place naturally

really the point of this is to clamp void channels for any permutation of rgbx
where all channels are the same (e.g., both rgbx8 and rgbx16), so the previous
helper isn't inclusive enough

need to go through sampler path

10 batch states isn't actually that many if an app happens to be flushing
a lot, so let's multiply that to catch outlier cases

10% of video mem ends up being way too aggressive and causes constant
stalls

really this is supposed to be a failsafe against ooming in a single batch, so
using 50% here ends up serving that purpose much more effectively