Mirrors/yuzu
2
0
Fork 0
mirror of https://github.com/yuzu-mirror/yuzu synced 2024-12-01 04:09:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

video_core: Resolve more variable shadowing scenarios pt.2

Browse source 
Migrates the video core code closer to enabling variable shadowing
warnings as errors.

This primarily sorts out shadowing occurrences within the Vulkan code.
This commit is contained in:
Lioncash 2020-12-05 04:51:14 -05:00
parent e6a896c4bd
commit 414a87a4f4
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;
} }
} }