Linuxydable/suyu
1
0
Fork 0
forked from suyu/suyu
Code Pull requests Activity
suyu/src/video_core/renderer_vulkan/vk_rasterizer.h

217 lines
8.2 KiB
C++
Raw Normal View History

vk_rasterizer: Add placeholder
2020-01-07 01:10:56 +01:00
// Copyright 2019 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
#include <array>
#include <bitset>
#include <memory>
#include <utility>
#include <vector>
#include <boost/container/static_vector.hpp>
#include "common/common_types.h"
accelerateDMA: Fixes and feedback.
2021-07-12 04:10:42 +02:00
#include "video_core/engines/maxwell_dma.h"
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
#include "video_core/rasterizer_accelerated.h"
vk_rasterizer: Add placeholder
2020-01-07 01:10:56 +01:00
#include "video_core/rasterizer_interface.h"
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 06:25:23 +01:00
#include "video_core/renderer_vulkan/blit_image.h"
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
#include "video_core/renderer_vulkan/fixed_pipeline_state.h"
#include "video_core/renderer_vulkan/vk_buffer_cache.h"
#include "video_core/renderer_vulkan/vk_descriptor_pool.h"
vk_fence_manager: Initial implementation
2020-03-17 01:43:05 +01:00
#include "video_core/renderer_vulkan/vk_fence_manager.h"
fixed_pipeline_cache: Use dirty flags to lazily update key Use dirty flags to avoid building pipeline key from scratch on each draw call. This saves a bit of unnecesary work on each draw call.
2021-01-19 06:04:27 +01:00
#include "video_core/renderer_vulkan/vk_graphics_pipeline.h"
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
#include "video_core/renderer_vulkan/vk_pipeline_cache.h"
vk_query_cache: Implement generic query cache on Vulkan
2020-02-11 22:59:44 +01:00
#include "video_core/renderer_vulkan/vk_query_cache.h"
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
#include "video_core/renderer_vulkan/vk_scheduler.h"
#include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
#include "video_core/renderer_vulkan/vk_texture_cache.h"
#include "video_core/renderer_vulkan/vk_update_descriptor.h"
Vk Async pipeline compilation
2020-07-28 06:08:02 +02:00
#include "video_core/shader/async_shaders.h"
vulkan_common: Move allocator to the common directory Allow using the abstraction from the OpenGL backend.
2021-01-03 22:17:57 +01:00
#include "video_core/vulkan_common/vulkan_memory_allocator.h"
vulkan_common: Rename renderer_vulkan/wrapper.h to vulkan_common/vulkan_wrapper.h Allows sharing Vulkan wrapper code between different rendering backends.
2020-12-25 01:30:11 +01:00
#include "video_core/vulkan_common/vulkan_wrapper.h"
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
namespace Core {
class System;
}
namespace Core::Frontend {
class EmuWindow;
}
namespace Tegra::Engines {
class Maxwell3D;
}
namespace Vulkan {
struct VKScreenInfo;
vk_state_tracker: Initial implementation Add support for render targets and viewports.
2020-02-21 00:35:53 +01:00
class StateTracker;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
accelerateDMA: Accelerate Buffer Copies.
2021-07-10 18:19:10 +02:00
class AccelerateDMA : public Tegra::Engines::AccelerateDMAInterface {
public:
accelerateDMA: Fixes and feedback.
2021-07-12 04:10:42 +02:00
explicit AccelerateDMA(BufferCache& buffer_cache);
accelerateDMA: Accelerate Buffer Copies.
2021-07-10 18:19:10 +02:00
accelerateDMA: Fixes and feedback.
2021-07-12 04:10:42 +02:00
bool BufferCopy(GPUVAddr start_address, GPUVAddr end_address, u64 amount) override;
accelerateDMA: Accelerate Buffer Copies.
2021-07-10 18:19:10 +02:00
DMAEngine: Accelerate BufferClear
2021-07-13 03:33:08 +02:00
bool BufferClear(GPUVAddr src_address, u64 amount, u32 value) override;
accelerateDMA: Fixes and feedback.
2021-07-12 04:10:42 +02:00
private:
BufferCache& buffer_cache;
accelerateDMA: Accelerate Buffer Copies.
2021-07-10 18:19:10 +02:00
};
vk_query_cache: Implement generic query cache on Vulkan
2020-02-11 22:59:44 +01:00
class RasterizerVulkan final : public VideoCore::RasterizerAccelerated {
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
public:
video_core: Resolve more variable shadowing scenarios pt.3 Cleans out the rest of the occurrences of variable shadowing and makes any further occurrences of shadowing compiler errors.
2020-12-05 17:40:14 +01:00
explicit RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
Tegra::MemoryManager& gpu_memory_, Core::Memory::Memory& cpu_memory_,
renderer_vulkan: Rename VKDevice to Device The "VK" prefix predates the "Vulkan" namespace. It was carried around the codebase for consistency. "VKDevice" currently is a bad alias with "VkDevice" (only an upcase character of difference) that can cause confusion. Rename all instances of it.
2020-12-26 05:10:53 +01:00
VKScreenInfo& screen_info_, const Device& device_,
renderer_vulkan: Rename Vulkan memory manager to memory allocator "Memory manager" collides with the guest GPU memory manager, and a memory allocator sounds closer to what the abstraction aims to be.
2021-01-03 22:11:01 +01:00
MemoryAllocator& memory_allocator_, StateTracker& state_tracker_,
video_core: Resolve more variable shadowing scenarios pt.3 Cleans out the rest of the occurrences of variable shadowing and makes any further occurrences of shadowing compiler errors.
2020-12-05 17:40:14 +01:00
VKScheduler& scheduler_);
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
~RasterizerVulkan() override;
maxwell_3d: Unify draw methods Pass instanced state of a draw invocation as an argument instead of having two separate virtual methods.
2020-02-14 22:09:37 +01:00
void Draw(bool is_indexed, bool is_instanced) override;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
void Clear() override;
void DispatchCompute(GPUVAddr code_addr) override;
vk_query_cache: Implement generic query cache on Vulkan
2020-02-11 22:59:44 +01:00
void ResetCounter(VideoCore::QueryType type) override;
void Query(GPUVAddr gpu_addr, VideoCore::QueryType type, std::optional<u64> timestamp) override;
video_core: Reimplement the buffer cache Reimplement the buffer cache using cached bindings and page level granularity for modification tracking. This also drops the usage of shared pointers and virtual functions from the cache. - Bindings are cached, allowing to skip work when the game changes few bits between draws. - OpenGL Assembly shaders no longer copy when a region has been modified from the GPU to emulate constant buffers, instead GL_EXT_memory_object is used to alias sub-buffers within the same allocation. - OpenGL Assembly shaders stream constant buffer data using glProgramBufferParametersIuivNV, from NV_parameter_buffer_object. In theory this should save one hash table resolve inside the driver compared to glBufferSubData. - A new OpenGL stream buffer is implemented based on fences for drivers that are not Nvidia's proprietary, due to their low performance on partial glBufferSubData calls synchronized with 3D rendering (that some games use a lot). - Most optimizations are shared between APIs now, allowing Vulkan to cache more bindings than before, skipping unnecesarry work. This commit adds the necessary infrastructure to use Vulkan object from OpenGL. Overall, it improves performance and fixes some bugs present on the old cache. There are still some edge cases hit by some games that harm performance on some vendors, this are planned to be fixed in later commits.
2021-01-17 00:48:58 +01:00
void BindGraphicsUniformBuffer(size_t stage, u32 index, GPUVAddr gpu_addr, u32 size) override;
buffer_cache: Simplify uniform disabling logic
2021-06-01 19:26:43 +02:00
void DisableGraphicsUniformBuffer(size_t stage, u32 index) override;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
void FlushAll() override;
GPU: Setup Flush/Invalidate to use VAddr instead of CacheAddr
2020-04-05 18:58:23 +02:00
void FlushRegion(VAddr addr, u64 size) override;
ThreadManager: Sync async reads on accurate gpu.
2020-02-18 03:29:04 +01:00
bool MustFlushRegion(VAddr addr, u64 size) override;
GPU: Setup Flush/Invalidate to use VAddr instead of CacheAddr
2020-04-05 18:58:23 +02:00
void InvalidateRegion(VAddr addr, u64 size) override;
GPU: Refactor synchronization on Async GPU
2020-02-16 14:51:37 +01:00
void OnCPUWrite(VAddr addr, u64 size) override;
void SyncGuestHost() override;
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 06:25:23 +01:00
void UnmapMemory(VAddr addr, u64 size) override;
Texture Cache: Initial Implementation of Sparse Textures.
2021-06-12 15:52:27 +02:00
void ModifyGPUMemory(GPUVAddr addr, u64 size) override;
FenceManager: Manage syncpoints and rename fences to semaphores.
2020-02-19 18:40:37 +01:00
void SignalSemaphore(GPUVAddr addr, u32 value) override;
void SignalSyncPoint(u32 value) override;
Fence Manager: Add fences on Reference Count.
2021-07-06 22:23:10 +02:00
void SignalReference() override;
Rasterizer: Document SignalFence & ReleaseFences and setup skeletons on Vulkan.
2020-02-18 18:24:38 +01:00
void ReleaseFences() override;
GPU: Setup Flush/Invalidate to use VAddr instead of CacheAddr
2020-04-05 18:58:23 +02:00
void FlushAndInvalidateRegion(VAddr addr, u64 size) override;
{maxwell_3d,buffer_cache}: Implement memory barriers using 3D registers Drop MemoryBarrier from the buffer cache and use Maxwell3D's register WaitForIdle. To implement this on OpenGL we just call glMemoryBarrier with the necessary bits. Vulkan lacks this synchronization primitive, so we set an event and immediately wait for it. This is not a pretty solution, but it's what Vulkan can do without submitting the current command buffer to the queue (which ends up being more expensive on the CPU).
2020-04-28 07:14:11 +02:00
void WaitForIdle() override;
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 06:25:23 +01:00
void FragmentBarrier() override;
void TiledCacheBarrier() override;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
void FlushCommands() override;
void TickFrame() override;
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 06:25:23 +01:00
bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Surface& src,
const Tegra::Engines::Fermi2D::Surface& dst,
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
const Tegra::Engines::Fermi2D::Config& copy_config) override;
accelerateDMA: Accelerate Buffer Copies.
2021-07-10 18:19:10 +02:00
Tegra::Engines::AccelerateDMAInterface& AccessAccelerateDMA() override;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
bool AccelerateDisplay(const Tegra::FramebufferConfig& config, VAddr framebuffer_addr,
u32 pixel_stride) override;
Vk Async pipeline compilation
2020-07-28 06:08:02 +02:00
VideoCommon::Shader::AsyncShaders& GetAsyncShaders() {
return async_shaders;
}
const VideoCommon::Shader::AsyncShaders& GetAsyncShaders() const {
return async_shaders;
}
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
/// Maximum supported size that a constbuffer can have in bytes.
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 06:25:23 +01:00
static constexpr size_t MaxConstbufferSize = 0x10000;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
static_assert(MaxConstbufferSize % (4 * sizeof(float)) == 0,
"The maximum size of a constbuffer must be a multiple of the size of GLvec4");
private:
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 06:25:23 +01:00
static constexpr size_t MAX_TEXTURES = 192;
static constexpr size_t MAX_IMAGES = 48;
static constexpr size_t MAX_IMAGE_VIEWS = MAX_TEXTURES + MAX_IMAGES;
static constexpr VkDeviceSize DEFAULT_BUFFER_SIZE = 4 * sizeof(float);
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
void FlushWork();
/// Setup descriptors in the graphics pipeline.
video_core: Reimplement the buffer cache Reimplement the buffer cache using cached bindings and page level granularity for modification tracking. This also drops the usage of shared pointers and virtual functions from the cache. - Bindings are cached, allowing to skip work when the game changes few bits between draws. - OpenGL Assembly shaders no longer copy when a region has been modified from the GPU to emulate constant buffers, instead GL_EXT_memory_object is used to alias sub-buffers within the same allocation. - OpenGL Assembly shaders stream constant buffer data using glProgramBufferParametersIuivNV, from NV_parameter_buffer_object. In theory this should save one hash table resolve inside the driver compared to glBufferSubData. - A new OpenGL stream buffer is implemented based on fences for drivers that are not Nvidia's proprietary, due to their low performance on partial glBufferSubData calls synchronized with 3D rendering (that some games use a lot). - Most optimizations are shared between APIs now, allowing Vulkan to cache more bindings than before, skipping unnecesarry work. This commit adds the necessary infrastructure to use Vulkan object from OpenGL. Overall, it improves performance and fixes some bugs present on the old cache. There are still some edge cases hit by some games that harm performance on some vendors, this are planned to be fixed in later commits.
2021-01-17 00:48:58 +01:00
void SetupShaderDescriptors(const std::array<Shader*, Maxwell::MaxShaderProgram>& shaders,
bool is_indexed);
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
void UpdateDynamicStates();
vk_rasterizer: Implement transform feedback binding zero
2020-03-06 09:11:18 +01:00
void BeginTransformFeedback();
void EndTransformFeedback();
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
/// Setup uniform texels in the graphics pipeline.
void SetupGraphicsUniformTexels(const ShaderEntries& entries, std::size_t stage);
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
/// Setup textures in the graphics pipeline.
void SetupGraphicsTextures(const ShaderEntries& entries, std::size_t stage);
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
/// Setup storage texels in the graphics pipeline.
void SetupGraphicsStorageTexels(const ShaderEntries& entries, std::size_t stage);
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
/// Setup images in the graphics pipeline.
void SetupGraphicsImages(const ShaderEntries& entries, std::size_t stage);
/// Setup texel buffers in the compute pipeline.
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
void SetupComputeUniformTexels(const ShaderEntries& entries);
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
/// Setup textures in the compute pipeline.
void SetupComputeTextures(const ShaderEntries& entries);
vk_rasterizer: Implement storage texels This is the equivalent of an image buffer on OpenGL. - Used by Octopath Traveler
2020-06-02 02:41:07 +02:00
/// Setup storage texels in the compute pipeline.
void SetupComputeStorageTexels(const ShaderEntries& entries);
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
/// Setup images in the compute pipeline.
void SetupComputeImages(const ShaderEntries& entries);
vk_rasterizer: Pass Maxwell registers to dynamic updates
2020-02-21 05:21:57 +01:00
void UpdateViewportsState(Tegra::Engines::Maxwell3D::Regs& regs);
void UpdateScissorsState(Tegra::Engines::Maxwell3D::Regs& regs);
void UpdateDepthBias(Tegra::Engines::Maxwell3D::Regs& regs);
void UpdateBlendConstants(Tegra::Engines::Maxwell3D::Regs& regs);
void UpdateDepthBounds(Tegra::Engines::Maxwell3D::Regs& regs);
void UpdateStencilFaces(Tegra::Engines::Maxwell3D::Regs& regs);
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
vk_rasterizer: Use VK_EXT_extended_dynamic_state
2020-06-22 08:03:27 +02:00
void UpdateCullMode(Tegra::Engines::Maxwell3D::Regs& regs);
void UpdateDepthBoundsTestEnable(Tegra::Engines::Maxwell3D::Regs& regs);
void UpdateDepthTestEnable(Tegra::Engines::Maxwell3D::Regs& regs);
void UpdateDepthWriteEnable(Tegra::Engines::Maxwell3D::Regs& regs);
void UpdateDepthCompareOp(Tegra::Engines::Maxwell3D::Regs& regs);
void UpdateFrontFace(Tegra::Engines::Maxwell3D::Regs& regs);
void UpdateStencilOp(Tegra::Engines::Maxwell3D::Regs& regs);
void UpdateStencilTestEnable(Tegra::Engines::Maxwell3D::Regs& regs);
video_core: Remove all Core::System references in renderer Now that the GPU is initialized when video backends are initialized, it's no longer needed to query components once the game is running: it can be done when yuzu is booting. This allows us to pass components between constructors and in the process remove all Core::System references in the video backend.
2020-06-12 02:24:45 +02:00
Tegra::GPU& gpu;
Tegra::MemoryManager& gpu_memory;
Tegra::Engines::Maxwell3D& maxwell3d;
Tegra::Engines::KeplerCompute& kepler_compute;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
VKScreenInfo& screen_info;
renderer_vulkan: Rename VKDevice to Device The "VK" prefix predates the "Vulkan" namespace. It was carried around the codebase for consistency. "VKDevice" currently is a bad alias with "VkDevice" (only an upcase character of difference) that can cause confusion. Rename all instances of it.
2020-12-26 05:10:53 +01:00
const Device& device;
renderer_vulkan: Rename Vulkan memory manager to memory allocator "Memory manager" collides with the guest GPU memory manager, and a memory allocator sounds closer to what the abstraction aims to be.
2021-01-03 22:11:01 +01:00
MemoryAllocator& memory_allocator;
vk_state_tracker: Initial implementation Add support for render targets and viewports.
2020-02-21 00:35:53 +01:00
StateTracker& state_tracker;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
VKScheduler& scheduler;
vk_memory_manager: Improve memory manager and its API Fix a bug where the memory allocator could leave gaps between commits. To fix this the allocation algorithm was reworked, although it's still short in number of lines of code. Rework the allocation API to self-contained movable objects instead of naively using an unique_ptr to do the job for us. Remove the VK prefix.
2020-12-31 02:58:05 +01:00
StagingBufferPool staging_pool;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
VKDescriptorPool descriptor_pool;
VKUpdateDescriptorQueue update_descriptor_queue;
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 06:25:23 +01:00
BlitImageHelper blit_image;
renderer_vulkan: Accelerate ASTC decoding Co-Authored-By: Rodrigo Locatti <reinuseslisp@airmail.cc>
2021-02-13 22:49:24 +01:00
ASTCDecoderPass astc_decoder_pass;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
fixed_pipeline_cache: Use dirty flags to lazily update key Use dirty flags to avoid building pipeline key from scratch on each draw call. This saves a bit of unnecesary work on each draw call.
2021-01-19 06:04:27 +01:00
GraphicsPipelineCacheKey graphics_key;
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 06:25:23 +01:00
TextureCacheRuntime texture_cache_runtime;
TextureCache texture_cache;
video_core: Reimplement the buffer cache Reimplement the buffer cache using cached bindings and page level granularity for modification tracking. This also drops the usage of shared pointers and virtual functions from the cache. - Bindings are cached, allowing to skip work when the game changes few bits between draws. - OpenGL Assembly shaders no longer copy when a region has been modified from the GPU to emulate constant buffers, instead GL_EXT_memory_object is used to alias sub-buffers within the same allocation. - OpenGL Assembly shaders stream constant buffer data using glProgramBufferParametersIuivNV, from NV_parameter_buffer_object. In theory this should save one hash table resolve inside the driver compared to glBufferSubData. - A new OpenGL stream buffer is implemented based on fences for drivers that are not Nvidia's proprietary, due to their low performance on partial glBufferSubData calls synchronized with 3D rendering (that some games use a lot). - Most optimizations are shared between APIs now, allowing Vulkan to cache more bindings than before, skipping unnecesarry work. This commit adds the necessary infrastructure to use Vulkan object from OpenGL. Overall, it improves performance and fixes some bugs present on the old cache. There are still some edge cases hit by some games that harm performance on some vendors, this are planned to be fixed in later commits.
2021-01-17 00:48:58 +01:00
BufferCacheRuntime buffer_cache_runtime;
BufferCache buffer_cache;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
VKPipelineCache pipeline_cache;
vk_query_cache: Implement generic query cache on Vulkan
2020-02-11 22:59:44 +01:00
VKQueryCache query_cache;
accelerateDMA: Accelerate Buffer Copies.
2021-07-10 18:19:10 +02:00
AccelerateDMA accelerate_dma;
video_core: Remove all Core::System references in renderer Now that the GPU is initialized when video backends are initialized, it's no longer needed to query components once the game is running: it can be done when yuzu is booting. This allows us to pass components between constructors and in the process remove all Core::System references in the video backend.
2020-06-12 02:24:45 +02:00
VKFenceManager fence_manager;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
{maxwell_3d,buffer_cache}: Implement memory barriers using 3D registers Drop MemoryBarrier from the buffer cache and use Maxwell3D's register WaitForIdle. To implement this on OpenGL we just call glMemoryBarrier with the necessary bits. Vulkan lacks this synchronization primitive, so we set an event and immediately wait for it. This is not a pretty solution, but it's what Vulkan can do without submitting the current command buffer to the queue (which ends up being more expensive on the CPU).
2020-04-28 07:14:11 +02:00
vk::Event wfi_event;
Address feedback. Bruteforce delete duplicates
2020-07-30 21:41:11 +02:00
VideoCommon::Shader::AsyncShaders async_shaders;
vk_rasterizer: Add lazy default buffer maker and use it for empty buffers Introduce a default buffer getter that lazily constructs an empty buffer. This is intended to match OpenGL's buffer 0. Use this for disabled vertex and uniform buffers. While we are at it, include vertex buffer usages for staging buffers to silence validation errors.
2020-04-22 00:20:53 +02:00
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 06:25:23 +01:00
boost::container::static_vector<u32, MAX_IMAGE_VIEWS> image_view_indices;
std::array<VideoCommon::ImageViewId, MAX_IMAGE_VIEWS> image_view_ids;
boost::container::static_vector<VkSampler, MAX_TEXTURES> sampler_handles;
vk_rasterizer: Implement Vulkan's rasterizer This abstraction is Vulkan's equivalent to OpenGL's rasterizer. It takes care of joining all parts of the backend and rendering accordingly on demand.
2020-01-17 02:55:23 +01:00
u32 draw_counter = 0;
};
vk_rasterizer: Add placeholder
2020-01-07 01:10:56 +01:00
} // namespace Vulkan
Copy permalink