| Age | Commit message (Collapse) | Author |
|---|
|
gl_rasterizer/vk_memory_manager: Silence -Wreorder warnings
|
|
maxwell_3d: Use std::bitset to manage dirty flags
|
|
common: Move Quaternion, Rectangle, Vec2, Vec3, and Vec4 into the Common namespace
|
|
declaration order
Reorders members in the order that they would actually be initialized
in. Silences a -Wreorder warning.
|
|
declaration order
Orders the members in the order they would actually be initialized in.
Silences a -Wreorder warning.
|
|
This is only necessary in headers. Silences a warning with clang.
|
|
These types are within the common library, so they should be within the
Common namespace.
|
|
|
|
|
|
|
|
shader_decompiler: Improve Accuracy of Attribute Interpolation.
|
|
rasterizer_cache_gl: Only do fast layered copy on the same format.
|
|
video_core/dma_pusher: The full list of headers at once.
|
|
vk_scheduler: Implement a scheduler
|
|
gl_rasterizer_cache: Fixup parameter order in layered swizzle
|
|
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
|
|
As fetching command list headers and and the list of command headers is a fixed 1:1 relation now, they can be implemented within a single call.
This cleans up the Step() logic quite a bit.
|
|
Fetching every u32 from memory leads to a big overhead. So let's fetch all of them as a block if possible.
This reduces the Memory::* calls by the dma_pusher by a factor of 10.
|
|
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
|
|
renderer_opengl: respect the sRGB colorspace for the screenshot feature
|
|
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
|
|
|
|
glCopyImageSubData does not support different formats.
|
|
Implement BGRA8 framebuffer format
|
|
VKDevice contains all the data required to manage and initialize a
physical device. Its intention is to be passed across Vulkan objects to
query device-specific data (for example the logical device and the
dispatch loader).
|
|
We already store a reference to the system instance that the renderer is
created with, so we don't need to refer to the system instance via
Core::System::GetInstance()
|
|
core_timing: Rename CoreTiming namespace to Core::Timing
|
|
kepler_compute: Fixup assert and rename the engine
|
|
|
|
Avoids shadowing the members of the struct itself, which results in a
-Wshadow warning.
|
|
This file is intended to be included instead of vulkan/vulkan.hpp. It
includes declarations of unique handlers using a dynamic dispatcher
instead of a static one (which would require linking to a Vulkan
library).
|
