N-archive/suyu
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu.git synced 2024-12-23 08:50:57 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #5133 from lioncash/video-shadow2

Browse source 
video_core: Resolve more variable shadowing scenarios pt.2
This commit is contained in:
Chloe 2020-12-05 23:45:00 +11:00 committed by GitHub
commit f2f346e110
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
39 changed files with 305 additions and 296 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
src/video_core/command_classes/codecs/vp9.cpp
View file

@ -374,43 +374,43 @@ void VP9::InsertEntropy(u64 offset, Vp9EntropyProbs& dst) {
} }
Vp9FrameContainer VP9::GetCurrentFrame(const NvdecCommon::NvdecRegisters& state) { Vp9FrameContainer VP9::GetCurrentFrame(const NvdecCommon::NvdecRegisters& state) {
Vp9FrameContainer frame{}; Vp9FrameContainer current_frame{};
{ {
gpu.SyncGuestHost(); gpu.SyncGuestHost();
frame.info = GetVp9PictureInfo(state); current_frame.info = GetVp9PictureInfo(state);
frame.bit_stream.resize(frame.info.bitstream_size); current_frame.bit_stream.resize(current_frame.info.bitstream_size);
gpu.MemoryManager().ReadBlock(state.frame_bitstream_offset, frame.bit_stream.data(), gpu.MemoryManager().ReadBlock(state.frame_bitstream_offset, current_frame.bit_stream.data(),
frame.info.bitstream_size); current_frame.info.bitstream_size);
} }
// Buffer two frames, saving the last show frame info // Buffer two frames, saving the last show frame info
if (!next_next_frame.bit_stream.empty()) { if (!next_next_frame.bit_stream.empty()) {
Vp9FrameContainer temp{ Vp9FrameContainer temp{
.info = frame.info, .info = current_frame.info,
.bit_stream = std::move(frame.bit_stream), .bit_stream = std::move(current_frame.bit_stream),
}; };
next_next_frame.info.show_frame = frame.info.last_frame_shown; next_next_frame.info.show_frame = current_frame.info.last_frame_shown;
frame.info = next_next_frame.info; current_frame.info = next_next_frame.info;
frame.bit_stream = std::move(next_next_frame.bit_stream); current_frame.bit_stream = std::move(next_next_frame.bit_stream);
next_next_frame = std::move(temp); next_next_frame = std::move(temp);
if (!next_frame.bit_stream.empty()) { if (!next_frame.bit_stream.empty()) {
Vp9FrameContainer temp2{ Vp9FrameContainer temp2{
.info = frame.info, .info = current_frame.info,
.bit_stream = std::move(frame.bit_stream), .bit_stream = std::move(current_frame.bit_stream),
}; };
next_frame.info.show_frame = frame.info.last_frame_shown; next_frame.info.show_frame = current_frame.info.last_frame_shown;
frame.info = next_frame.info; current_frame.info = next_frame.info;
frame.bit_stream = std::move(next_frame.bit_stream); current_frame.bit_stream = std::move(next_frame.bit_stream);
next_frame = std::move(temp2); next_frame = std::move(temp2);
} else { } else {
next_frame.info = frame.info; next_frame.info = current_frame.info;
next_frame.bit_stream = std::move(frame.bit_stream); next_frame.bit_stream = std::move(current_frame.bit_stream);
} }
} else { } else {
next_next_frame.info = frame.info; next_next_frame.info = current_frame.info;
next_next_frame.bit_stream = std::move(frame.bit_stream); next_next_frame.bit_stream = std::move(current_frame.bit_stream);
} }
return frame; return current_frame;
} }
std::vector<u8> VP9::ComposeCompressedHeader() { std::vector<u8> VP9::ComposeCompressedHeader() {

4
src/video_core/renderer_vulkan/renderer_vulkan.cpp
View file

@ -243,8 +243,8 @@ std::string BuildCommaSeparatedExtensions(std::vector<std::string> available_ext
RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_, RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
Core::Frontend::EmuWindow& emu_window, Core::Frontend::EmuWindow& emu_window,
Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_, Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
std::unique_ptr<Core::Frontend::GraphicsContext> context) std::unique_ptr<Core::Frontend::GraphicsContext> context_)
: RendererBase{emu_window, std::move(context)}, telemetry_session{telemetry_session_}, : RendererBase{emu_window, std::move(context_)}, telemetry_session{telemetry_session_},
cpu_memory{cpu_memory_}, gpu{gpu_} {} cpu_memory{cpu_memory_}, gpu{gpu_} {}
RendererVulkan::~RendererVulkan() { RendererVulkan::~RendererVulkan() {

6
src/video_core/renderer_vulkan/renderer_vulkan.h
View file

@ -45,9 +45,9 @@ struct VKScreenInfo {
class RendererVulkan final : public VideoCore::RendererBase { class RendererVulkan final : public VideoCore::RendererBase {
public: public:
explicit RendererVulkan(Core::TelemetrySession& telemtry_session, explicit RendererVulkan(Core::TelemetrySession& telemtry_session,
Core::Frontend::EmuWindow& emu_window, Core::Memory::Memory& cpu_memory, Core::Frontend::EmuWindow& emu_window,
Tegra::GPU& gpu, Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
std::unique_ptr<Core::Frontend::GraphicsContext> context); std::unique_ptr<Core::Frontend::GraphicsContext> context_);
~RendererVulkan() override; ~RendererVulkan() override;
bool Init() override; bool Init() override;

40
src/video_core/renderer_vulkan/vk_compute_pass.cpp
View file

@ -461,15 +461,15 @@ VkDescriptorSet VKComputePass::CommitDescriptorSet(
return set; return set;
} }
QuadArrayPass::QuadArrayPass(const VKDevice& device, VKScheduler& scheduler, QuadArrayPass::QuadArrayPass(const VKDevice& device_, VKScheduler& scheduler_,
VKDescriptorPool& descriptor_pool, VKDescriptorPool& descriptor_pool_,
VKStagingBufferPool& staging_buffer_pool, VKStagingBufferPool& staging_buffer_pool_,
VKUpdateDescriptorQueue& update_descriptor_queue) VKUpdateDescriptorQueue& update_descriptor_queue_)
: VKComputePass(device, descriptor_pool, BuildQuadArrayPassDescriptorSetLayoutBinding(), : VKComputePass(device_, descriptor_pool_, BuildQuadArrayPassDescriptorSetLayoutBinding(),
BuildQuadArrayPassDescriptorUpdateTemplateEntry(), BuildQuadArrayPassDescriptorUpdateTemplateEntry(),
BuildComputePushConstantRange(sizeof(u32)), std::size(quad_array), quad_array), BuildComputePushConstantRange(sizeof(u32)), std::size(quad_array), quad_array),
scheduler{scheduler}, staging_buffer_pool{staging_buffer_pool}, scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
update_descriptor_queue{update_descriptor_queue} {} update_descriptor_queue{update_descriptor_queue_} {}
QuadArrayPass::~QuadArrayPass() = default; QuadArrayPass::~QuadArrayPass() = default;
@ -510,14 +510,14 @@ std::pair<VkBuffer, VkDeviceSize> QuadArrayPass::Assemble(u32 num_vertices, u32
return {*buffer.handle, 0}; return {*buffer.handle, 0};
} }
Uint8Pass::Uint8Pass(const VKDevice& device, VKScheduler& scheduler, Uint8Pass::Uint8Pass(const VKDevice& device_, VKScheduler& scheduler_,
VKDescriptorPool& descriptor_pool, VKStagingBufferPool& staging_buffer_pool, VKDescriptorPool& descriptor_pool_, VKStagingBufferPool& staging_buffer_pool_,
VKUpdateDescriptorQueue& update_descriptor_queue) VKUpdateDescriptorQueue& update_descriptor_queue_)
: VKComputePass(device, descriptor_pool, BuildInputOutputDescriptorSetBindings(), : VKComputePass(device_, descriptor_pool_, BuildInputOutputDescriptorSetBindings(),
BuildInputOutputDescriptorUpdateTemplate(), {}, std::size(uint8_pass), BuildInputOutputDescriptorUpdateTemplate(), {}, std::size(uint8_pass),
uint8_pass), uint8_pass),
scheduler{scheduler}, staging_buffer_pool{staging_buffer_pool}, scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
update_descriptor_queue{update_descriptor_queue} {} update_descriptor_queue{update_descriptor_queue_} {}
Uint8Pass::~Uint8Pass() = default; Uint8Pass::~Uint8Pass() = default;
@ -555,16 +555,16 @@ std::pair<VkBuffer, u64> Uint8Pass::Assemble(u32 num_vertices, VkBuffer src_buff
return {*buffer.handle, 0}; return {*buffer.handle, 0};
} }
QuadIndexedPass::QuadIndexedPass(const VKDevice& device, VKScheduler& scheduler, QuadIndexedPass::QuadIndexedPass(const VKDevice& device_, VKScheduler& scheduler_,
VKDescriptorPool& descriptor_pool, VKDescriptorPool& descriptor_pool_,
VKStagingBufferPool& staging_buffer_pool, VKStagingBufferPool& staging_buffer_pool_,
VKUpdateDescriptorQueue& update_descriptor_queue) VKUpdateDescriptorQueue& update_descriptor_queue_)
: VKComputePass(device, descriptor_pool, BuildInputOutputDescriptorSetBindings(), : VKComputePass(device_, descriptor_pool_, BuildInputOutputDescriptorSetBindings(),
BuildInputOutputDescriptorUpdateTemplate(), BuildInputOutputDescriptorUpdateTemplate(),
BuildComputePushConstantRange(sizeof(u32) * 2), std::size(QUAD_INDEXED_SPV), BuildComputePushConstantRange(sizeof(u32) * 2), std::size(QUAD_INDEXED_SPV),
QUAD_INDEXED_SPV), QUAD_INDEXED_SPV),
scheduler{scheduler}, staging_buffer_pool{staging_buffer_pool}, scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
update_descriptor_queue{update_descriptor_queue} {} update_descriptor_queue{update_descriptor_queue_} {}
QuadIndexedPass::~QuadIndexedPass() = default; QuadIndexedPass::~QuadIndexedPass() = default;

23
src/video_core/renderer_vulkan/vk_compute_pass.h
View file

@ -43,10 +43,10 @@ private:
class QuadArrayPass final : public VKComputePass { class QuadArrayPass final : public VKComputePass {
public: public:
explicit QuadArrayPass(const VKDevice& device, VKScheduler& scheduler, explicit QuadArrayPass(const VKDevice& device_, VKScheduler& scheduler_,
VKDescriptorPool& descriptor_pool, VKDescriptorPool& descriptor_pool_,
VKStagingBufferPool& staging_buffer_pool, VKStagingBufferPool& staging_buffer_pool_,
VKUpdateDescriptorQueue& update_descriptor_queue); VKUpdateDescriptorQueue& update_descriptor_queue_);
~QuadArrayPass(); ~QuadArrayPass();
std::pair<VkBuffer, VkDeviceSize> Assemble(u32 num_vertices, u32 first); std::pair<VkBuffer, VkDeviceSize> Assemble(u32 num_vertices, u32 first);
@ -59,9 +59,10 @@ private:
class Uint8Pass final : public VKComputePass { class Uint8Pass final : public VKComputePass {
public: public:
explicit Uint8Pass(const VKDevice& device, VKScheduler& scheduler, explicit Uint8Pass(const VKDevice& device_, VKScheduler& scheduler_,
VKDescriptorPool& descriptor_pool, VKStagingBufferPool& staging_buffer_pool, VKDescriptorPool& descriptor_pool_,
VKUpdateDescriptorQueue& update_descriptor_queue); VKStagingBufferPool& staging_buffer_pool_,
VKUpdateDescriptorQueue& update_descriptor_queue_);
~Uint8Pass(); ~Uint8Pass();
std::pair<VkBuffer, u64> Assemble(u32 num_vertices, VkBuffer src_buffer, u64 src_offset); std::pair<VkBuffer, u64> Assemble(u32 num_vertices, VkBuffer src_buffer, u64 src_offset);
@ -74,10 +75,10 @@ private:
class QuadIndexedPass final : public VKComputePass { class QuadIndexedPass final : public VKComputePass {
public: public:
explicit QuadIndexedPass(const VKDevice& device, VKScheduler& scheduler, explicit QuadIndexedPass(const VKDevice& device_, VKScheduler& scheduler_,
VKDescriptorPool& descriptor_pool, VKDescriptorPool& descriptor_pool_,
VKStagingBufferPool& staging_buffer_pool, VKStagingBufferPool& staging_buffer_pool_,
VKUpdateDescriptorQueue& update_descriptor_queue); VKUpdateDescriptorQueue& update_descriptor_queue_);
~QuadIndexedPass(); ~QuadIndexedPass();
std::pair<VkBuffer, u64> Assemble(Tegra::Engines::Maxwell3D::Regs::IndexFormat index_format, std::pair<VkBuffer, u64> Assemble(Tegra::Engines::Maxwell3D::Regs::IndexFormat index_format,

16
src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
View file

@ -15,16 +15,16 @@
namespace Vulkan { namespace Vulkan {
VKComputePipeline::VKComputePipeline(const VKDevice& device, VKScheduler& scheduler, VKComputePipeline::VKComputePipeline(const VKDevice& device_, VKScheduler& scheduler_,
VKDescriptorPool& descriptor_pool, VKDescriptorPool& descriptor_pool_,
VKUpdateDescriptorQueue& update_descriptor_queue, VKUpdateDescriptorQueue& update_descriptor_queue_,
const SPIRVShader& shader) const SPIRVShader& shader_)
: device{device}, scheduler{scheduler}, entries{shader.entries}, : device{device_}, scheduler{scheduler_}, entries{shader_.entries},
descriptor_set_layout{CreateDescriptorSetLayout()}, descriptor_set_layout{CreateDescriptorSetLayout()},
descriptor_allocator{descriptor_pool, *descriptor_set_layout}, descriptor_allocator{descriptor_pool_, *descriptor_set_layout},
update_descriptor_queue{update_descriptor_queue}, layout{CreatePipelineLayout()}, update_descriptor_queue{update_descriptor_queue_}, layout{CreatePipelineLayout()},
descriptor_template{CreateDescriptorUpdateTemplate()}, descriptor_template{CreateDescriptorUpdateTemplate()},
shader_module{CreateShaderModule(shader.code)}, pipeline{CreatePipeline()} {} shader_module{CreateShaderModule(shader_.code)}, pipeline{CreatePipeline()} {}
VKComputePipeline::~VKComputePipeline() = default; VKComputePipeline::~VKComputePipeline() = default;

8
src/video_core/renderer_vulkan/vk_compute_pipeline.h
View file

@ -17,10 +17,10 @@ class VKUpdateDescriptorQueue;
class VKComputePipeline final { class VKComputePipeline final {
public: public:
explicit VKComputePipeline(const VKDevice& device, VKScheduler& scheduler, explicit VKComputePipeline(const VKDevice& device_, VKScheduler& scheduler_,
VKDescriptorPool& descriptor_pool, VKDescriptorPool& descriptor_pool_,
VKUpdateDescriptorQueue& update_descriptor_queue, VKUpdateDescriptorQueue& update_descriptor_queue_,
const SPIRVShader& shader); const SPIRVShader& shader_);
~VKComputePipeline(); ~VKComputePipeline();
VkDescriptorSet CommitDescriptorSet(); VkDescriptorSet CommitDescriptorSet();

16
src/video_core/renderer_vulkan/vk_device.cpp
View file

@ -491,8 +491,8 @@ bool VKDevice::IsOptimalAstcSupported(const VkPhysicalDeviceFeatures& features)
VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
VK_FORMAT_FEATURE_TRANSFER_DST_BIT}; VK_FORMAT_FEATURE_TRANSFER_DST_BIT};
for (const auto format : astc_formats) { for (const auto format : astc_formats) {
const auto format_properties{physical.GetFormatProperties(format)}; const auto physical_format_properties{physical.GetFormatProperties(format)};
if (!(format_properties.optimalTilingFeatures & format_feature_usage)) { if ((physical_format_properties.optimalTilingFeatures & format_feature_usage) == 0) {
return false; return false;
} }
} }
@ -644,8 +644,8 @@ std::vector<const char*> VKDevice::LoadExtensions() {
VkPhysicalDeviceFeatures2KHR features; VkPhysicalDeviceFeatures2KHR features;
features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR; features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
VkPhysicalDeviceProperties2KHR properties; VkPhysicalDeviceProperties2KHR physical_properties;
properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR; physical_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
if (has_khr_shader_float16_int8) { if (has_khr_shader_float16_int8) {
VkPhysicalDeviceFloat16Int8FeaturesKHR float16_int8_features; VkPhysicalDeviceFloat16Int8FeaturesKHR float16_int8_features;
@ -670,8 +670,8 @@ std::vector<const char*> VKDevice::LoadExtensions() {
subgroup_properties.sType = subgroup_properties.sType =
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT; VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT;
subgroup_properties.pNext = nullptr; subgroup_properties.pNext = nullptr;
properties.pNext = &subgroup_properties; physical_properties.pNext = &subgroup_properties;
physical.GetProperties2KHR(properties); physical.GetProperties2KHR(physical_properties);
is_warp_potentially_bigger = subgroup_properties.maxSubgroupSize > GuestWarpSize; is_warp_potentially_bigger = subgroup_properties.maxSubgroupSize > GuestWarpSize;
@ -695,8 +695,8 @@ std::vector<const char*> VKDevice::LoadExtensions() {
VkPhysicalDeviceTransformFeedbackPropertiesEXT tfb_properties; VkPhysicalDeviceTransformFeedbackPropertiesEXT tfb_properties;
tfb_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; tfb_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
tfb_properties.pNext = nullptr; tfb_properties.pNext = nullptr;
properties.pNext = &tfb_properties; physical_properties.pNext = &tfb_properties;
physical.GetProperties2KHR(properties); physical.GetProperties2KHR(physical_properties);
if (tfb_features.transformFeedback && tfb_features.geometryStreams && if (tfb_features.transformFeedback && tfb_features.geometryStreams &&
tfb_properties.maxTransformFeedbackStreams >= 4 && tfb_properties.maxTransformFeedbackStreams >= 4 &&

22
src/video_core/renderer_vulkan/vk_fence_manager.cpp
View file

@ -14,12 +14,13 @@
namespace Vulkan { namespace Vulkan {
InnerFence::InnerFence(const VKDevice& device, VKScheduler& scheduler, u32 payload, bool is_stubbed) InnerFence::InnerFence(const VKDevice& device_, VKScheduler& scheduler_, u32 payload_,
: VideoCommon::FenceBase(payload, is_stubbed), device{device}, scheduler{scheduler} {} bool is_stubbed_)
: FenceBase{payload_, is_stubbed_}, device{device_}, scheduler{scheduler_} {}
InnerFence::InnerFence(const VKDevice& device, VKScheduler& scheduler, GPUVAddr address, InnerFence::InnerFence(const VKDevice& device_, VKScheduler& scheduler_, GPUVAddr address_,
u32 payload, bool is_stubbed) u32 payload_, bool is_stubbed_)
: VideoCommon::FenceBase(address, payload, is_stubbed), device{device}, scheduler{scheduler} {} : FenceBase{address_, payload_, is_stubbed_}, device{device_}, scheduler{scheduler_} {}
InnerFence::~InnerFence() = default; InnerFence::~InnerFence() = default;
@ -71,11 +72,12 @@ bool InnerFence::IsEventSignalled() const {
} }
} }
VKFenceManager::VKFenceManager(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu, VKFenceManager::VKFenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
Tegra::MemoryManager& memory_manager, VKTextureCache& texture_cache, Tegra::MemoryManager& memory_manager_,
VKBufferCache& buffer_cache, VKQueryCache& query_cache, VKTextureCache& texture_cache_, VKBufferCache& buffer_cache_,
const VKDevice& device_, VKScheduler& scheduler_) VKQueryCache& query_cache_, const VKDevice& device_,
: GenericFenceManager(rasterizer, gpu, texture_cache, buffer_cache, query_cache), VKScheduler& scheduler_)
: GenericFenceManager{rasterizer_, gpu_, texture_cache_, buffer_cache_, query_cache_},
device{device_}, scheduler{scheduler_} {} device{device_}, scheduler{scheduler_} {}
Fence VKFenceManager::CreateFence(u32 value, bool is_stubbed) { Fence VKFenceManager::CreateFence(u32 value, bool is_stubbed) {

16
src/video_core/renderer_vulkan/vk_fence_manager.h
View file

@ -28,10 +28,10 @@ class VKTextureCache;
class InnerFence : public VideoCommon::FenceBase { class InnerFence : public VideoCommon::FenceBase {
public: public:
explicit InnerFence(const VKDevice& device, VKScheduler& scheduler, u32 payload, explicit InnerFence(const VKDevice& device_, VKScheduler& scheduler_, u32 payload_,
bool is_stubbed); bool is_stubbed_);
explicit InnerFence(const VKDevice& device, VKScheduler& scheduler, GPUVAddr address, explicit InnerFence(const VKDevice& device_, VKScheduler& scheduler_, GPUVAddr address_,
u32 payload, bool is_stubbed); u32 payload_, bool is_stubbed_);
~InnerFence(); ~InnerFence();
void Queue(); void Queue();
@ -55,10 +55,10 @@ using GenericFenceManager =
class VKFenceManager final : public GenericFenceManager { class VKFenceManager final : public GenericFenceManager {
public: public:
explicit VKFenceManager(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu, explicit VKFenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
Tegra::MemoryManager& memory_manager, VKTextureCache& texture_cache, Tegra::MemoryManager& memory_manager_, VKTextureCache& texture_cache_,
VKBufferCache& buffer_cache, VKQueryCache& query_cache, VKBufferCache& buffer_cache_, VKQueryCache& query_cache_,
const VKDevice& device, VKScheduler& scheduler); const VKDevice& device_, VKScheduler& scheduler_);
protected: protected:
Fence CreateFence(u32 value, bool is_stubbed) override; Fence CreateFence(u32 value, bool is_stubbed) override;

38
src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
View file

@ -71,21 +71,21 @@ VkViewportSwizzleNV UnpackViewportSwizzle(u16 swizzle) {
} // Anonymous namespace } // Anonymous namespace
VKGraphicsPipeline::VKGraphicsPipeline(const VKDevice& device, VKScheduler& scheduler, VKGraphicsPipeline::VKGraphicsPipeline(const VKDevice& device_, VKScheduler& scheduler_,
VKDescriptorPool& descriptor_pool, VKDescriptorPool& descriptor_pool_,
VKUpdateDescriptorQueue& update_descriptor_queue, VKUpdateDescriptorQueue& update_descriptor_queue_,
VKRenderPassCache& renderpass_cache, VKRenderPassCache& renderpass_cache_,
const GraphicsPipelineCacheKey& key, const GraphicsPipelineCacheKey& key_,
vk::Span<VkDescriptorSetLayoutBinding> bindings, vk::Span<VkDescriptorSetLayoutBinding> bindings_,
const SPIRVProgram& program) const SPIRVProgram& program_)
: device{device}, scheduler{scheduler}, cache_key{key}, hash{cache_key.Hash()}, : device{device_}, scheduler{scheduler_}, cache_key{key_}, hash{cache_key.Hash()},
descriptor_set_layout{CreateDescriptorSetLayout(bindings)}, descriptor_set_layout{CreateDescriptorSetLayout(bindings_)},
descriptor_allocator{descriptor_pool, *descriptor_set_layout}, descriptor_allocator{descriptor_pool_, *descriptor_set_layout},
update_descriptor_queue{update_descriptor_queue}, layout{CreatePipelineLayout()}, update_descriptor_queue{update_descriptor_queue_}, layout{CreatePipelineLayout()},
descriptor_template{CreateDescriptorUpdateTemplate(program)}, modules{CreateShaderModules( descriptor_template{CreateDescriptorUpdateTemplate(program_)}, modules{CreateShaderModules(
program)}, program_)},
renderpass{renderpass_cache.GetRenderPass(cache_key.renderpass_params)}, renderpass{renderpass_cache_.GetRenderPass(cache_key.renderpass_params)},
pipeline{CreatePipeline(cache_key.renderpass_params, program)} {} pipeline{CreatePipeline(cache_key.renderpass_params, program_)} {}
VKGraphicsPipeline::~VKGraphicsPipeline() = default; VKGraphicsPipeline::~VKGraphicsPipeline() = default;
@ -162,8 +162,8 @@ std::vector<vk::ShaderModule> VKGraphicsPipeline::CreateShaderModules(
.codeSize = 0, .codeSize = 0,
}; };
std::vector<vk::ShaderModule> modules; std::vector<vk::ShaderModule> shader_modules;
modules.reserve(Maxwell::MaxShaderStage); shader_modules.reserve(Maxwell::MaxShaderStage);
for (std::size_t i = 0; i < Maxwell::MaxShaderStage; ++i) { for (std::size_t i = 0; i < Maxwell::MaxShaderStage; ++i) {
const auto& stage = program[i]; const auto& stage = program[i];
if (!stage) { if (!stage) {
@ -174,9 +174,9 @@ std::vector<vk::ShaderModule> VKGraphicsPipeline::CreateShaderModules(
ci.codeSize = stage->code.size() * sizeof(u32); ci.codeSize = stage->code.size() * sizeof(u32);
ci.pCode = stage->code.data(); ci.pCode = stage->code.data();
modules.push_back(device.GetLogical().CreateShaderModule(ci)); shader_modules.push_back(device.GetLogical().CreateShaderModule(ci));
} }
return modules; return shader_modules;
} }
vk::Pipeline VKGraphicsPipeline::CreatePipeline(const RenderPassParams& renderpass_params, vk::Pipeline VKGraphicsPipeline::CreatePipeline(const RenderPassParams& renderpass_params,

14
src/video_core/renderer_vulkan/vk_graphics_pipeline.h
View file

@ -51,13 +51,13 @@ using SPIRVProgram = std::array<std::optional<SPIRVShader>, Maxwell::MaxShaderSt
class VKGraphicsPipeline final { class VKGraphicsPipeline final {
public: public:
explicit VKGraphicsPipeline(const VKDevice& device, VKScheduler& scheduler, explicit VKGraphicsPipeline(const VKDevice& device_, VKScheduler& scheduler_,
VKDescriptorPool& descriptor_pool, VKDescriptorPool& descriptor_pool_,
VKUpdateDescriptorQueue& update_descriptor_queue, VKUpdateDescriptorQueue& update_descriptor_queue_,
VKRenderPassCache& renderpass_cache, VKRenderPassCache& renderpass_cache_,
const GraphicsPipelineCacheKey& key, const GraphicsPipelineCacheKey& key_,
vk::Span<VkDescriptorSetLayoutBinding> bindings, vk::Span<VkDescriptorSetLayoutBinding> bindings_,
const SPIRVProgram& program); const SPIRVProgram& program_);
~VKGraphicsPipeline(); ~VKGraphicsPipeline();
VkDescriptorSet CommitDescriptorSet(); VkDescriptorSet CommitDescriptorSet();

14
src/video_core/renderer_vulkan/vk_image.cpp
View file

@ -13,18 +13,18 @@
namespace Vulkan { namespace Vulkan {
VKImage::VKImage(const VKDevice& device, VKScheduler& scheduler, const VkImageCreateInfo& image_ci, VKImage::VKImage(const VKDevice& device_, VKScheduler& scheduler_,
VkImageAspectFlags aspect_mask) const VkImageCreateInfo& image_ci_, VkImageAspectFlags aspect_mask_)
: device{device}, scheduler{scheduler}, format{image_ci.format}, aspect_mask{aspect_mask}, : device{device_}, scheduler{scheduler_}, format{image_ci_.format}, aspect_mask{aspect_mask_},
image_num_layers{image_ci.arrayLayers}, image_num_levels{image_ci.mipLevels} { image_num_layers{image_ci_.arrayLayers}, image_num_levels{image_ci_.mipLevels} {
UNIMPLEMENTED_IF_MSG(image_ci.queueFamilyIndexCount != 0, UNIMPLEMENTED_IF_MSG(image_ci_.queueFamilyIndexCount != 0,
"Queue family tracking is not implemented"); "Queue family tracking is not implemented");
image = device.GetLogical().CreateImage(image_ci); image = device_.GetLogical().CreateImage(image_ci_);
const u32 num_ranges = image_num_layers * image_num_levels; const u32 num_ranges = image_num_layers * image_num_levels;
barriers.resize(num_ranges); barriers.resize(num_ranges);
subrange_states.resize(num_ranges, {{}, image_ci.initialLayout}); subrange_states.resize(num_ranges, {{}, image_ci_.initialLayout});
} }
VKImage::~VKImage() = default; VKImage::~VKImage() = default;

4
src/video_core/renderer_vulkan/vk_image.h
View file

@ -17,8 +17,8 @@ class VKScheduler;
class VKImage { class VKImage {
public: public:
explicit VKImage(const VKDevice& device, VKScheduler& scheduler, explicit VKImage(const VKDevice& device_, VKScheduler& scheduler_,
const VkImageCreateInfo& image_ci, VkImageAspectFlags aspect_mask); const VkImageCreateInfo& image_ci_, VkImageAspectFlags aspect_mask_);
~VKImage(); ~VKImage();
/// Records in the passed command buffer an image transition and updates the state of the image. /// Records in the passed command buffer an image transition and updates the state of the image.

18
src/video_core/renderer_vulkan/vk_memory_manager.cpp
View file

@ -29,10 +29,10 @@ u64 GetAllocationChunkSize(u64 required_size) {
class VKMemoryAllocation final { class VKMemoryAllocation final {
public: public:
explicit VKMemoryAllocation(const VKDevice& device, vk::DeviceMemory memory, explicit VKMemoryAllocation(const VKDevice& device_, vk::DeviceMemory memory_,
VkMemoryPropertyFlags properties, u64 allocation_size, u32 type) VkMemoryPropertyFlags properties_, u64 allocation_size_, u32 type_)
: device{device}, memory{std::move(memory)}, properties{properties}, : device{device_}, memory{std::move(memory_)}, properties{properties_},
allocation_size{allocation_size}, shifted_type{ShiftType(type)} {} allocation_size{allocation_size_}, shifted_type{ShiftType(type_)} {}
VKMemoryCommit Commit(VkDeviceSize commit_size, VkDeviceSize alignment) { VKMemoryCommit Commit(VkDeviceSize commit_size, VkDeviceSize alignment) {
auto found = TryFindFreeSection(free_iterator, allocation_size, auto found = TryFindFreeSection(free_iterator, allocation_size,
@ -117,8 +117,8 @@ private:
std::vector<const VKMemoryCommitImpl*> commits; std::vector<const VKMemoryCommitImpl*> commits;
}; };
VKMemoryManager::VKMemoryManager(const VKDevice& device) VKMemoryManager::VKMemoryManager(const VKDevice& device_)
: device{device}, properties{device.GetPhysical().GetMemoryProperties()} {} : device{device_}, properties{device_.GetPhysical().GetMemoryProperties()} {}
VKMemoryManager::~VKMemoryManager() = default; VKMemoryManager::~VKMemoryManager() = default;
@ -207,9 +207,9 @@ VKMemoryCommit VKMemoryManager::TryAllocCommit(const VkMemoryRequirements& requi
return {}; return {};
} }
VKMemoryCommitImpl::VKMemoryCommitImpl(const VKDevice& device, VKMemoryAllocation* allocation, VKMemoryCommitImpl::VKMemoryCommitImpl(const VKDevice& device_, VKMemoryAllocation* allocation_,
const vk::DeviceMemory& memory, u64 begin, u64 end) const vk::DeviceMemory& memory_, u64 begin_, u64 end_)
: device{device}, memory{memory}, interval{begin, end}, allocation{allocation} {} : device{device_}, memory{memory_}, interval{begin_, end_}, allocation{allocation_} {}
VKMemoryCommitImpl::~VKMemoryCommitImpl() { VKMemoryCommitImpl::~VKMemoryCommitImpl() {
allocation->Free(this); allocation->Free(this);

10
src/video_core/renderer_vulkan/vk_memory_manager.h
View file

@ -21,7 +21,7 @@ using VKMemoryCommit = std::unique_ptr<VKMemoryCommitImpl>;
class VKMemoryManager final { class VKMemoryManager final {
public: public:
explicit VKMemoryManager(const VKDevice& device); explicit VKMemoryManager(const VKDevice& device_);
VKMemoryManager(const VKMemoryManager&) = delete; VKMemoryManager(const VKMemoryManager&) = delete;
~VKMemoryManager(); ~VKMemoryManager();
@ -58,8 +58,8 @@ class VKMemoryCommitImpl final {
friend MemoryMap; friend MemoryMap;
public: public:
explicit VKMemoryCommitImpl(const VKDevice& device, VKMemoryAllocation* allocation, explicit VKMemoryCommitImpl(const VKDevice& device_, VKMemoryAllocation* allocation_,
const vk::DeviceMemory& memory, u64 begin, u64 end); const vk::DeviceMemory& memory_, u64 begin_, u64 end_);
~VKMemoryCommitImpl(); ~VKMemoryCommitImpl();
/// Maps a memory region and returns a pointer to it. /// Maps a memory region and returns a pointer to it.
@ -93,8 +93,8 @@ private:
/// Holds ownership of a memory map. /// Holds ownership of a memory map.
class MemoryMap final { class MemoryMap final {
public: public:
explicit MemoryMap(const VKMemoryCommitImpl* commit, u8* address) explicit MemoryMap(const VKMemoryCommitImpl* commit_, u8* address_)
: commit{commit}, address{address} {} : commit{commit_}, address{address_} {}
~MemoryMap() { ~MemoryMap() {
if (commit) { if (commit) {

30
src/video_core/renderer_vulkan/vk_query_cache.cpp
View file

@ -66,15 +66,15 @@ void QueryPool::Reserve(std::pair<VkQueryPool, u32> query) {
usage[pool_index * GROW_STEP + static_cast<std::ptrdiff_t>(query.second)] = false; usage[pool_index * GROW_STEP + static_cast<std::ptrdiff_t>(query.second)] = false;
} }
VKQueryCache::VKQueryCache(VideoCore::RasterizerInterface& rasterizer, VKQueryCache::VKQueryCache(VideoCore::RasterizerInterface& rasterizer_,
Tegra::Engines::Maxwell3D& maxwell3d, Tegra::MemoryManager& gpu_memory, Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
const VKDevice& device, VKScheduler& scheduler) const VKDevice& device_, VKScheduler& scheduler_)
: VideoCommon::QueryCacheBase<VKQueryCache, CachedQuery, CounterStream, : QueryCacheBase<VKQueryCache, CachedQuery, CounterStream, HostCounter>{rasterizer_, maxwell3d_,
HostCounter>{rasterizer, maxwell3d, gpu_memory}, gpu_memory_},
device{device}, scheduler{scheduler}, query_pools{ device{device_}, scheduler{scheduler_}, query_pools{
QueryPool{device, scheduler, QueryPool{device_, scheduler_,
QueryType::SamplesPassed}, QueryType::SamplesPassed},
} {} } {}
VKQueryCache::~VKQueryCache() { VKQueryCache::~VKQueryCache() {
// TODO(Rodrigo): This is a hack to destroy all HostCounter instances before the base class // TODO(Rodrigo): This is a hack to destroy all HostCounter instances before the base class
@ -95,12 +95,12 @@ void VKQueryCache::Reserve(QueryType type, std::pair<VkQueryPool, u32> query) {
query_pools[static_cast<std::size_t>(type)].Reserve(query); query_pools[static_cast<std::size_t>(type)].Reserve(query);
} }
HostCounter::HostCounter(VKQueryCache& cache, std::shared_ptr<HostCounter> dependency, HostCounter::HostCounter(VKQueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
QueryType type) QueryType type_)
: VideoCommon::HostCounterBase<VKQueryCache, HostCounter>{std::move(dependency)}, cache{cache}, : HostCounterBase<VKQueryCache, HostCounter>{std::move(dependency_)}, cache{cache_},
type{type}, query{cache.AllocateQuery(type)}, tick{cache.Scheduler().CurrentTick()} { type{type_}, query{cache_.AllocateQuery(type_)}, tick{cache_.Scheduler().CurrentTick()} {
const vk::Device* logical = &cache.Device().GetLogical(); const vk::Device* logical = &cache_.Device().GetLogical();
cache.Scheduler().Record([logical, query = query](vk::CommandBuffer cmdbuf) { cache_.Scheduler().Record([logical, query = query](vk::CommandBuffer cmdbuf) {
logical->ResetQueryPoolEXT(query.first, query.second, 1); logical->ResetQueryPoolEXT(query.first, query.second, 1);
cmdbuf.BeginQuery(query.first, query.second, VK_QUERY_CONTROL_PRECISE_BIT); cmdbuf.BeginQuery(query.first, query.second, VK_QUERY_CONTROL_PRECISE_BIT);
}); });

10
src/video_core/renderer_vulkan/vk_query_cache.h
View file

@ -53,9 +53,9 @@ private:
class VKQueryCache final class VKQueryCache final
: public VideoCommon::QueryCacheBase<VKQueryCache, CachedQuery, CounterStream, HostCounter> { : public VideoCommon::QueryCacheBase<VKQueryCache, CachedQuery, CounterStream, HostCounter> {
public: public:
explicit VKQueryCache(VideoCore::RasterizerInterface& rasterizer, explicit VKQueryCache(VideoCore::RasterizerInterface& rasterizer_,
Tegra::Engines::Maxwell3D& maxwell3d, Tegra::MemoryManager& gpu_memory, Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
const VKDevice& device, VKScheduler& scheduler); const VKDevice& device_, VKScheduler& scheduler_);
~VKQueryCache(); ~VKQueryCache();
std::pair<VkQueryPool, u32> AllocateQuery(VideoCore::QueryType type); std::pair<VkQueryPool, u32> AllocateQuery(VideoCore::QueryType type);
@ -78,8 +78,8 @@ private:
class HostCounter final : public VideoCommon::HostCounterBase<VKQueryCache, HostCounter> { class HostCounter final : public VideoCommon::HostCounterBase<VKQueryCache, HostCounter> {
public: public:
explicit HostCounter(VKQueryCache& cache, std::shared_ptr<HostCounter> dependency, explicit HostCounter(VKQueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
VideoCore::QueryType type); VideoCore::QueryType type_);
~HostCounter(); ~HostCounter();
void EndQuery(); void EndQuery();

17
src/video_core/renderer_vulkan/vk_rasterizer.cpp
View file

@ -904,15 +904,14 @@ void RasterizerVulkan::SetupShaderDescriptors(
texture_cache.GuardSamplers(false); texture_cache.GuardSamplers(false);
} }
void RasterizerVulkan::SetupImageTransitions( void RasterizerVulkan::SetupImageTransitions(Texceptions texceptions, const ColorAttachments& color,
Texceptions texceptions, const std::array<View, Maxwell::NumRenderTargets>& color_attachments, const ZetaAttachment& zeta) {
const View& zeta_attachment) {
TransitionImages(sampled_views, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_ACCESS_SHADER_READ_BIT); TransitionImages(sampled_views, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_ACCESS_SHADER_READ_BIT);
TransitionImages(image_views, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, TransitionImages(image_views, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT); VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT);
for (std::size_t rt = 0; rt < std::size(color_attachments); ++rt) { for (std::size_t rt = 0; rt < color.size(); ++rt) {
const auto color_attachment = color_attachments[rt]; const auto color_attachment = color[rt];
if (color_attachment == nullptr) { if (color_attachment == nullptr) {
continue; continue;
} }
@ -923,13 +922,13 @@ void RasterizerVulkan::SetupImageTransitions(
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT); VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
} }
if (zeta_attachment != nullptr) { if (zeta != nullptr) {
const auto image_layout = texceptions[ZETA_TEXCEPTION_INDEX] const auto image_layout = texceptions[ZETA_TEXCEPTION_INDEX]
? VK_IMAGE_LAYOUT_GENERAL ? VK_IMAGE_LAYOUT_GENERAL
: VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; : VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
zeta_attachment->Transition(image_layout, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, zeta->Transition(image_layout, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT); VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
} }
} }

12
src/video_core/renderer_vulkan/vk_rasterizer.h
View file

@ -160,6 +160,9 @@ private:
bool is_indexed = 0; bool is_indexed = 0;
}; };
using ColorAttachments = std::array<View, Maxwell::NumRenderTargets>;
using ZetaAttachment = View;
using Texceptions = std::bitset<Maxwell::NumRenderTargets + 1>; using Texceptions = std::bitset<Maxwell::NumRenderTargets + 1>;
static constexpr std::size_t ZETA_TEXCEPTION_INDEX = 8; static constexpr std::size_t ZETA_TEXCEPTION_INDEX = 8;
@ -181,9 +184,8 @@ private:
/// Setup descriptors in the graphics pipeline. /// Setup descriptors in the graphics pipeline.
void SetupShaderDescriptors(const std::array<Shader*, Maxwell::MaxShaderProgram>& shaders); void SetupShaderDescriptors(const std::array<Shader*, Maxwell::MaxShaderProgram>& shaders);
void SetupImageTransitions(Texceptions texceptions, void SetupImageTransitions(Texceptions texceptions, const ColorAttachments& color,
const std::array<View, Maxwell::NumRenderTargets>& color_attachments, const ZetaAttachment& zeta);
const View& zeta_attachment);
void UpdateDynamicStates(); void UpdateDynamicStates();
@ -308,8 +310,8 @@ private:
vk::Event wfi_event; vk::Event wfi_event;
VideoCommon::Shader::AsyncShaders async_shaders; VideoCommon::Shader::AsyncShaders async_shaders;
std::array<View, Maxwell::NumRenderTargets> color_attachments; ColorAttachments color_attachments;
View zeta_attachment; ZetaAttachment zeta_attachment;
std::vector<ImageView> sampled_views; std::vector<ImageView> sampled_views;
std::vector<ImageView> image_views; std::vector<ImageView> image_views;

2
src/video_core/renderer_vulkan/vk_renderpass_cache.cpp
View file

@ -24,7 +24,7 @@ bool RenderPassParams::operator==(const RenderPassParams& rhs) const noexcept {
return std::memcmp(&rhs, this, sizeof *this) == 0; return std::memcmp(&rhs, this, sizeof *this) == 0;
} }
VKRenderPassCache::VKRenderPassCache(const VKDevice& device) : device{device} {} VKRenderPassCache::VKRenderPassCache(const VKDevice& device_) : device{device_} {}
VKRenderPassCache::~VKRenderPassCache() = default; VKRenderPassCache::~VKRenderPassCache() = default;

2
src/video_core/renderer_vulkan/vk_renderpass_cache.h
View file

@ -55,7 +55,7 @@ namespace Vulkan {
class VKRenderPassCache final { class VKRenderPassCache final {
public: public:
explicit VKRenderPassCache(const VKDevice& device); explicit VKRenderPassCache(const VKDevice& device_);
~VKRenderPassCache(); ~VKRenderPassCache();
VkRenderPass GetRenderPass(const RenderPassParams& params); VkRenderPass GetRenderPass(const RenderPassParams& params);

2
src/video_core/renderer_vulkan/vk_sampler_cache.cpp
View file

@ -36,7 +36,7 @@ VkBorderColor ConvertBorderColor(std::array<float, 4> color) {
} // Anonymous namespace } // Anonymous namespace
VKSamplerCache::VKSamplerCache(const VKDevice& device) : device{device} {} VKSamplerCache::VKSamplerCache(const VKDevice& device_) : device{device_} {}
VKSamplerCache::~VKSamplerCache() = default; VKSamplerCache::~VKSamplerCache() = default;

2
src/video_core/renderer_vulkan/vk_sampler_cache.h
View file

@ -14,7 +14,7 @@ class VKDevice;
class VKSamplerCache final : public VideoCommon::SamplerCache<VkSampler, vk::Sampler> { class VKSamplerCache final : public VideoCommon::SamplerCache<VkSampler, vk::Sampler> {
public: public:
explicit VKSamplerCache(const VKDevice& device); explicit VKSamplerCache(const VKDevice& device_);
~VKSamplerCache(); ~VKSamplerCache();
protected: protected:

2
src/video_core/renderer_vulkan/vk_scheduler.h
View file

@ -104,7 +104,7 @@ private:
template <typename T> template <typename T>
class TypedCommand final : public Command { class TypedCommand final : public Command {
public: public:
explicit TypedCommand(T&& command) : command{std::move(command)} {} explicit TypedCommand(T&& command_) : command{std::move(command_)} {}
~TypedCommand() override = default; ~TypedCommand() override = default;
TypedCommand(TypedCommand&&) = delete; TypedCommand(TypedCommand&&) = delete;

28
src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
View file

@ -55,8 +55,8 @@ enum class Type { Void, Bool, Bool2, Float, Int, Uint, HalfFloat };
class Expression final { class Expression final {
public: public:
Expression(Id id, Type type) : id{id}, type{type} { Expression(Id id_, Type type_) : id{id_}, type{type_} {
ASSERT(type != Type::Void); ASSERT(type_ != Type::Void);
} }
Expression() : type{Type::Void} {} Expression() : type{Type::Void} {}
@ -281,12 +281,12 @@ u32 ShaderVersion(const VKDevice& device) {
class SPIRVDecompiler final : public Sirit::Module { class SPIRVDecompiler final : public Sirit::Module {
public: public:
explicit SPIRVDecompiler(const VKDevice& device, const ShaderIR& ir, ShaderType stage, explicit SPIRVDecompiler(const VKDevice& device_, const ShaderIR& ir_, ShaderType stage_,
const Registry& registry, const Specialization& specialization) const Registry& registry_, const Specialization& specialization_)
: Module(ShaderVersion(device)), device{device}, ir{ir}, stage{stage}, : Module(ShaderVersion(device_)), device{device_}, ir{ir_}, stage{stage_},
header{ir.GetHeader()}, registry{registry}, specialization{specialization} { header{ir_.GetHeader()}, registry{registry_}, specialization{specialization_} {
if (stage != ShaderType::Compute) { if (stage_ != ShaderType::Compute) {
transform_feedback = BuildTransformFeedback(registry.GetGraphicsInfo()); transform_feedback = BuildTransformFeedback(registry_.GetGraphicsInfo());
} }
AddCapability(spv::Capability::Shader); AddCapability(spv::Capability::Shader);
@ -330,7 +330,7 @@ public:
if (device.IsFloat16Supported()) { if (device.IsFloat16Supported()) {
AddCapability(spv::Capability::Float16); AddCapability(spv::Capability::Float16);
} }
t_scalar_half = Name(TypeFloat(device.IsFloat16Supported() ? 16 : 32), "scalar_half"); t_scalar_half = Name(TypeFloat(device_.IsFloat16Supported() ? 16 : 32), "scalar_half");
t_half = Name(TypeVector(t_scalar_half, 2), "half"); t_half = Name(TypeVector(t_scalar_half, 2), "half");
const Id main = Decompile(); const Id main = Decompile();
@ -1088,9 +1088,9 @@ private:
indices.point_size = AddBuiltIn(t_float, spv::BuiltIn::PointSize, "point_size"); indices.point_size = AddBuiltIn(t_float, spv::BuiltIn::PointSize, "point_size");
} }
const auto& output_attributes = ir.GetOutputAttributes(); const auto& ir_output_attributes = ir.GetOutputAttributes();
const bool declare_clip_distances = const bool declare_clip_distances = std::any_of(
std::any_of(output_attributes.begin(), output_attributes.end(), [](const auto& index) { ir_output_attributes.begin(), ir_output_attributes.end(), [](const auto& index) {
return index == Attribute::Index::ClipDistances0123 || return index == Attribute::Index::ClipDistances0123 ||
index == Attribute::Index::ClipDistances4567; index == Attribute::Index::ClipDistances4567;
}); });
@ -2891,7 +2891,7 @@ private:
class ExprDecompiler { class ExprDecompiler {
public: public:
explicit ExprDecompiler(SPIRVDecompiler& decomp) : decomp{decomp} {} explicit ExprDecompiler(SPIRVDecompiler& decomp_) : decomp{decomp_} {}
Id operator()(const ExprAnd& expr) { Id operator()(const ExprAnd& expr) {
const Id type_def = decomp.GetTypeDefinition(Type::Bool); const Id type_def = decomp.GetTypeDefinition(Type::Bool);
@ -2947,7 +2947,7 @@ private:
class ASTDecompiler { class ASTDecompiler {
public: public:
explicit ASTDecompiler(SPIRVDecompiler& decomp) : decomp{decomp} {} explicit ASTDecompiler(SPIRVDecompiler& decomp_) : decomp{decomp_} {}
void operator()(const ASTProgram& ast) { void operator()(const ASTProgram& ast) {
ASTNode current = ast.nodes.GetFirst(); ASTNode current = ast.nodes.GetFirst();

8
src/video_core/renderer_vulkan/vk_shader_decompiler.h
View file

@ -30,8 +30,8 @@ constexpr u32 DESCRIPTOR_SET = 0;
class ConstBufferEntry : public VideoCommon::Shader::ConstBuffer { class ConstBufferEntry : public VideoCommon::Shader::ConstBuffer {
public: public:
explicit constexpr ConstBufferEntry(const VideoCommon::Shader::ConstBuffer& entry, u32 index) explicit constexpr ConstBufferEntry(const ConstBuffer& entry_, u32 index_)
: VideoCommon::Shader::ConstBuffer{entry}, index{index} {} : ConstBuffer{entry_}, index{index_} {}
constexpr u32 GetIndex() const { constexpr u32 GetIndex() const {
return index; return index;
@ -43,8 +43,8 @@ private:
class GlobalBufferEntry { class GlobalBufferEntry {
public: public:
constexpr explicit GlobalBufferEntry(u32 cbuf_index, u32 cbuf_offset, bool is_written) constexpr explicit GlobalBufferEntry(u32 cbuf_index_, u32 cbuf_offset_, bool is_written_)
: cbuf_index{cbuf_index}, cbuf_offset{cbuf_offset}, is_written{is_written} {} : cbuf_index{cbuf_index_}, cbuf_offset{cbuf_offset_}, is_written{is_written_} {}
constexpr u32 GetCbufIndex() const { constexpr u32 GetCbufIndex() const {
return cbuf_index; return cbuf_index;

61
src/video_core/renderer_vulkan/vk_texture_cache.cpp
View file

@ -180,19 +180,19 @@ VkImageCreateInfo GenerateImageCreateInfo(const VKDevice& device, const SurfaceP
return ci; return ci;
} }
u32 EncodeSwizzle(Tegra::Texture::SwizzleSource x_source, Tegra::Texture::SwizzleSource y_source, u32 EncodeSwizzle(SwizzleSource x_source, SwizzleSource y_source, SwizzleSource z_source,
Tegra::Texture::SwizzleSource z_source, Tegra::Texture::SwizzleSource w_source) { SwizzleSource w_source) {
return (static_cast<u32>(x_source) << 24) | (static_cast<u32>(y_source) << 16) | return (static_cast<u32>(x_source) << 24) | (static_cast<u32>(y_source) << 16) |
(static_cast<u32>(z_source) << 8) | static_cast<u32>(w_source); (static_cast<u32>(z_source) << 8) | static_cast<u32>(w_source);
} }
} // Anonymous namespace } // Anonymous namespace
CachedSurface::CachedSurface(const VKDevice& device, VKMemoryManager& memory_manager, CachedSurface::CachedSurface(const VKDevice& device_, VKMemoryManager& memory_manager_,
VKScheduler& scheduler, VKStagingBufferPool& staging_pool, VKScheduler& scheduler_, VKStagingBufferPool& staging_pool_,
GPUVAddr gpu_addr, const SurfaceParams& params) GPUVAddr gpu_addr_, const SurfaceParams& params_)
: SurfaceBase<View>{gpu_addr, params, device.IsOptimalAstcSupported()}, device{device}, : SurfaceBase<View>{gpu_addr_, params_, device_.IsOptimalAstcSupported()}, device{device_},
memory_manager{memory_manager}, scheduler{scheduler}, staging_pool{staging_pool} { memory_manager{memory_manager_}, scheduler{scheduler_}, staging_pool{staging_pool_} {
if (params.IsBuffer()) { if (params.IsBuffer()) {
buffer = CreateBuffer(device, params, host_memory_size); buffer = CreateBuffer(device, params, host_memory_size);
commit = memory_manager.Commit(buffer, false); commit = memory_manager.Commit(buffer, false);
@ -234,7 +234,7 @@ void CachedSurface::UploadTexture(const std::vector<u8>& staging_buffer) {
void CachedSurface::DownloadTexture(std::vector<u8>& staging_buffer) { void CachedSurface::DownloadTexture(std::vector<u8>& staging_buffer) {
UNIMPLEMENTED_IF(params.IsBuffer()); UNIMPLEMENTED_IF(params.IsBuffer());
if (params.pixel_format == VideoCore::Surface::PixelFormat::A1B5G5R5_UNORM) { if (params.pixel_format == PixelFormat::A1B5G5R5_UNORM) {
LOG_WARNING(Render_Vulkan, "A1B5G5R5 flushing is stubbed"); LOG_WARNING(Render_Vulkan, "A1B5G5R5 flushing is stubbed");
} }
@ -244,10 +244,10 @@ void CachedSurface::DownloadTexture(std::vector<u8>& staging_buffer) {
FullTransition(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_TRANSFER_READ_BIT, FullTransition(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_TRANSFER_READ_BIT,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
const auto& buffer = staging_pool.GetUnusedBuffer(host_memory_size, true); const auto& unused_buffer = staging_pool.GetUnusedBuffer(host_memory_size, true);
// TODO(Rodrigo): Do this in a single copy // TODO(Rodrigo): Do this in a single copy
for (u32 level = 0; level < params.num_levels; ++level) { for (u32 level = 0; level < params.num_levels; ++level) {
scheduler.Record([image = *image->GetHandle(), buffer = *buffer.handle, scheduler.Record([image = *image->GetHandle(), buffer = *unused_buffer.handle,
copy = GetBufferImageCopy(level)](vk::CommandBuffer cmdbuf) { copy = GetBufferImageCopy(level)](vk::CommandBuffer cmdbuf) {
cmdbuf.CopyImageToBuffer(image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, copy); cmdbuf.CopyImageToBuffer(image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, copy);
}); });
@ -255,16 +255,17 @@ void CachedSurface::DownloadTexture(std::vector<u8>& staging_buffer) {
scheduler.Finish(); scheduler.Finish();
// TODO(Rodrigo): Use an intern buffer for staging buffers and avoid this unnecessary memcpy. // TODO(Rodrigo): Use an intern buffer for staging buffers and avoid this unnecessary memcpy.
std::memcpy(staging_buffer.data(), buffer.commit->Map(host_memory_size), host_memory_size); std::memcpy(staging_buffer.data(), unused_buffer.commit->Map(host_memory_size),
host_memory_size);
} }
void CachedSurface::DecorateSurfaceName() { void CachedSurface::DecorateSurfaceName() {
// TODO(Rodrigo): Add name decorations // TODO(Rodrigo): Add name decorations
} }
View CachedSurface::CreateView(const ViewParams& params) { View CachedSurface::CreateView(const ViewParams& view_params) {
// TODO(Rodrigo): Add name decorations // TODO(Rodrigo): Add name decorations
return views[params] = std::make_shared<CachedSurfaceView>(device, *this, params); return views[view_params] = std::make_shared<CachedSurfaceView>(device, *this, view_params);
} }
void CachedSurface::UploadBuffer(const std::vector<u8>& staging_buffer) { void CachedSurface::UploadBuffer(const std::vector<u8>& staging_buffer) {
@ -348,21 +349,21 @@ VkImageSubresourceRange CachedSurface::GetImageSubresourceRange() const {
static_cast<u32>(params.GetNumLayers())}; static_cast<u32>(params.GetNumLayers())};
} }
CachedSurfaceView::CachedSurfaceView(const VKDevice& device, CachedSurface& surface, CachedSurfaceView::CachedSurfaceView(const VKDevice& device_, CachedSurface& surface_,
const ViewParams& params) const ViewParams& view_params_)
: VideoCommon::ViewBase{params}, params{surface.GetSurfaceParams()}, : ViewBase{view_params_}, surface_params{surface_.GetSurfaceParams()},
image{surface.GetImageHandle()}, buffer_view{surface.GetBufferViewHandle()}, image{surface_.GetImageHandle()}, buffer_view{surface_.GetBufferViewHandle()},
aspect_mask{surface.GetAspectMask()}, device{device}, surface{surface}, aspect_mask{surface_.GetAspectMask()}, device{device_}, surface{surface_},
base_level{params.base_level}, num_levels{params.num_levels}, base_level{view_params_.base_level}, num_levels{view_params_.num_levels},
image_view_type{image ? GetImageViewType(params.target) : VK_IMAGE_VIEW_TYPE_1D} { image_view_type{image ? GetImageViewType(view_params_.target) : VK_IMAGE_VIEW_TYPE_1D} {
if (image_view_type == VK_IMAGE_VIEW_TYPE_3D) { if (image_view_type == VK_IMAGE_VIEW_TYPE_3D) {
base_layer = 0; base_layer = 0;
num_layers = 1; num_layers = 1;
base_slice = params.base_layer; base_slice = view_params_.base_layer;
num_slices = params.num_layers; num_slices = view_params_.num_layers;
} else { } else {
base_layer = params.base_layer; base_layer = view_params_.base_layer;
num_layers = params.num_layers; num_layers = view_params_.num_layers;
} }
} }
@ -384,7 +385,7 @@ VkImageView CachedSurfaceView::GetImageView(SwizzleSource x_source, SwizzleSourc
std::array swizzle{MaxwellToVK::SwizzleSource(x_source), MaxwellToVK::SwizzleSource(y_source), std::array swizzle{MaxwellToVK::SwizzleSource(x_source), MaxwellToVK::SwizzleSource(y_source),
MaxwellToVK::SwizzleSource(z_source), MaxwellToVK::SwizzleSource(w_source)}; MaxwellToVK::SwizzleSource(z_source), MaxwellToVK::SwizzleSource(w_source)};
if (params.pixel_format == VideoCore::Surface::PixelFormat::A1B5G5R5_UNORM) { if (surface_params.pixel_format == PixelFormat::A1B5G5R5_UNORM) {
// A1B5G5R5 is implemented as A1R5G5B5, we have to change the swizzle here. // A1B5G5R5 is implemented as A1R5G5B5, we have to change the swizzle here.
std::swap(swizzle[0], swizzle[2]); std::swap(swizzle[0], swizzle[2]);
} }
@ -395,12 +396,12 @@ VkImageView CachedSurfaceView::GetImageView(SwizzleSource x_source, SwizzleSourc
if (aspect == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) { if (aspect == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
UNIMPLEMENTED_IF(x_source != SwizzleSource::R && x_source != SwizzleSource::G); UNIMPLEMENTED_IF(x_source != SwizzleSource::R && x_source != SwizzleSource::G);
const bool is_first = x_source == SwizzleSource::R; const bool is_first = x_source == SwizzleSource::R;
switch (params.pixel_format) { switch (surface_params.pixel_format) {
case VideoCore::Surface::PixelFormat::D24_UNORM_S8_UINT: case PixelFormat::D24_UNORM_S8_UINT:
case VideoCore::Surface::PixelFormat::D32_FLOAT_S8_UINT: case PixelFormat::D32_FLOAT_S8_UINT:
aspect = is_first ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_STENCIL_BIT; aspect = is_first ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_STENCIL_BIT;
break; break;
case VideoCore::Surface::PixelFormat::S8_UINT_D24_UNORM: case PixelFormat::S8_UINT_D24_UNORM:
aspect = is_first ? VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT; aspect = is_first ? VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT;
break; break;
default: default:
@ -417,7 +418,7 @@ VkImageView CachedSurfaceView::GetImageView(SwizzleSource x_source, SwizzleSourc
if (image_view_type == VK_IMAGE_VIEW_TYPE_3D) { if (image_view_type == VK_IMAGE_VIEW_TYPE_3D) {
ASSERT(base_slice == 0); ASSERT(base_slice == 0);
ASSERT(num_slices == params.depth); ASSERT(num_slices == surface_params.depth);
} }
image_view = device.GetLogical().CreateImageView({ image_view = device.GetLogical().CreateImageView({

18
src/video_core/renderer_vulkan/vk_texture_cache.h
View file

@ -40,9 +40,9 @@ class CachedSurface final : public VideoCommon::SurfaceBase<View> {
friend CachedSurfaceView; friend CachedSurfaceView;
public: public:
explicit CachedSurface(const VKDevice& device, VKMemoryManager& memory_manager, explicit CachedSurface(const VKDevice& device_, VKMemoryManager& memory_manager_,
VKScheduler& scheduler, VKStagingBufferPool& staging_pool, VKScheduler& scheduler_, VKStagingBufferPool& staging_pool_,
GPUVAddr gpu_addr, const SurfaceParams& params); GPUVAddr gpu_addr_, const SurfaceParams& params_);
~CachedSurface(); ~CachedSurface();
void UploadTexture(const std::vector<u8>& staging_buffer) override; void UploadTexture(const std::vector<u8>& staging_buffer) override;
@ -84,7 +84,7 @@ public:
protected: protected:
void DecorateSurfaceName(); void DecorateSurfaceName();
View CreateView(const ViewParams& params) override; View CreateView(const ViewParams& view_params) override;
private: private:
void UploadBuffer(const std::vector<u8>& staging_buffer); void UploadBuffer(const std::vector<u8>& staging_buffer);
@ -110,8 +110,8 @@ private:
class CachedSurfaceView final : public VideoCommon::ViewBase { class CachedSurfaceView final : public VideoCommon::ViewBase {
public: public:
explicit CachedSurfaceView(const VKDevice& device, CachedSurface& surface, explicit CachedSurfaceView(const VKDevice& device_, CachedSurface& surface_,
const ViewParams& params); const ViewParams& view_params_);
~CachedSurfaceView(); ~CachedSurfaceView();
VkImageView GetImageView(Tegra::Texture::SwizzleSource x_source, VkImageView GetImageView(Tegra::Texture::SwizzleSource x_source,
@ -126,11 +126,11 @@ public:
} }
u32 GetWidth() const { u32 GetWidth() const {
return params.GetMipWidth(base_level); return surface_params.GetMipWidth(base_level);
} }
u32 GetHeight() const { u32 GetHeight() const {
return params.GetMipHeight(base_level); return surface_params.GetMipHeight(base_level);
} }
u32 GetNumLayers() const { u32 GetNumLayers() const {
@ -169,7 +169,7 @@ public:
private: private:
// Store a copy of these values to avoid double dereference when reading them // Store a copy of these values to avoid double dereference when reading them
const SurfaceParams params; const SurfaceParams surface_params;
const VkImage image; const VkImage image;
const VkBufferView buffer_view; const VkBufferView buffer_view;
const VkImageAspectFlags aspect_mask; const VkImageAspectFlags aspect_mask;

4
src/video_core/renderer_vulkan/vk_update_descriptor.cpp
View file

@ -14,8 +14,8 @@
namespace Vulkan { namespace Vulkan {
VKUpdateDescriptorQueue::VKUpdateDescriptorQueue(const VKDevice& device, VKScheduler& scheduler) VKUpdateDescriptorQueue::VKUpdateDescriptorQueue(const VKDevice& device_, VKScheduler& scheduler_)
: device{device}, scheduler{scheduler} {} : device{device_}, scheduler{scheduler_} {}
VKUpdateDescriptorQueue::~VKUpdateDescriptorQueue() = default; VKUpdateDescriptorQueue::~VKUpdateDescriptorQueue() = default;

2
src/video_core/renderer_vulkan/vk_update_descriptor.h
View file

@ -31,7 +31,7 @@ struct DescriptorUpdateEntry {
class VKUpdateDescriptorQueue final { class VKUpdateDescriptorQueue final {
public: public:
explicit VKUpdateDescriptorQueue(const VKDevice& device, VKScheduler& scheduler); explicit VKUpdateDescriptorQueue(const VKDevice& device_, VKScheduler& scheduler_);
~VKUpdateDescriptorQueue(); ~VKUpdateDescriptorQueue();
void TickFrame(); void TickFrame();

16
src/video_core/renderer_vulkan/wrapper.cpp
View file

@ -417,7 +417,7 @@ VkResult Free(VkDevice device, VkCommandPool handle, Span<VkCommandBuffer> buffe
} }
Instance Instance::Create(u32 version, Span<const char*> layers, Span<const char*> extensions, Instance Instance::Create(u32 version, Span<const char*> layers, Span<const char*> extensions,
InstanceDispatch& dld) noexcept { InstanceDispatch& dispatch) noexcept {
const VkApplicationInfo application_info{ const VkApplicationInfo application_info{
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
.pNext = nullptr, .pNext = nullptr,
@ -439,17 +439,17 @@ Instance Instance::Create(u32 version, Span<const char*> layers, Span<const char
}; };
VkInstance instance; VkInstance instance;
if (dld.vkCreateInstance(&ci, nullptr, &instance) != VK_SUCCESS) { if (dispatch.vkCreateInstance(&ci, nullptr, &instance) != VK_SUCCESS) {
// Failed to create the instance. // Failed to create the instance.
return {}; return {};
} }
if (!Proc(dld.vkDestroyInstance, dld, "vkDestroyInstance", instance)) { if (!Proc(dispatch.vkDestroyInstance, dispatch, "vkDestroyInstance", instance)) {
// We successfully created an instance but the destroy function couldn't be loaded. // We successfully created an instance but the destroy function couldn't be loaded.
// This is a good moment to panic. // This is a good moment to panic.
return {}; return {};
} }
return Instance(instance, dld); return Instance(instance, dispatch);
} }
std::optional<std::vector<VkPhysicalDevice>> Instance::EnumeratePhysicalDevices() { std::optional<std::vector<VkPhysicalDevice>> Instance::EnumeratePhysicalDevices() {
@ -540,7 +540,7 @@ std::vector<VkImage> SwapchainKHR::GetImages() const {
Device Device::Create(VkPhysicalDevice physical_device, Span<VkDeviceQueueCreateInfo> queues_ci, Device Device::Create(VkPhysicalDevice physical_device, Span<VkDeviceQueueCreateInfo> queues_ci,
Span<const char*> enabled_extensions, const void* next, Span<const char*> enabled_extensions, const void* next,
DeviceDispatch& dld) noexcept { DeviceDispatch& dispatch) noexcept {
const VkDeviceCreateInfo ci{ const VkDeviceCreateInfo ci{
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
.pNext = next, .pNext = next,
@ -555,11 +555,11 @@ Device Device::Create(VkPhysicalDevice physical_device, Span<VkDeviceQueueCreate
}; };
VkDevice device; VkDevice device;
if (dld.vkCreateDevice(physical_device, &ci, nullptr, &device) != VK_SUCCESS) { if (dispatch.vkCreateDevice(physical_device, &ci, nullptr, &device) != VK_SUCCESS) {
return {}; return {};
} }
Load(device, dld); Load(device, dispatch);
return Device(device, dld); return Device(device, dispatch);
} }
Queue Device::GetQueue(u32 family_index) const noexcept { Queue Device::GetQueue(u32 family_index) const noexcept {

25
src/video_core/renderer_vulkan/wrapper.h
View file

@ -52,7 +52,7 @@ public:
/// Construct a span from a pointer and a size. /// Construct a span from a pointer and a size.
/// This is inteded for subranges. /// This is inteded for subranges.
constexpr Span(const T* ptr, std::size_t num) noexcept : ptr{ptr}, num{num} {} constexpr Span(const T* ptr_, std::size_t num_) noexcept : ptr{ptr_}, num{num_} {}
/// Returns the data pointer by the span. /// Returns the data pointer by the span.
constexpr const T* data() const noexcept { constexpr const T* data() const noexcept {
@ -469,9 +469,10 @@ public:
PoolAllocations() = default; PoolAllocations() = default;
/// Construct an allocation. Errors are reported through IsOutOfPoolMemory(). /// Construct an allocation. Errors are reported through IsOutOfPoolMemory().
explicit PoolAllocations(std::unique_ptr<AllocationType[]> allocations, std::size_t num, explicit PoolAllocations(std::unique_ptr<AllocationType[]> allocations_, std::size_t num_,
VkDevice device, PoolType pool, const DeviceDispatch& dld) noexcept VkDevice device_, PoolType pool_, const DeviceDispatch& dld_) noexcept
: allocations{std::move(allocations)}, num{num}, device{device}, pool{pool}, dld{&dld} {} : allocations{std::move(allocations_)}, num{num_}, device{device_}, pool{pool_},
dld{&dld_} {}
/// Copying Vulkan allocations is not supported and will never be. /// Copying Vulkan allocations is not supported and will never be.
PoolAllocations(const PoolAllocations&) = delete; PoolAllocations(const PoolAllocations&) = delete;
@ -565,7 +566,7 @@ class Instance : public Handle<VkInstance, NoOwner, InstanceDispatch> {
public: public:
/// Creates a Vulkan instance. Use "operator bool" for error handling. /// Creates a Vulkan instance. Use "operator bool" for error handling.
static Instance Create(u32 version, Span<const char*> layers, Span<const char*> extensions, static Instance Create(u32 version, Span<const char*> layers, Span<const char*> extensions,
InstanceDispatch& dld) noexcept; InstanceDispatch& dispatch) noexcept;
/// Enumerates physical devices. /// Enumerates physical devices.
/// @return Physical devices and an empty handle on failure. /// @return Physical devices and an empty handle on failure.
@ -581,7 +582,8 @@ public:
constexpr Queue() noexcept = default; constexpr Queue() noexcept = default;
/// Construct a queue handle. /// Construct a queue handle.
constexpr Queue(VkQueue queue, const DeviceDispatch& dld) noexcept : queue{queue}, dld{&dld} {} constexpr Queue(VkQueue queue_, const DeviceDispatch& dld_) noexcept
: queue{queue_}, dld{&dld_} {}
VkResult Submit(Span<VkSubmitInfo> submit_infos, VkResult Submit(Span<VkSubmitInfo> submit_infos,
VkFence fence = VK_NULL_HANDLE) const noexcept { VkFence fence = VK_NULL_HANDLE) const noexcept {
@ -720,7 +722,7 @@ class Device : public Handle<VkDevice, NoOwner, DeviceDispatch> {
public: public:
static Device Create(VkPhysicalDevice physical_device, Span<VkDeviceQueueCreateInfo> queues_ci, static Device Create(VkPhysicalDevice physical_device, Span<VkDeviceQueueCreateInfo> queues_ci,
Span<const char*> enabled_extensions, const void* next, Span<const char*> enabled_extensions, const void* next,
DeviceDispatch& dld) noexcept; DeviceDispatch& dispatch) noexcept;
Queue GetQueue(u32 family_index) const noexcept; Queue GetQueue(u32 family_index) const noexcept;
@ -809,8 +811,9 @@ class PhysicalDevice {
public: public:
constexpr PhysicalDevice() noexcept = default; constexpr PhysicalDevice() noexcept = default;
constexpr PhysicalDevice(VkPhysicalDevice physical_device, const InstanceDispatch& dld) noexcept constexpr PhysicalDevice(VkPhysicalDevice physical_device_,
: physical_device{physical_device}, dld{&dld} {} const InstanceDispatch& dld_) noexcept
: physical_device{physical_device_}, dld{&dld_} {}
constexpr operator VkPhysicalDevice() const noexcept { constexpr operator VkPhysicalDevice() const noexcept {
return physical_device; return physical_device;
@ -849,8 +852,8 @@ class CommandBuffer {
public: public:
CommandBuffer() noexcept = default; CommandBuffer() noexcept = default;
explicit CommandBuffer(VkCommandBuffer handle, const DeviceDispatch& dld) noexcept explicit CommandBuffer(VkCommandBuffer handle_, const DeviceDispatch& dld_) noexcept
: handle{handle}, dld{&dld} {} : handle{handle_}, dld{&dld_} {}
const VkCommandBuffer* address() const noexcept { const VkCommandBuffer* address() const noexcept {
return &handle; return &handle;

6
src/video_core/shader/control_flow.cpp
View file

@ -241,10 +241,10 @@ std::pair<ParseResult, ParseInfo> ParseCode(CFGRebuildState& state, u32 address)
ParseInfo parse_info{}; ParseInfo parse_info{};
SingleBranch single_branch{}; SingleBranch single_branch{};
const auto insert_label = [](CFGRebuildState& state, u32 address) { const auto insert_label = [](CFGRebuildState& rebuild_state, u32 label_address) {
const auto pair = state.labels.emplace(address); const auto pair = rebuild_state.labels.emplace(label_address);
if (pair.second) { if (pair.second) {
state.inspect_queries.push_back(address); rebuild_state.inspect_queries.push_back(label_address);
} }
}; };

10
src/video_core/shader/decode/image.cpp
View file

@ -358,9 +358,9 @@ u32 ShaderIR::DecodeImage(NodeBlock& bb, u32 pc) {
instr.suldst.GetStoreDataLayout() != StoreType::Bits64); instr.suldst.GetStoreDataLayout() != StoreType::Bits64);
auto descriptor = [this, instr] { auto descriptor = [this, instr] {
std::optional<Tegra::Engines::SamplerDescriptor> descriptor; std::optional<Tegra::Engines::SamplerDescriptor> sampler_descriptor;
if (instr.suldst.is_immediate) { if (instr.suldst.is_immediate) {
descriptor = sampler_descriptor =
registry.ObtainBoundSampler(static_cast<u32>(instr.image.index.Value())); registry.ObtainBoundSampler(static_cast<u32>(instr.image.index.Value()));
} else { } else {
const Node image_register = GetRegister(instr.gpr39); const Node image_register = GetRegister(instr.gpr39);
@ -368,12 +368,12 @@ u32 ShaderIR::DecodeImage(NodeBlock& bb, u32 pc) {
static_cast<s64>(global_code.size())); static_cast<s64>(global_code.size()));
const auto buffer = std::get<1>(result); const auto buffer = std::get<1>(result);
const auto offset = std::get<2>(result); const auto offset = std::get<2>(result);
descriptor = registry.ObtainBindlessSampler(buffer, offset); sampler_descriptor = registry.ObtainBindlessSampler(buffer, offset);
} }
if (!descriptor) { if (!sampler_descriptor) {
UNREACHABLE_MSG("Failed to obtain image descriptor"); UNREACHABLE_MSG("Failed to obtain image descriptor");
} }
return *descriptor; return *sampler_descriptor;
}(); }();
const auto comp_mask = GetImageComponentMask(descriptor.format); const auto comp_mask = GetImageComponentMask(descriptor.format);

10
src/video_core/shader/decode/other.cpp
View file

@ -90,11 +90,11 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
UNIMPLEMENTED_MSG("S2R WscaleFactorZ is not implemented"); UNIMPLEMENTED_MSG("S2R WscaleFactorZ is not implemented");
return Immediate(0U); return Immediate(0U);
case SystemVariable::Tid: { case SystemVariable::Tid: {
Node value = Immediate(0); Node val = Immediate(0);
value = BitfieldInsert(value, Operation(OperationCode::LocalInvocationIdX), 0, 9); val = BitfieldInsert(val, Operation(OperationCode::LocalInvocationIdX), 0, 9);
value = BitfieldInsert(value, Operation(OperationCode::LocalInvocationIdY), 16, 9); val = BitfieldInsert(val, Operation(OperationCode::LocalInvocationIdY), 16, 9);
value = BitfieldInsert(value, Operation(OperationCode::LocalInvocationIdZ), 26, 5); val = BitfieldInsert(val, Operation(OperationCode::LocalInvocationIdZ), 26, 5);
return value; return val;
} }
case SystemVariable::TidX: case SystemVariable::TidX:
return Operation(OperationCode::LocalInvocationIdX); return Operation(OperationCode::LocalInvocationIdX);

27
src/video_core/texture_cache/surface_base.cpp
View file

@ -167,27 +167,28 @@ std::vector<CopyParams> SurfaceBaseImpl::BreakDownNonLayered(const SurfaceParams
return result; return result;
} }
void SurfaceBaseImpl::SwizzleFunc(MortonSwizzleMode mode, u8* memory, const SurfaceParams& params, void SurfaceBaseImpl::SwizzleFunc(MortonSwizzleMode mode, u8* memory,
u8* buffer, u32 level) { const SurfaceParams& surface_params, u8* buffer, u32 level) {
const u32 width{params.GetMipWidth(level)}; const u32 width{surface_params.GetMipWidth(level)};
const u32 height{params.GetMipHeight(level)}; const u32 height{surface_params.GetMipHeight(level)};
const u32 block_height{params.GetMipBlockHeight(level)}; const u32 block_height{surface_params.GetMipBlockHeight(level)};
const u32 block_depth{params.GetMipBlockDepth(level)}; const u32 block_depth{surface_params.GetMipBlockDepth(level)};
std::size_t guest_offset{mipmap_offsets[level]}; std::size_t guest_offset{mipmap_offsets[level]};
if (params.is_layered) { if (surface_params.is_layered) {
std::size_t host_offset = 0; std::size_t host_offset = 0;
const std::size_t guest_stride = layer_size; const std::size_t guest_stride = layer_size;
const std::size_t host_stride = params.GetHostLayerSize(level); const std::size_t host_stride = surface_params.GetHostLayerSize(level);
for (u32 layer = 0; layer < params.depth; ++layer) { for (u32 layer = 0; layer < surface_params.depth; ++layer) {
MortonSwizzle(mode, params.pixel_format, width, block_height, height, block_depth, 1, MortonSwizzle(mode, surface_params.pixel_format, width, block_height, height,
params.tile_width_spacing, buffer + host_offset, memory + guest_offset); block_depth, 1, surface_params.tile_width_spacing, buffer + host_offset,
memory + guest_offset);
guest_offset += guest_stride; guest_offset += guest_stride;
host_offset += host_stride; host_offset += host_stride;
} }
} else { } else {
MortonSwizzle(mode, params.pixel_format, width, block_height, height, block_depth, MortonSwizzle(mode, surface_params.pixel_format, width, block_height, height, block_depth,
params.GetMipDepth(level), params.tile_width_spacing, buffer, surface_params.GetMipDepth(level), surface_params.tile_width_spacing, buffer,
memory + guest_offset); memory + guest_offset);
} }
} }

4
src/video_core/texture_cache/surface_base.h
View file

@ -167,8 +167,8 @@ protected:
std::vector<std::size_t> mipmap_offsets; std::vector<std::size_t> mipmap_offsets;
private: private:
void SwizzleFunc(MortonSwizzleMode mode, u8* memory, const SurfaceParams& params, u8* buffer, void SwizzleFunc(MortonSwizzleMode mode, u8* memory, const SurfaceParams& surface_params,
u32 level); u8* buffer, u32 level);
std::vector<CopyParams> BreakDownLayered(const SurfaceParams& in_params) const; std::vector<CopyParams> BreakDownLayered(const SurfaceParams& in_params) const;

14
src/video_core/texture_cache/surface_params.cpp
View file

@ -356,18 +356,18 @@ std::size_t SurfaceParams::GetLayerSize(bool as_host_size, bool uncompressed) co
std::size_t SurfaceParams::GetInnerMipmapMemorySize(u32 level, bool as_host_size, std::size_t SurfaceParams::GetInnerMipmapMemorySize(u32 level, bool as_host_size,
bool uncompressed) const { bool uncompressed) const {
const u32 width{GetMipmapSize(uncompressed, GetMipWidth(level), GetDefaultBlockWidth())}; const u32 mip_width{GetMipmapSize(uncompressed, GetMipWidth(level), GetDefaultBlockWidth())};
const u32 height{GetMipmapSize(uncompressed, GetMipHeight(level), GetDefaultBlockHeight())}; const u32 mip_height{GetMipmapSize(uncompressed, GetMipHeight(level), GetDefaultBlockHeight())};
const u32 depth{is_layered ? 1U : GetMipDepth(level)}; const u32 mip_depth{is_layered ? 1U : GetMipDepth(level)};
if (is_tiled) { if (is_tiled) {
return Tegra::Texture::CalculateSize(!as_host_size, GetBytesPerPixel(), width, height, return Tegra::Texture::CalculateSize(!as_host_size, GetBytesPerPixel(), mip_width,
depth, GetMipBlockHeight(level), mip_height, mip_depth, GetMipBlockHeight(level),
GetMipBlockDepth(level)); GetMipBlockDepth(level));
} else if (as_host_size || IsBuffer()) { } else if (as_host_size || IsBuffer()) {
return GetBytesPerPixel() * width * height * depth; return GetBytesPerPixel() * mip_width * mip_height * mip_depth;
} else { } else {
// Linear Texture Case // Linear Texture Case
return pitch * height * depth; return pitch * mip_height * mip_depth;
} }
} }