Given a pipeline key, this cache returns a pipeline abstraction (for
graphics or compute).

This abstractio represents the state of the 3D engine at a given draw.
Instead of changing individual bits of the pipeline how it's done in
APIs like D3D11, OpenGL and NVN; on Vulkan we are forced to put
everything together into a single, immutable object.

It takes advantage of the few dynamic states Vulkan offers.

This abstraction represents a Vulkan compute pipeline.

This function allows us to share code between compute and graphics
pipelines compilation.

vk_update_descriptor/vk_renderpass_cache: Add pipeline cache dependencies

renderer_vulkan: Buffer cache, stream buffer and memory manager changes

The renderpass cache is used to avoid creating renderpasses on each
draw. The hashed structure is not currently optimized.

The update descriptor is used to store in flat memory a large chunk of
staging data used to update descriptor sets through templates. It
provides a push interface to easily insert descriptors following the
current pipeline. The order used in the descriptor update template has
to be implicitly followed. We can catch bugs here using validation
layers.

The stream buffer before this commit once it was full (no more bytes to
write before looping) waiting for all previous operations to finish.
This was a temporary solution and had a noticeable performance penalty
in performance (from what a profiler showed).

To avoid this mark with fences usages of the stream buffer and once it
loops wait for them to be signaled. On average this will never wait.
Each fence knows where its usage finishes, resulting in a non-paged
stream buffer.

On the other side, the buffer cache is reimplemented using the generic
buffer cache. It makes use of the staging buffer pool and the new
stream buffer.

* Allocate memory in discrete exponentially increasing chunks until the
128 MiB threshold. Allocations larger thant that increase linearly by
256 MiB (depending on the required size). This allows to use small
allocations for small resources.

* Move memory maps to a RAII abstraction. To optimize for debugging
tools (like RenderDoc) users will map/unmap on usage. If this ever
becomes a noticeable overhead (from my profiling it doesn't) we can
transparently move to persistent memory maps without harming the API,
getting optimal performance for both gameplay and debugging.

* Improve messages on exceptional situations.

* Fix typos "requeriments" -> "requirements".

* Small style changes.

This is intended for a follow up commit to avoid circular dependencies.

yuzu/bootmanager: Remove {glx,wgl}MakeCurrent on SwapBuffers

MakeCurrent is a costly (according to Nsight's profiler it takes a tenth
of a millisecond to complete), and we don't have a reason to call it
because:
- Qt no longer signals a warning if it's not called
- yuzu no longer supports macOS

core/memory + arm/dynarmic: Use a global offset within our arm page table.

video_core: Block in WaitFence.

vk_descriptor_pool: Initial implementation

nifm: Only return that there's an internet connection when there's a BCATServer

Shader_IR: add the ability to amend code in the shader ir.

Co-Authored-By: Mat M. <mathew1800@gmail.com>

NvServices: Correct Ioctl Remap.

yuzu: Remove Maxwell debugger

This was carried from Citra and wasn't really used on yuzu. It also adds
some runtime overhead. This commit removes it from yuzu's codebase.

maxwell_to_gl: Implement missing primitive topologies

Create a large descriptor pool where we allocate all our descriptors
from. It has to be wide enough to support any pipeline, hence its large
numbers.

If the descritor pool is filled, we allocate more memory at that moment.
This way we can take advantage of permissive drivers like Nvidia's that
allocate more descriptors than what the spec requires.

This saves us two x64 instructions per load/store instruction.

TODO: Clean up our memory code. We can use this optimization here as well.

shader/p2r: Implement P2R Pr

This commit introduces a mechanism by which shader IR code can be
amended and extended. This useful for track algorithms where certain
information can derived from before the track such as indexes to array
samplers.

vk_image: Add an image object abstraction

vk_staging_buffer_pool: Add a staging pool for temporary operations

This function is called rarely and blocks quite often for a long time.
So don't waste power and let the CPU sleep.

This might also increase the performance as the other cores might be allowed to clock higher.

gl_rasterizer: Allow rendering without fragment shader

 shader/texture: Implement AOFFI and PTP for TLD4 and TLD4S

Rendering without a fragment shader is usually used in depth-only
passes.

The job of this abstraction is to provide staging buffers for temporary
operations. Think of image uploads or buffer uploads to device memory.

It automatically deletes unused buffers.

This object's job is to contain an image and manage its transitions.
Since Nvidia hardware doesn't know what a transition is but Vulkan
requires them anyway, we have to state track image subresources
individually.

To avoid the overhead of tracking each subresource in images with many
subresources (think of cubemap arrays with several mipmaps), this commit
tracks when subresources have diverged. As long as this doesn't happen
we can check the state of the first subresource (that will be shared
with all subresources) and update accordingly.

Image transitions are deferred to the scheduler command buffer.