This manages two kinds of streaming buffers: one for unified memory
models and one for dedicated GPUs. The first one skips the copy from the
staging buffer to the real buffer, since it creates an unified buffer.

This implementation waits for all fences to finish their operation
before "invalidating". This is suboptimal since it should allocate
another buffer or start searching from the beginning. There is room for
improvement here.

This could also handle AMD's "pinned" memory (a heap with 256 MiB) that
seems to be designed for buffer streaming.

vk_scheduler: Implement a scheduler

gl_rasterizer_cache: Fixup parameter order in layered swizzle

vk_memory_manager: Fixup commit interval allocation

VKMemoryCommitImpl was using as the end of its interval "begin + end".
That ended up wasting memory.

The scheduler abstracts command buffer and fence management with an
interface that's able to do OpenGL-like operations on Vulkan command
buffers.

It returns by value a command buffer and fence that have to be used for
subsequent operations until Flush or Finish is executed, after that the
current execution context (the pair of command buffers and fences) gets
invalidated a new one must be fetched. Thankfully validation layers will
quickly detect if this is skipped throwing an error due to modifications
to a sent command buffer.

vk_memory_manager: Implement memory manager

gl_state: Synchronize gl_state even when state is disabled

video_core: Remove usages of System::GetInstance() within the engines

* Fixes Unicode Key File Directories

Adds code so that when loading a file it converts to UTF16 first, to
ensure the files can be opened. Code borrowed from FileUtil::Exists.

* Update src/core/crypto/key_manager.cpp

Co-Authored-By: Jungorend <Jungorend@users.noreply.github.com>

* Update src/core/crypto/key_manager.cpp

Co-Authored-By: Jungorend <Jungorend@users.noreply.github.com>

* Using FileUtil instead to be cleaner.

* Update src/core/crypto/key_manager.cpp

Co-Authored-By: Jungorend <Jungorend@users.noreply.github.com>

service/nvflinger: Relocate definitions of Layer and Display to the vi service

These are more closely related to the vi service as opposed to the
intermediary nvflinger.

This also places them in their relevant subfolder, as future changes to
these will likely result in subclassing to represent various displays
and services, as they're done within the service itself on hardware.

The reasoning for prefixing the display and layer source files is to
avoid potential clashing if two files with the same name are compiled
(e.g. if 'display.cpp/.h' or 'layer.cpp/.h' is added to another service
at any point), which MSVC will actually warn against. This prevents that
case from occurring.

This also presently coverts the std::array introduced within
f45c25aa back to a std::vector to allow
the forward declaration of the Display type. Forward declaring a type
within a std::vector is allowed since the introduction of N4510
(http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4510.html) by
Zhihao Yuan.

A memory manager object handles the memory allocations for a device. It
allocates chunks of Vulkan memory objects and then suballocates.

vk_resource_manager: Implement fence and command buffer allocator

audio_core/buffer: Make const and non-const getter for samples consistent

address_arbiter: Use nested namespaces where applicable

renderer_opengl: respect the sRGB colorspace for the screenshot feature

Port citra-emu/citra#4197: "threadsafe_queue: Add PopWait and use it where possible "

This way proper const/non-const selection can occur.

A fairly trivial change. Other sections of the codebase use nested
namespaces instead of separate namespaces here. This one must have just
been overlooked.

Avoids the use of the global accessor in favor of explicitly making the
system a dependency within the interface.

core_timing: De-globalize core_timing facilities

Gets rid of the largest set of mutable global state within the core.
This also paves a way for eliminating usages of GetInstance() on the
System class as a follow-up.

Note that no behavioral changes have been made, and this simply extracts
the functionality into a class. This also has the benefit of making
dependencies on the core timing functionality explicit within the
relevant interfaces.

Previously, we were completely ignoring for screenshots whether the game uses RGB or sRGB.
This resulted in screenshot colors that looked off for some titles.

There are some potential edge cases where gl_state may fail to track the
state if a related state changes while the toggle is disabled or it
didn't change. This addresses that.

gl_rasterizer_cache: Get rid of variable shadowing

gl_shader_decompiler: Re-implement TLDS lod

Handles a pool of resources protected by fences. Manages resource
overflow allocating more resources.

This class is intended to be used through inheritance.

CommitFence iterates a pool of fences until one is found. If all fences
are being used at the same time, allocate more.

A fence watch is used to keep track of the usage of a fence and protect
a resource or set of resources without having to inherit from their
handlers.

Fences take ownership of objects, protecting them from GPU-side or
driver-side concurrent access. They must be commited from the resource
manager. Their usage flow is: commit the fence from the resource
manager, protect resources with it and use them, send the fence to an
execution queue and Wait for it if needed and then call Release. Used
resources will automatically be signaled when they are free to be
reused.

VKResource is an interface that gets signaled by a fence when it is free
to be reused.

vulkan: Add dependencies and device abstraction

core_timing: Make EmptyTimedCallback a local variable