VERY experimental Nintendo Switch 2 emulator
C++
[vulkan] 4th Vulkan Global Maintenance (#4212)
CamilleLaVeyeb9280dedfb5
diff --git a/src/shader_recompiler/backend/spirv/emit_spirv.cpp b/src/shader_recompiler/backend/spirv/emit_spirv.cppindex 7ab2bd4adf..53453e6ab7 100644--- a/src/shader_recompiler/backend/spirv/emit_spirv.cpp+++ b/src/shader_recompiler/backend/spirv/emit_spirv.cpp@@ -465,12 +465,22 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ctctx.AddCapability(spv::Capability::ImageGatherExtended);ctx.AddCapability(spv::Capability::ImageQuery);ctx.AddCapability(spv::Capability::SampledBuffer);- // TODO: this usage needs to be tracked properly- if (ctx.profile.support_sampled_image_array_nonuniform_indexing) {- if (ctx.profile.supported_spirv < 0x00010400)+ if (!ctx.non_uniform_ids.empty()) {+ if (ctx.profile.supported_spirv < 0x00010500)ctx.AddExtension("SPV_EXT_descriptor_indexing");ctx.AddCapability(spv::Capability::ShaderNonUniform);- ctx.AddCapability(spv::Capability::SampledImageArrayNonUniformIndexing);+ if (ctx.uses_nonuniform_sampled_image) {+ ctx.AddCapability(spv::Capability::SampledImageArrayNonUniformIndexing);+ }+ if (ctx.uses_nonuniform_storage_image) {+ ctx.AddCapability(spv::Capability::StorageImageArrayNonUniformIndexing);+ }+ if (ctx.uses_nonuniform_uniform_texel_buffer) {+ ctx.AddCapability(spv::Capability::UniformTexelBufferArrayNonUniformIndexing);+ }+ if (ctx.uses_nonuniform_storage_texel_buffer) {+ ctx.AddCapability(spv::Capability::StorageTexelBufferArrayNonUniformIndexing);+ }}}diff --git a/src/shader_recompiler/backend/spirv/emit_spirv_atomic.cpp b/src/shader_recompiler/backend/spirv/emit_spirv_atomic.cppindex 0ce73f289b..d1c08c1131 100644--- a/src/shader_recompiler/backend/spirv/emit_spirv_atomic.cpp+++ b/src/shader_recompiler/backend/spirv/emit_spirv_atomic.cpp@@ -1,3 +1,6 @@+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later@@ -15,7 +18,7 @@ Id SharedPointer(EmitContext& ctx, Id offset, u32 index_offset = 0) {if (index_offset > 0) {index = ctx.OpIAdd(ctx.U32[1], index, ctx.Const(index_offset));}- return ctx.profile.support_explicit_workgroup_layout+ return ctx.uses_explicit_workgroup_layout? ctx.OpAccessChain(ctx.shared_u32, ctx.shared_memory_u32, ctx.u32_zero_value, index): ctx.OpAccessChain(ctx.shared_u32, ctx.shared_memory_u32, index);}@@ -155,7 +158,7 @@ Id EmitSharedAtomicExchange32(EmitContext& ctx, Id offset, Id value) {}Id EmitSharedAtomicExchange64(EmitContext& ctx, Id offset, Id value) {- if (ctx.profile.support_int64_atomics && ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.profile.support_shared_int64_atomics && ctx.uses_explicit_workgroup_layout) {const Id shift_id{ctx.Const(3U)};const Id index{ctx.OpShiftRightArithmetic(ctx.U32[1], offset, shift_id)};const Id pointer{diff --git a/src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp b/src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cppindex f4d9de79d3..28f9869e22 100644--- a/src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp+++ b/src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp@@ -624,12 +624,14 @@ Id EmitRenderArea(EmitContext& ctx) {}Id EmitLoadLocal(EmitContext& ctx, Id word_offset) {- const Id pointer{ctx.OpAccessChain(ctx.private_u32, ctx.local_memory, word_offset)};+ const Id pointer{+ ctx.OpAccessChain(ctx.private_u32, ctx.local_memory, word_offset, ctx.Const(0U))};return ctx.OpLoad(ctx.U32[1], pointer);}void EmitWriteLocal(EmitContext& ctx, Id word_offset, Id value) {- const Id pointer{ctx.OpAccessChain(ctx.private_u32, ctx.local_memory, word_offset)};+ const Id pointer{+ ctx.OpAccessChain(ctx.private_u32, ctx.local_memory, word_offset, ctx.Const(0U))};ctx.OpStore(pointer, value);}diff --git a/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp b/src/shader_recompiler/backend/spirv/emit_spirv_image.cppindex 0b3a1a7c08..5d4983b9f7 100644--- a/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp+++ b/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp@@ -15,8 +15,56 @@namespace Shader::Backend::SPIRV {namespace {-[[nodiscard]] bool IsNonUniformDescriptor(EmitContext& ctx, const IR::Value& index) noexcept {- return ctx.profile.support_sampled_image_array_nonuniform_indexing && !index.IsImmediate();+enum class NonUniformKind {+ SampledImage,+ StorageImage,+ UniformTexelBuffer,+ StorageTexelBuffer,+};++[[nodiscard]] bool IsNonUniformSupported(const Profile& profile, NonUniformKind kind) noexcept {+ switch (kind) {+ case NonUniformKind::SampledImage:+ return profile.support_sampled_image_array_nonuniform_indexing;+ case NonUniformKind::StorageImage:+ return profile.support_storage_image_array_nonuniform_indexing;+ case NonUniformKind::UniformTexelBuffer:+ return profile.support_uniform_texel_buffer_array_nonuniform_indexing;+ case NonUniformKind::StorageTexelBuffer:+ return profile.support_storage_texel_buffer_array_nonuniform_indexing;+ }+ return false;+}++void DecorateNonUniform(EmitContext& ctx, Id object) {+ if (ctx.non_uniform_ids.contains(object.value)) {+ return;+ }+ ctx.Decorate(object, spv::Decoration::NonUniform);+ ctx.non_uniform_ids.insert(object.value);+}++[[nodiscard]] bool MarkNonUniform(EmitContext& ctx, Id idx, const IR::Value& index,+ NonUniformKind kind) {+ if (index.IsImmediate() || !IsNonUniformSupported(ctx.profile, kind)) {+ return false;+ }+ DecorateNonUniform(ctx, idx);+ switch (kind) {+ case NonUniformKind::SampledImage:+ ctx.uses_nonuniform_sampled_image = true;+ break;+ case NonUniformKind::StorageImage:+ ctx.uses_nonuniform_storage_image = true;+ break;+ case NonUniformKind::UniformTexelBuffer:+ ctx.uses_nonuniform_uniform_texel_buffer = true;+ break;+ case NonUniformKind::StorageTexelBuffer:+ ctx.uses_nonuniform_storage_texel_buffer = true;+ break;+ }+ return true;}class ImageOperands {@@ -195,12 +243,13 @@ Id Texture(EmitContext& ctx, IR::TextureInstInfo info, [[maybe_unused]] const IRconst TextureDefinition& def{ctx.textures.at(info.descriptor_index)};if (def.count > 1) {auto const idx = index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index);- if (!ctx.non_uniform_ids.contains(idx.value) && IsNonUniformDescriptor(ctx, index)) {- ctx.Decorate(idx, spv::Decoration::NonUniform);- ctx.non_uniform_ids.insert(idx.value);- }+ const bool non_uniform{MarkNonUniform(ctx, idx, index, NonUniformKind::SampledImage)};const Id pointer{ctx.OpAccessChain(def.pointer_type, def.id, idx)};const Id object{ctx.OpLoad(def.sampled_type, pointer)};+ if (non_uniform) {+ DecorateNonUniform(ctx, pointer);+ DecorateNonUniform(ctx, object);+ }return object;} else {return ctx.OpLoad(def.sampled_type, def.id);@@ -212,21 +261,30 @@ Id TextureImage(EmitContext& ctx, IR::TextureInstInfo info, const IR::Value& indconst TextureBufferDefinition& def{ctx.texture_buffers.at(info.descriptor_index)};if (def.count > 1) {const Id idx{index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index)};+ const bool non_uniform{+ MarkNonUniform(ctx, idx, index, NonUniformKind::UniformTexelBuffer)};const Id ptr{ctx.OpAccessChain(ctx.image_buffer_type, def.id, idx)};- return ctx.OpLoad(ctx.image_buffer_type, ptr);+ const Id object{ctx.OpLoad(ctx.image_buffer_type, ptr)};+ if (non_uniform) {+ DecorateNonUniform(ctx, ptr);+ DecorateNonUniform(ctx, object);+ }+ return object;}return ctx.OpLoad(ctx.image_buffer_type, def.id);} else {const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};if (def.count > 1) {auto const idx = index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index);- if (!ctx.non_uniform_ids.contains(idx.value) && IsNonUniformDescriptor(ctx, index)) {- ctx.Decorate(idx, spv::Decoration::NonUniform);- ctx.non_uniform_ids.insert(idx.value);- }+ const bool non_uniform{MarkNonUniform(ctx, idx, index, NonUniformKind::SampledImage)};const Id ptr = ctx.OpAccessChain(def.pointer_type, def.id, idx);const Id object = ctx.OpLoad(def.sampled_type, ptr);const Id image = ctx.OpImage(def.image_type, object);+ if (non_uniform) {+ DecorateNonUniform(ctx, ptr);+ DecorateNonUniform(ctx, object);+ DecorateNonUniform(ctx, image);+ }return image;}return ctx.OpImage(def.image_type, ctx.OpLoad(def.sampled_type, def.id));@@ -238,16 +296,29 @@ std::pair<Id, bool> Image(EmitContext& ctx, const IR::Value& index, IR::TextureIconst ImageBufferDefinition def{ctx.image_buffers.at(info.descriptor_index)};if (def.count > 1) {const Id idx{index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index)};+ const bool non_uniform{+ MarkNonUniform(ctx, idx, index, NonUniformKind::StorageTexelBuffer)};const Id ptr{ctx.OpAccessChain(def.pointer_type, def.id, idx)};- return {ctx.OpLoad(def.image_type, ptr), def.is_integer};+ const Id image{ctx.OpLoad(def.image_type, ptr)};+ if (non_uniform) {+ DecorateNonUniform(ctx, ptr);+ DecorateNonUniform(ctx, image);+ }+ return {image, def.is_integer};}return {ctx.OpLoad(def.image_type, def.id), def.is_integer};} else {const ImageDefinition def{ctx.images.at(info.descriptor_index)};if (def.count > 1) {const Id idx{index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index)};+ const bool non_uniform{MarkNonUniform(ctx, idx, index, NonUniformKind::StorageImage)};const Id ptr{ctx.OpAccessChain(def.pointer_type, def.id, idx)};- return {ctx.OpLoad(def.image_type, ptr), def.is_integer};+ const Id image{ctx.OpLoad(def.image_type, ptr)};+ if (non_uniform) {+ DecorateNonUniform(ctx, ptr);+ DecorateNonUniform(ctx, image);+ }+ return {image, def.is_integer};}return {ctx.OpLoad(def.image_type, def.id), def.is_integer};}diff --git a/src/shader_recompiler/backend/spirv/emit_spirv_memory.cpp b/src/shader_recompiler/backend/spirv/emit_spirv_memory.cppindex 4a5e7ef067..bef4421fed 100644--- a/src/shader_recompiler/backend/spirv/emit_spirv_memory.cpp+++ b/src/shader_recompiler/backend/spirv/emit_spirv_memory.cpp@@ -159,7 +159,7 @@ void EmitWriteGlobal128(EmitContext& ctx, Id address, Id value) {}Id EmitLoadStorageU8(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {- if (ctx.profile.support_int8 && ctx.profile.support_uniform_and_storage_buffer_8bit &&+ if (ctx.profile.support_int8 && ctx.profile.support_storage_buffer_8bit &&ctx.profile.support_descriptor_aliasing) {return ctx.OpUConvert(ctx.U32[1],LoadStorage(ctx, binding, offset, ctx.U8, ctx.storage_types.U8,@@ -171,7 +171,7 @@ Id EmitLoadStorageU8(EmitContext& ctx, const IR::Value& binding, const IR::Value}Id EmitLoadStorageS8(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {- if (ctx.profile.support_int8 && ctx.profile.support_uniform_and_storage_buffer_8bit &&+ if (ctx.profile.support_int8 && ctx.profile.support_storage_buffer_8bit &&ctx.profile.support_descriptor_aliasing) {return ctx.OpSConvert(ctx.U32[1],LoadStorage(ctx, binding, offset, ctx.S8, ctx.storage_types.S8,@@ -183,7 +183,7 @@ Id EmitLoadStorageS8(EmitContext& ctx, const IR::Value& binding, const IR::Value}Id EmitLoadStorageU16(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {- if (ctx.profile.support_int16 && ctx.profile.support_uniform_and_storage_buffer_16bit &&+ if (ctx.profile.support_int16 && ctx.profile.support_storage_buffer_16bit &&ctx.profile.support_descriptor_aliasing) {return ctx.OpUConvert(ctx.U32[1],LoadStorage(ctx, binding, offset, ctx.U16, ctx.storage_types.U16,@@ -195,7 +195,7 @@ Id EmitLoadStorageU16(EmitContext& ctx, const IR::Value& binding, const IR::Valu}Id EmitLoadStorageS16(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {- if (ctx.profile.support_int16 && ctx.profile.support_uniform_and_storage_buffer_16bit &&+ if (ctx.profile.support_int16 && ctx.profile.support_storage_buffer_16bit &&ctx.profile.support_descriptor_aliasing) {return ctx.OpSConvert(ctx.U32[1],LoadStorage(ctx, binding, offset, ctx.S16, ctx.storage_types.S16,@@ -234,7 +234,8 @@ Id EmitLoadStorage128(EmitContext& ctx, const IR::Value& binding, const IR::Valuvoid EmitWriteStorageU8(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,Id value) {- if (ctx.profile.support_int8 && ctx.profile.support_uniform_and_storage_buffer_8bit) {+ if (ctx.profile.support_int8 && ctx.profile.support_storage_buffer_8bit &&+ ctx.profile.support_descriptor_aliasing) {WriteStorage(ctx, binding, offset, ctx.OpSConvert(ctx.U8, value), ctx.storage_types.U8,sizeof(u8), &StorageDefinitions::U8);} else {@@ -244,7 +245,8 @@ void EmitWriteStorageU8(EmitContext& ctx, const IR::Value& binding, const IR::Vavoid EmitWriteStorageS8(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,Id value) {- if (ctx.profile.support_int8 && ctx.profile.support_uniform_and_storage_buffer_8bit) {+ if (ctx.profile.support_int8 && ctx.profile.support_storage_buffer_8bit &&+ ctx.profile.support_descriptor_aliasing) {WriteStorage(ctx, binding, offset, ctx.OpSConvert(ctx.S8, value), ctx.storage_types.S8,sizeof(s8), &StorageDefinitions::S8);} else {@@ -254,7 +256,8 @@ void EmitWriteStorageS8(EmitContext& ctx, const IR::Value& binding, const IR::Vavoid EmitWriteStorageU16(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,Id value) {- if (ctx.profile.support_int16 && ctx.profile.support_uniform_and_storage_buffer_16bit) {+ if (ctx.profile.support_int16 && ctx.profile.support_storage_buffer_16bit &&+ ctx.profile.support_descriptor_aliasing) {WriteStorage(ctx, binding, offset, ctx.OpSConvert(ctx.U16, value), ctx.storage_types.U16,sizeof(u16), &StorageDefinitions::U16);} else {@@ -264,7 +267,8 @@ void EmitWriteStorageU16(EmitContext& ctx, const IR::Value& binding, const IR::Vvoid EmitWriteStorageS16(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,Id value) {- if (ctx.profile.support_int16 && ctx.profile.support_uniform_and_storage_buffer_16bit) {+ if (ctx.profile.support_int16 && ctx.profile.support_storage_buffer_16bit &&+ ctx.profile.support_descriptor_aliasing) {WriteStorage(ctx, binding, offset, ctx.OpSConvert(ctx.S16, value), ctx.storage_types.S16,sizeof(s16), &StorageDefinitions::S16);} else {diff --git a/src/shader_recompiler/backend/spirv/emit_spirv_shared_memory.cpp b/src/shader_recompiler/backend/spirv/emit_spirv_shared_memory.cppindex c3208b955a..dc398aa296 100644--- a/src/shader_recompiler/backend/spirv/emit_spirv_shared_memory.cpp+++ b/src/shader_recompiler/backend/spirv/emit_spirv_shared_memory.cpp@@ -31,7 +31,7 @@ std::pair<Id, Id> ExtractArgs(EmitContext& ctx, Id offset, u32 mask, u32 count)} // Anonymous namespaceId EmitLoadSharedU8(EmitContext& ctx, Id offset) {- if (ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.uses_explicit_workgroup_layout) {const Id pointer{ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};return ctx.OpUConvert(ctx.U32[1], ctx.OpLoad(ctx.U8, pointer));@@ -42,7 +42,7 @@ Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {}Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {- if (ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.uses_explicit_workgroup_layout) {const Id pointer{ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};return ctx.OpSConvert(ctx.U32[1], ctx.OpLoad(ctx.U8, pointer));@@ -53,7 +53,7 @@ Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {}Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {- if (ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.uses_explicit_workgroup_layout) {const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};return ctx.OpUConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));} else {@@ -63,7 +63,7 @@ Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {}Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {- if (ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.uses_explicit_workgroup_layout) {const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};return ctx.OpSConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));} else {@@ -73,7 +73,7 @@ Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {}Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {- if (ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.uses_explicit_workgroup_layout) {const Id pointer{Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2)};return ctx.OpLoad(ctx.U32[1], pointer);} else {@@ -82,7 +82,7 @@ Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {}Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {- if (ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.uses_explicit_workgroup_layout) {const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};return ctx.OpLoad(ctx.U32[2], pointer);} else {@@ -97,7 +97,7 @@ Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {}Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {- if (ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.uses_explicit_workgroup_layout) {const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};return ctx.OpLoad(ctx.U32[4], pointer);}@@ -113,7 +113,7 @@ Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {}void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {- if (ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.uses_explicit_workgroup_layout) {const Id pointer{ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};ctx.OpStore(pointer, ctx.OpUConvert(ctx.U8, value));@@ -123,7 +123,7 @@ void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {}void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {- if (ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.uses_explicit_workgroup_layout) {const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};ctx.OpStore(pointer, ctx.OpUConvert(ctx.U16, value));} else {@@ -133,7 +133,7 @@ void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {Id pointer{};- if (ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.uses_explicit_workgroup_layout) {pointer = Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2);} else {const Id shift{ctx.Const(2U)};@@ -144,7 +144,7 @@ void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {}void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {- if (ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.uses_explicit_workgroup_layout) {const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};ctx.OpStore(pointer, value);return;@@ -159,7 +159,7 @@ void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {}void EmitWriteSharedU128(EmitContext& ctx, Id offset, Id value) {- if (ctx.profile.support_explicit_workgroup_layout) {+ if (ctx.uses_explicit_workgroup_layout) {const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};ctx.OpStore(pointer, value);return;diff --git a/src/shader_recompiler/backend/spirv/spirv_emit_context.cpp b/src/shader_recompiler/backend/spirv/spirv_emit_context.cppindex 17ce4d744f..b562e82983 100644--- a/src/shader_recompiler/backend/spirv/spirv_emit_context.cpp+++ b/src/shader_recompiler/backend/spirv/spirv_emit_context.cpp@@ -371,7 +371,7 @@ Id CasFunction(EmitContext& ctx, Operation operation, Id value_type) {Id CasLoop(EmitContext& ctx, Operation operation, Id array_pointer, Id element_pointer,Id value_type, Id memory_type, spv::Scope scope) {const bool is_shared{scope == spv::Scope::Workgroup};- const bool is_struct{!is_shared || ctx.profile.support_explicit_workgroup_layout};+ const bool is_struct{!is_shared || ctx.uses_explicit_workgroup_layout};const Id cas_func{CasFunction(ctx, operation, value_type)};const Id zero{ctx.u32_zero_value};const Id scope_id{ctx.Const(static_cast<u32>(scope))};@@ -591,7 +591,8 @@ void EmitContext::DefineLocalMemory(const IR::Program& program) {return;}const u32 num_elements{Common::DivCeil(program.local_memory_size, 4U)};- const Id type{TypeArray(U32[1], Const(num_elements))};+ const Id element_type{TypeStruct(U32[1])};+ const Id type{TypeArray(element_type, Const(num_elements))};const Id pointer{TypePointer(spv::StorageClass::Private, type)};local_memory = AddGlobalVariable(pointer, spv::StorageClass::Private);if (profile.supported_spirv >= 0x00010400) {@@ -600,6 +601,10 @@ void EmitContext::DefineLocalMemory(const IR::Program& program) {}void EmitContext::DefineSharedMemory(const IR::Program& program) {+ uses_explicit_workgroup_layout =+ profile.support_explicit_workgroup_layout &&+ (!program.info.uses_int8 || profile.support_workgroup_layout_8bit_access) &&+ (!program.info.uses_int16 || profile.support_workgroup_layout_16bit_access);if (program.shared_memory_size == 0) {return;}@@ -620,18 +625,18 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {return std::make_tuple(variable, element_pointer, pointer);}};- if (profile.support_explicit_workgroup_layout) {+ if (uses_explicit_workgroup_layout) {AddExtension("SPV_KHR_workgroup_memory_explicit_layout");AddCapability(spv::Capability::WorkgroupMemoryExplicitLayoutKHR);- if (program.info.uses_int8) {+ if (program.info.uses_int8 && profile.support_int8) {AddCapability(spv::Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR);std::tie(shared_memory_u8, shared_u8, std::ignore) = make(U8, 1);}- if (program.info.uses_int16) {+ if (program.info.uses_int16 && profile.support_int16) {AddCapability(spv::Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR);std::tie(shared_memory_u16, shared_u16, std::ignore) = make(U16, 2);}- if (program.info.uses_int64) {+ if (program.info.uses_int64 && profile.support_int64) {std::tie(shared_memory_u64, shared_u64, std::ignore) = make(U64, 8);}std::tie(shared_memory_u32, shared_u32, shared_memory_u32_type) = make(U32[1], 4);@@ -1229,16 +1234,17 @@ void EmitContext::DefineStorageBuffers(const Info& info, u32& binding) {}AddExtension("SPV_KHR_storage_buffer_storage_class");- const IR::Type used_types{profile.support_descriptor_aliasing ? info.used_storage_buffer_types- : IR::Type::U32};- if (profile.support_int8 && profile.support_uniform_and_storage_buffer_8bit &&+ IR::Type used_types{profile.support_descriptor_aliasing ? info.used_storage_buffer_types+ : IR::Type::U32};+ used_types |= IR::Type::U32;+ if (profile.support_int8 && profile.support_storage_buffer_8bit &&True(used_types & IR::Type::U8)) {DefineSsbos(*this, storage_types.U8, &StorageDefinitions::U8, info, binding, U8,sizeof(u8));DefineSsbos(*this, storage_types.S8, &StorageDefinitions::S8, info, binding, S8,sizeof(u8));}- if (profile.support_int16 && profile.support_uniform_and_storage_buffer_16bit &&+ if (profile.support_int16 && profile.support_storage_buffer_16bit &&True(used_types & IR::Type::U16)) {DefineSsbos(*this, storage_types.U16, &StorageDefinitions::U16, info, binding, U16,sizeof(u16));diff --git a/src/shader_recompiler/backend/spirv/spirv_emit_context.h b/src/shader_recompiler/backend/spirv/spirv_emit_context.hindex 504bffc0ed..fb20966b67 100644--- a/src/shader_recompiler/backend/spirv/spirv_emit_context.h+++ b/src/shader_recompiler/backend/spirv/spirv_emit_context.h@@ -311,6 +311,7 @@ public:Id local_memory{};+ bool uses_explicit_workgroup_layout{};Id shared_memory_u8{};Id shared_memory_u16{};Id shared_memory_u32{};@@ -371,6 +372,11 @@ public:// Sirit::Id doesn't play nice with *::set<>ankerl::unordered_dense::set<u32> non_uniform_ids;+ bool uses_nonuniform_sampled_image{};+ bool uses_nonuniform_storage_image{};+ bool uses_nonuniform_uniform_texel_buffer{};+ bool uses_nonuniform_storage_texel_buffer{};+private:void DefineCommonTypes(const Info& info);void DefineCommonConstants();diff --git a/src/shader_recompiler/ir_opt/lower_fp64_to_fp32.cpp b/src/shader_recompiler/ir_opt/lower_fp64_to_fp32.cppindex 5db7a38add..9a05609857 100644--- a/src/shader_recompiler/ir_opt/lower_fp64_to_fp32.cpp+++ b/src/shader_recompiler/ir_opt/lower_fp64_to_fp32.cpp@@ -1,3 +1,6 @@+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-laterdiff --git a/src/shader_recompiler/ir_opt/lower_int64_to_int32.cpp b/src/shader_recompiler/ir_opt/lower_int64_to_int32.cppindex cdb58f46b3..dbca9643d8 100644--- a/src/shader_recompiler/ir_opt/lower_int64_to_int32.cpp+++ b/src/shader_recompiler/ir_opt/lower_int64_to_int32.cpp@@ -1,3 +1,6 @@+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later@@ -181,6 +184,72 @@ void ShiftRightArithmetic64To32(IR::Block& block, IR::Inst& inst) {inst.ReplaceUsesWith(ir.CompositeConstruct(ret_lo, ret_hi));}+void IAbs64To32(IR::Block& block, IR::Inst& inst) {+ IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));+ const auto [lo, hi]{Unpack(ir, inst.Arg(0))};++ const IR::U32 neg_lo{ir.IAdd(ir.BitwiseNot(lo), ir.Imm32(1))};+ const IR::U32 carry{IR::U32{ir.Select(ir.GetCarryFromOp(neg_lo), ir.Imm32(1u), ir.Imm32(0u))}};+ const IR::U32 neg_hi{ir.IAdd(ir.BitwiseNot(hi), carry)};++ const IR::U1 is_negative{ir.INotEqual(ir.BitwiseAnd(hi, ir.Imm32(0x80000000u)), ir.Imm32(0u))};+ const IR::U32 ret_lo{IR::U32{ir.Select(is_negative, neg_lo, lo)}};+ const IR::U32 ret_hi{IR::U32{ir.Select(is_negative, neg_hi, hi)}};+ inst.ReplaceUsesWith(ir.CompositeConstruct(ret_lo, ret_hi));+}++void SelectU64To32(IR::Block& block, IR::Inst& inst) {+ IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));+ const IR::U1 condition{inst.Arg(0)};+ const auto [true_lo, true_hi]{Unpack(ir, inst.Arg(1))};+ const auto [false_lo, false_hi]{Unpack(ir, inst.Arg(2))};++ const IR::U32 ret_lo{IR::U32{ir.Select(condition, true_lo, false_lo)}};+ const IR::U32 ret_hi{IR::U32{ir.Select(condition, true_hi, false_hi)}};+ inst.ReplaceUsesWith(ir.CompositeConstruct(ret_lo, ret_hi));+}++void UndefU64To32(IR::Block& block, IR::Inst& inst) {+ IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));+ inst.ReplaceUsesWith(ir.CompositeConstruct(ir.Imm32(0u), ir.Imm32(0u)));+}++void ConvertU64U32To32(IR::Block& block, IR::Inst& inst) {+ IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));+ inst.ReplaceUsesWith(ir.CompositeConstruct(IR::U32{inst.Arg(0)}, ir.Imm32(0u)));+}++void ConvertU32U64To32(IR::Block& block, IR::Inst& inst) {+ IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));+ inst.ReplaceUsesWith(Unpack(ir, inst.Arg(0)).first);+}++void IntToFloat64To32(IR::Block& block, IR::Inst& inst, bool is_signed, size_t dest_bitsize) {+ IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));+ const auto [lo, hi]{Unpack(ir, inst.Arg(0))};+ const IR::F32 low{ir.ConvertUToF(32, 32, lo)};+ const IR::F32 high{is_signed ? IR::F32{ir.ConvertSToF(32, 32, hi)}+ : IR::F32{ir.ConvertUToF(32, 32, hi)}};+ const IR::F32 combined{ir.FPFma(high, ir.Imm32(4294967296.0f), low)};+ if (dest_bitsize == 32) {+ inst.ReplaceUsesWith(combined);+ } else {+ inst.ReplaceUsesWith(ir.FPConvert(dest_bitsize, combined));+ }+}++void FloatToInt64To32(IR::Block& block, IR::Inst& inst, bool is_signed, size_t src_bitsize) {+ IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));+ const IR::F32 value{src_bitsize == 32 ? IR::F32{inst.Arg(0)}+ : IR::F32{ir.FPConvert(32, IR::F16F32F64{inst.Arg(0)})}};+ const IR::F32 high_f{ir.FPFloor(ir.FPMul(value, ir.Imm32(1.0f / 4294967296.0f)))};+ const IR::U32 hi{is_signed ? IR::U32{ir.ConvertFToS(32, high_f)}+ : IR::U32{ir.ConvertFToU(32, high_f)}};+ const IR::F32 low_f{ir.FPFma(high_f, ir.FPNeg(ir.Imm32(4294967296.0f)), value)};+ const IR::U32 lo{IR::U32{ir.ConvertFToU(32, low_f)}};+ inst.ReplaceUsesWith(ir.CompositeConstruct(lo, hi));+}+void Lower(IR::Block& block, IR::Inst& inst) {switch (inst.GetOpcode()) {case IR::Opcode::PackUint2x32:@@ -218,6 +287,62 @@ void Lower(IR::Block& block, IR::Inst& inst) {return inst.ReplaceOpcode(IR::Opcode::GlobalAtomicXor32x2);case IR::Opcode::GlobalAtomicExchange64:return inst.ReplaceOpcode(IR::Opcode::GlobalAtomicExchange32x2);+ case IR::Opcode::StorageAtomicIAdd64:+ return inst.ReplaceOpcode(IR::Opcode::StorageAtomicIAdd32x2);+ case IR::Opcode::StorageAtomicSMin64:+ return inst.ReplaceOpcode(IR::Opcode::StorageAtomicSMin32x2);+ case IR::Opcode::StorageAtomicUMin64:+ return inst.ReplaceOpcode(IR::Opcode::StorageAtomicUMin32x2);+ case IR::Opcode::StorageAtomicSMax64:+ return inst.ReplaceOpcode(IR::Opcode::StorageAtomicSMax32x2);+ case IR::Opcode::StorageAtomicUMax64:+ return inst.ReplaceOpcode(IR::Opcode::StorageAtomicUMax32x2);+ case IR::Opcode::StorageAtomicAnd64:+ return inst.ReplaceOpcode(IR::Opcode::StorageAtomicAnd32x2);+ case IR::Opcode::StorageAtomicOr64:+ return inst.ReplaceOpcode(IR::Opcode::StorageAtomicOr32x2);+ case IR::Opcode::StorageAtomicXor64:+ return inst.ReplaceOpcode(IR::Opcode::StorageAtomicXor32x2);+ case IR::Opcode::StorageAtomicExchange64:+ return inst.ReplaceOpcode(IR::Opcode::StorageAtomicExchange32x2);+ case IR::Opcode::BitCastU64F64:+ return inst.ReplaceOpcode(IR::Opcode::UnpackDouble2x32);+ case IR::Opcode::BitCastF64U64:+ return inst.ReplaceOpcode(IR::Opcode::PackDouble2x32);+ case IR::Opcode::UndefU64:+ return UndefU64To32(block, inst);+ case IR::Opcode::SelectU64:+ return SelectU64To32(block, inst);+ case IR::Opcode::IAbs64:+ return IAbs64To32(block, inst);+ case IR::Opcode::ConvertU64U32:+ return ConvertU64U32To32(block, inst);+ case IR::Opcode::ConvertU32U64:+ return ConvertU32U64To32(block, inst);+ case IR::Opcode::ConvertS64F16:+ return FloatToInt64To32(block, inst, true, 16);+ case IR::Opcode::ConvertS64F32:+ return FloatToInt64To32(block, inst, true, 32);+ case IR::Opcode::ConvertS64F64:+ return FloatToInt64To32(block, inst, true, 64);+ case IR::Opcode::ConvertU64F16:+ return FloatToInt64To32(block, inst, false, 16);+ case IR::Opcode::ConvertU64F32:+ return FloatToInt64To32(block, inst, false, 32);+ case IR::Opcode::ConvertU64F64:+ return FloatToInt64To32(block, inst, false, 64);+ case IR::Opcode::ConvertF16S64:+ return IntToFloat64To32(block, inst, true, 16);+ case IR::Opcode::ConvertF32S64:+ return IntToFloat64To32(block, inst, true, 32);+ case IR::Opcode::ConvertF64S64:+ return IntToFloat64To32(block, inst, true, 64);+ case IR::Opcode::ConvertF16U64:+ return IntToFloat64To32(block, inst, false, 16);+ case IR::Opcode::ConvertF32U64:+ return IntToFloat64To32(block, inst, false, 32);+ case IR::Opcode::ConvertF64U64:+ return IntToFloat64To32(block, inst, false, 64);default:break;}diff --git a/src/shader_recompiler/profile.h b/src/shader_recompiler/profile.hindex 0197a5f1d7..eb7b2a02b2 100644--- a/src/shader_recompiler/profile.h+++ b/src/shader_recompiler/profile.h@@ -18,8 +18,10 @@ struct Profile {bool support_descriptor_aliasing{};bool support_int8{};bool support_uniform_and_storage_buffer_8bit{};+ bool support_storage_buffer_8bit{};bool support_int16{};bool support_uniform_and_storage_buffer_16bit{};+ bool support_storage_buffer_16bit{};bool support_int64{};bool support_vertex_instance_id{};bool support_float_controls{};@@ -33,6 +35,8 @@ struct Profile {bool support_fp32_signed_zero_nan_preserve{};bool support_fp64_signed_zero_nan_preserve{};bool support_explicit_workgroup_layout{};+ bool support_workgroup_layout_8bit_access{};+ bool support_workgroup_layout_16bit_access{};bool support_vote{};u32 supported_subgroup_stages{0x7F};bool support_viewport_index_layer_non_geometry{};@@ -40,6 +44,7 @@ struct Profile {bool support_typeless_image_loads{};bool support_demote_to_helper_invocation{};bool support_int64_atomics{};+ bool support_shared_int64_atomics{};bool support_derivative_control{};bool support_geometry_shader_passthrough{};bool support_native_ndc{};@@ -54,6 +59,9 @@ struct Profile {bool support_multi_viewport{};bool support_geometry_streams{};bool support_sampled_image_array_nonuniform_indexing{};+ bool support_storage_image_array_nonuniform_indexing{};+ bool support_uniform_texel_buffer_array_nonuniform_indexing{};+ bool support_storage_texel_buffer_array_nonuniform_indexing{};bool warp_size_potentially_larger_than_guest{};diff --git a/src/video_core/host_shaders/CMakeLists.txt b/src/video_core/host_shaders/CMakeLists.txtindex 9e8d76b104..0d342c463d 100644--- a/src/video_core/host_shaders/CMakeLists.txt+++ b/src/video_core/host_shaders/CMakeLists.txt@@ -17,6 +17,9 @@ set(SHADER_FILES${CMAKE_CURRENT_SOURCE_DIR}/astc_decoder.comp${CMAKE_CURRENT_SOURCE_DIR}/blit_color_float.frag${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_2d.comp+ ${CMAKE_CURRENT_SOURCE_DIR}/blit_color_msaa.frag+ ${CMAKE_CURRENT_SOURCE_DIR}/blit_depth_msaa.frag+ ${CMAKE_CURRENT_SOURCE_DIR}/blit_depth_stencil_msaa.frag${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_3d.comp${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_3d_bcn.comp${CMAKE_CURRENT_SOURCE_DIR}/convert_abgr8_to_d24s8.frag@@ -26,7 +29,9 @@ set(SHADER_FILES${CMAKE_CURRENT_SOURCE_DIR}/convert_depth_to_float.frag${CMAKE_CURRENT_SOURCE_DIR}/convert_float_to_depth.frag${CMAKE_CURRENT_SOURCE_DIR}/convert_msaa_to_non_msaa.comp+ ${CMAKE_CURRENT_SOURCE_DIR}/convert_msaa_to_non_msaa.frag${CMAKE_CURRENT_SOURCE_DIR}/convert_non_msaa_to_msaa.comp+ ${CMAKE_CURRENT_SOURCE_DIR}/convert_non_msaa_to_msaa.frag${CMAKE_CURRENT_SOURCE_DIR}/convert_s8d24_to_abgr8.frag${CMAKE_CURRENT_SOURCE_DIR}/full_screen_triangle.vert${CMAKE_CURRENT_SOURCE_DIR}/fxaa.fragdiff --git a/src/video_core/host_shaders/blit_color_msaa.frag b/src/video_core/host_shaders/blit_color_msaa.fragnew file mode 100644index 0000000000..b25d0342c3--- /dev/null+++ b/src/video_core/host_shaders/blit_color_msaa.frag@@ -0,0 +1,13 @@+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#version 450 core++layout(binding = 0) uniform sampler2DMS tex;++layout(location = 0) in vec2 texcoord;+layout(location = 0) out vec4 color;++void main() {+ color = texelFetch(tex, ivec2(texcoord), gl_SampleID);+}diff --git a/src/video_core/host_shaders/blit_depth_msaa.frag b/src/video_core/host_shaders/blit_depth_msaa.fragnew file mode 100644index 0000000000..064289ad04--- /dev/null+++ b/src/video_core/host_shaders/blit_depth_msaa.frag@@ -0,0 +1,12 @@+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#version 450 core++layout(binding = 0) uniform sampler2DMS depth_tex;++layout(location = 0) in vec2 texcoord;++void main() {+ gl_FragDepth = texelFetch(depth_tex, ivec2(texcoord), 0).r;+}diff --git a/src/video_core/host_shaders/blit_depth_stencil_msaa.frag b/src/video_core/host_shaders/blit_depth_stencil_msaa.fragnew file mode 100644index 0000000000..d4264f2d14--- /dev/null+++ b/src/video_core/host_shaders/blit_depth_stencil_msaa.frag@@ -0,0 +1,15 @@+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#version 450 core+#extension GL_ARB_shader_stencil_export : require++layout(binding = 0) uniform sampler2DMS depth_tex;+layout(binding = 1) uniform usampler2DMS stencil_tex;++layout(location = 0) in vec2 texcoord;++void main() {+ gl_FragDepth = texelFetch(depth_tex, ivec2(texcoord), 0).r;+ gl_FragStencilRefARB = int(texelFetch(stencil_tex, ivec2(texcoord), 0).r);+}diff --git a/src/video_core/host_shaders/convert_msaa_to_non_msaa.frag b/src/video_core/host_shaders/convert_msaa_to_non_msaa.fragnew file mode 100644index 0000000000..6c4aac3c82--- /dev/null+++ b/src/video_core/host_shaders/convert_msaa_to_non_msaa.frag@@ -0,0 +1,22 @@+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#version 450 core++layout(binding = 0) uniform sampler2DMS msaa_in;++layout(push_constant) uniform PushConstants {+ ivec2 dst_offset;+ ivec2 src_offset;+ ivec2 scale;+};++layout(location = 0) out vec4 frag_color;++void main() {+ const ivec2 coord = ivec2(gl_FragCoord.xy) - dst_offset + src_offset;+ const ivec2 msaa_coord = coord / scale;+ const ivec2 sample_offset = coord % scale;+ const int sample_id = sample_offset.x + scale.x * sample_offset.y;+ frag_color = texelFetch(msaa_in, msaa_coord, sample_id);+}diff --git a/src/video_core/host_shaders/convert_non_msaa_to_msaa.frag b/src/video_core/host_shaders/convert_non_msaa_to_msaa.fragnew file mode 100644index 0000000000..19e23849d2--- /dev/null+++ b/src/video_core/host_shaders/convert_non_msaa_to_msaa.frag@@ -0,0 +1,21 @@+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#version 450 core++layout(binding = 0) uniform sampler2D img_in;++layout(push_constant) uniform PushConstants {+ ivec2 dst_offset;+ ivec2 src_offset;+ ivec2 scale;+};++layout(location = 0) out vec4 frag_color;++void main() {+ const ivec2 msaa_coord = ivec2(gl_FragCoord.xy) - dst_offset;+ const ivec2 sample_offset = ivec2(gl_SampleID % scale.x, gl_SampleID / scale.x);+ const ivec2 coord = msaa_coord * scale + sample_offset + src_offset;+ frag_color = texelFetch(img_in, coord, 0);+}diff --git a/src/video_core/renderer_vulkan/blit_image.cpp b/src/video_core/renderer_vulkan/blit_image.cppindex d99e528bc0..89083d29fb 100644--- a/src/video_core/renderer_vulkan/blit_image.cpp+++ b/src/video_core/renderer_vulkan/blit_image.cpp@@ -8,14 +8,20 @@#include "video_core/renderer_vulkan/vk_texture_cache.h"+#include "common/div_ceil.h"#include "common/settings.h"#include "video_core/host_shaders/blit_color_float_frag_spv.h"+#include "video_core/host_shaders/blit_color_msaa_frag_spv.h"+#include "video_core/host_shaders/blit_depth_msaa_frag_spv.h"+#include "video_core/host_shaders/blit_depth_stencil_msaa_frag_spv.h"#include "video_core/host_shaders/convert_abgr8_to_d24s8_frag_spv.h"#include "video_core/host_shaders/convert_abgr8_to_d32f_frag_spv.h"#include "video_core/host_shaders/convert_d24s8_to_abgr8_frag_spv.h"#include "video_core/host_shaders/convert_d32f_to_abgr8_frag_spv.h"#include "video_core/host_shaders/convert_depth_to_float_frag_spv.h"#include "video_core/host_shaders/convert_float_to_depth_frag_spv.h"+#include "video_core/host_shaders/convert_msaa_to_non_msaa_frag_spv.h"+#include "video_core/host_shaders/convert_non_msaa_to_msaa_frag_spv.h"#include "video_core/host_shaders/convert_s8d24_to_abgr8_frag_spv.h"#include "video_core/host_shaders/full_screen_triangle_vert_spv.h"#include "video_core/host_shaders/vulkan_blit_depth_stencil_frag_spv.h"@@ -24,11 +30,13 @@#include "video_core/host_shaders/vulkan_depthstencil_clear_frag_spv.h"#include "video_core/renderer_vulkan/blit_image.h"#include "video_core/renderer_vulkan/maxwell_to_vk.h"+#include "video_core/renderer_vulkan/vk_render_pass_cache.h"#include "video_core/renderer_vulkan/vk_scheduler.h"#include "video_core/renderer_vulkan/vk_shader_util.h"#include "video_core/renderer_vulkan/vk_state_tracker.h"#include "video_core/renderer_vulkan/vk_update_descriptor.h"#include "video_core/surface.h"+#include "video_core/texture_cache/samples_helper.h"#include "video_core/vulkan_common/vulkan_device.h"#include "video_core/vulkan_common/vulkan_wrapper.h"@@ -74,6 +82,12 @@ struct PushConstants {std::array<float, 2> tex_offset;};+struct MSAACopyPushConstants {+ std::array<s32, 2> dst_offset;+ std::array<s32, 2> src_offset;+ std::array<s32, 2> scale;+};+template <u32 binding>inline constexpr VkDescriptorSetLayoutBinding TEXTURE_DESCRIPTOR_SET_LAYOUT_BINDING{.binding = binding,@@ -241,6 +255,21 @@ constexpr VkPipelineDepthStencilStateCreateInfo PIPELINE_DEPTH_STENCIL_STATE_CRE.maxDepthBounds = 0.0f,};+constexpr VkPipelineDepthStencilStateCreateInfo PIPELINE_DEPTH_ONLY_STATE_CREATE_INFO{+ .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,+ .pNext = nullptr,+ .flags = 0,+ .depthTestEnable = VK_TRUE,+ .depthWriteEnable = VK_TRUE,+ .depthCompareOp = VK_COMPARE_OP_ALWAYS,+ .depthBoundsTestEnable = VK_FALSE,+ .stencilTestEnable = VK_FALSE,+ .front = VkStencilOpState{},+ .back = VkStencilOpState{},+ .minDepthBounds = 0.0f,+ .maxDepthBounds = 0.0f,+};+template <VkFilter filter>inline constexpr VkSamplerCreateInfo SAMPLER_CREATE_INFO{.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,@@ -474,6 +503,46 @@ void RecordShaderReadBarrier(Scheduler& scheduler, const ImageView& image_view)});}+[[nodiscard]] VkSampleCountFlagBits SampleCountFlag(u32 num_samples) {+ switch (num_samples) {+ case 2:+ return VK_SAMPLE_COUNT_2_BIT;+ case 4:+ return VK_SAMPLE_COUNT_4_BIT;+ case 8:+ return VK_SAMPLE_COUNT_8_BIT;+ case 16:+ return VK_SAMPLE_COUNT_16_BIT;+ default:+ return VK_SAMPLE_COUNT_1_BIT;+ }+}++[[nodiscard]] vk::ImageView MakeMSAACopyView(const vk::Device& device, VkImage image,+ VkFormat format, u32 base_level) {+ return device.CreateImageView(VkImageViewCreateInfo{+ .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,+ .pNext = nullptr,+ .flags = 0,+ .image = image,+ .viewType = VK_IMAGE_VIEW_TYPE_2D,+ .format = format,+ .components{+ .r = VK_COMPONENT_SWIZZLE_IDENTITY,+ .g = VK_COMPONENT_SWIZZLE_IDENTITY,+ .b = VK_COMPONENT_SWIZZLE_IDENTITY,+ .a = VK_COMPONENT_SWIZZLE_IDENTITY,+ },+ .subresourceRange{+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,+ .baseMipLevel = base_level,+ .levelCount = 1,+ .baseArrayLayer = 0,+ .layerCount = 1,+ },+ });+}+void BeginRenderPass(vk::CommandBuffer& cmdbuf, const Framebuffer* framebuffer) {const VkRenderPass render_pass = framebuffer->RenderPass();const VkFramebuffer framebuffer_handle = framebuffer->Handle();@@ -514,11 +583,19 @@ BlitImageHelper::BlitImageHelper(const Device& device_, Scheduler& scheduler_,PUSH_CONSTANT_RANGE<VK_SHADER_STAGE_VERTEX_BIT, sizeof(PushConstants)>))),clear_color_pipeline_layout(device.GetLogical().CreatePipelineLayout(PipelineLayoutCreateInfo(nullptr, PUSH_CONSTANT_RANGE<VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(float) * 4>))),+ msaa_copy_pipeline_layout(device.GetLogical().CreatePipelineLayout(PipelineLayoutCreateInfo(+ one_texture_set_layout.address(),+ PUSH_CONSTANT_RANGE<VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(MSAACopyPushConstants)>))),full_screen_vert(BuildShader(device, FULL_SCREEN_TRIANGLE_VERT_SPV)),blit_color_to_color_frag(BuildShader(device, BLIT_COLOR_FLOAT_FRAG_SPV)),+ blit_color_msaa_frag(BuildShader(device, BLIT_COLOR_MSAA_FRAG_SPV)),blit_depth_stencil_frag(device.IsExtShaderStencilExportSupported()? BuildShader(device, VULKAN_BLIT_DEPTH_STENCIL_FRAG_SPV): vk::ShaderModule{}),+ blit_depth_msaa_frag(BuildShader(device, BLIT_DEPTH_MSAA_FRAG_SPV)),+ blit_depth_stencil_msaa_frag(device.IsExtShaderStencilExportSupported()+ ? BuildShader(device, BLIT_DEPTH_STENCIL_MSAA_FRAG_SPV)+ : vk::ShaderModule{}),clear_color_vert(BuildShader(device, VULKAN_COLOR_CLEAR_VERT_SPV)),clear_color_frag(BuildShader(device, VULKAN_COLOR_CLEAR_FRAG_SPV)),clear_stencil_frag(BuildShader(device, VULKAN_DEPTHSTENCIL_CLEAR_FRAG_SPV)),@@ -531,6 +608,8 @@ BlitImageHelper::BlitImageHelper(const Device& device_, Scheduler& scheduler_,convert_d32f_to_abgr8_frag(BuildShader(device, CONVERT_D32F_TO_ABGR8_FRAG_SPV)),convert_d24s8_to_abgr8_frag(BuildShader(device, CONVERT_D24S8_TO_ABGR8_FRAG_SPV)),convert_s8d24_to_abgr8_frag(BuildShader(device, CONVERT_S8D24_TO_ABGR8_FRAG_SPV)),+ convert_msaa_to_non_msaa_frag(BuildShader(device, CONVERT_MSAA_TO_NON_MSAA_FRAG_SPV)),+ convert_non_msaa_to_msaa_frag(BuildShader(device, CONVERT_NON_MSAA_TO_MSAA_FRAG_SPV)),linear_sampler(device.GetLogical().CreateSampler(SAMPLER_CREATE_INFO<VK_FILTER_LINEAR>)),nearest_sampler(device.GetLogical().CreateSampler(SAMPLER_CREATE_INFO<VK_FILTER_NEAREST>)) {}@@ -591,6 +670,70 @@ void BlitImageHelper::BlitColor(const Framebuffer* dst_framebuffer, VkImageView});}+void BlitImageHelper::BlitColorMSAA(const Framebuffer* dst_framebuffer,+ const ImageView& src_image_view, const Region2D& dst_region,+ const Region2D& src_region) {+ const BlitMSAAPipelineKey key{+ .renderpass = dst_framebuffer->RenderPass(),+ .samples = dst_framebuffer->Samples(),+ };+ const VkPipelineLayout layout = *one_texture_pipeline_layout;+ const VkSampler sampler = *nearest_sampler;+ const VkPipeline pipeline = FindOrEmplaceBlitColorMSAAPipeline(key);+ const VkImageView src_view = src_image_view.Handle(Shader::TextureType::Color2D);++ RecordShaderReadBarrier(scheduler, src_image_view);+ scheduler.RequestRenderpass(dst_framebuffer);+ scheduler.Record([this, dst_region, src_region, pipeline, layout, sampler,+ src_view](vk::CommandBuffer cmdbuf) {+ const VkDescriptorSet descriptor_set = one_texture_descriptor_allocator.Commit();+ UpdateOneTextureDescriptorSet(device, descriptor_set, sampler, src_view);+ cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);+ cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,+ nullptr);+ BindBlitState(cmdbuf, layout, dst_region, src_region);+ cmdbuf.Draw(3, 1, 0, 0);+ });+ scheduler.InvalidateState();+}++void BlitImageHelper::ResolveDepthStencil(const Framebuffer* dst_framebuffer,+ ImageView& src_image_view, const Region2D& dst_region,+ const Region2D& src_region) {+ const bool resolve_stencil =+ dst_framebuffer->HasAspectStencilBit() && device.IsExtShaderStencilExportSupported();+ const VkPipeline pipeline =+ FindOrEmplaceResolveDepthStencilPipeline(dst_framebuffer->RenderPass(), resolve_stencil);+ const VkPipelineLayout layout =+ resolve_stencil ? *two_textures_pipeline_layout : *one_texture_pipeline_layout;+ const VkSampler sampler = *nearest_sampler;+ const VkImageView src_depth_view = src_image_view.DepthView();+ const VkImageView src_stencil_view =+ resolve_stencil ? src_image_view.StencilView() : VK_NULL_HANDLE;++ RecordShaderReadBarrier(scheduler, src_image_view);+ scheduler.RequestRenderpass(dst_framebuffer);+ scheduler.Record([this, dst_region, src_region, pipeline, layout, sampler, src_depth_view,+ src_stencil_view, resolve_stencil](vk::CommandBuffer cmdbuf) {+ if (resolve_stencil) {+ const VkDescriptorSet descriptor_set = two_textures_descriptor_allocator.Commit();+ UpdateTwoTexturesDescriptorSet(device, descriptor_set, sampler, src_depth_view,+ src_stencil_view);+ cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,+ nullptr);+ } else {+ const VkDescriptorSet descriptor_set = one_texture_descriptor_allocator.Commit();+ UpdateOneTextureDescriptorSet(device, descriptor_set, sampler, src_depth_view);+ cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,+ nullptr);+ }+ cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);+ BindBlitState(cmdbuf, layout, dst_region, src_region);+ cmdbuf.Draw(3, 1, 0, 0);+ });+ scheduler.InvalidateState();+}+void BlitImageHelper::BlitDepthStencil(const Framebuffer* dst_framebuffer,ImageView& src_image_view,const Region2D& dst_region, const Region2D& src_region,@@ -739,6 +882,174 @@ void BlitImageHelper::ClearDepthStencil(const Framebuffer* dst_framebuffer, boolscheduler.InvalidateState();}+void BlitImageHelper::CopyMSAA(RenderPassCache& render_pass_cache, VkImage dst_image,+ VideoCore::Surface::PixelFormat dst_format, VkImage src_image,+ VideoCore::Surface::PixelFormat src_format, u32 num_samples,+ std::span<const VideoCommon::ImageCopy> copies,+ bool msaa_to_non_msaa) {+ while (!msaa_copy_resources.empty() && scheduler.IsFree(msaa_copy_resources.front().tick)) {+ msaa_copy_resources.pop_front();+ }+ const auto [samples_x, samples_y] = VideoCommon::SamplesLog2(static_cast<int>(num_samples));+ const s32 scale_x = 1 << samples_x;+ const s32 scale_y = 1 << samples_y;+ const VkSampleCountFlagBits samples =+ msaa_to_non_msaa ? VK_SAMPLE_COUNT_1_BIT : SampleCountFlag(num_samples);+ RenderPassKey renderpass_key{};+ renderpass_key.color_formats.fill(VideoCore::Surface::PixelFormat::Invalid);+ renderpass_key.color_formats[0] = dst_format;+ renderpass_key.depth_format = VideoCore::Surface::PixelFormat::Invalid;+ renderpass_key.samples = samples;+ const VkRenderPass renderpass = render_pass_cache.Get(renderpass_key);+ const MSAACopyPipelineKey key{+ .renderpass = renderpass,+ .samples = samples,+ .msaa_to_non_msaa = msaa_to_non_msaa,+ };+ const VkPipeline pipeline = FindOrEmplaceMSAACopyPipeline(key);+ const VkPipelineLayout layout = *msaa_copy_pipeline_layout;+ const VkSampler sampler = *nearest_sampler;+ const VkFormat src_vk_format =+ MaxwellToVK::SurfaceFormat(device, FormatType::Optimal, true, src_format).format;+ const VkFormat dst_vk_format =+ MaxwellToVK::SurfaceFormat(device, FormatType::Optimal, true, dst_format).format;+ for (const VideoCommon::ImageCopy& copy : copies) {+ ASSERT(copy.src_subresource.base_layer == 0);+ ASSERT(copy.src_subresource.num_layers == 1);+ ASSERT(copy.dst_subresource.base_layer == 0);+ ASSERT(copy.dst_subresource.num_layers == 1);+ vk::ImageView src_view =+ MakeMSAACopyView(device.GetLogical(), src_image, src_vk_format,+ static_cast<u32>(copy.src_subresource.base_level));+ vk::ImageView dst_view =+ MakeMSAACopyView(device.GetLogical(), dst_image, dst_vk_format,+ static_cast<u32>(copy.dst_subresource.base_level));+ const VkOffset2D dst_offset{copy.dst_offset.x, copy.dst_offset.y};+ const VkExtent2D dst_extent{copy.extent.width, copy.extent.height};+ const VkRect2D render_area{+ .offset = dst_offset,+ .extent = dst_extent,+ };+ vk::Framebuffer framebuffer = device.GetLogical().CreateFramebuffer(VkFramebufferCreateInfo{+ .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,+ .pNext = nullptr,+ .flags = 0,+ .renderPass = renderpass,+ .attachmentCount = 1,+ .pAttachments = dst_view.address(),+ .width = static_cast<u32>(dst_offset.x) + dst_extent.width,+ .height = static_cast<u32>(dst_offset.y) + dst_extent.height,+ .layers = 1,+ });+ const MSAACopyPushConstants push_constants{+ .dst_offset = {dst_offset.x, dst_offset.y},+ .src_offset = {copy.src_offset.x, copy.src_offset.y},+ .scale = {scale_x, scale_y},+ };+ scheduler.RequestOutsideRenderPassOperationContext();+ scheduler.Record([this, pipeline, layout, sampler, renderpass,+ framebuffer_handle = *framebuffer, src_view_handle = *src_view,+ src = src_image, dst = dst_image, render_area,+ push_constants](vk::CommandBuffer cmdbuf) {+ constexpr VkImageSubresourceRange color_range{+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,+ .baseMipLevel = 0,+ .levelCount = VK_REMAINING_MIP_LEVELS,+ .baseArrayLayer = 0,+ .layerCount = VK_REMAINING_ARRAY_LAYERS,+ };+ const std::array pre_barriers{+ VkImageMemoryBarrier{+ .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,+ .pNext = nullptr,+ .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |+ VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,+ .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,+ .oldLayout = VK_IMAGE_LAYOUT_GENERAL,+ .newLayout = VK_IMAGE_LAYOUT_GENERAL,+ .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .image = src,+ .subresourceRange = color_range,+ },+ VkImageMemoryBarrier{+ .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,+ .pNext = nullptr,+ .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |+ VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,+ .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |+ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,+ .oldLayout = VK_IMAGE_LAYOUT_GENERAL,+ .newLayout = VK_IMAGE_LAYOUT_GENERAL,+ .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .image = dst,+ .subresourceRange = color_range,+ },+ };+ cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |+ VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |+ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |+ VK_PIPELINE_STAGE_TRANSFER_BIT,+ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |+ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,+ 0, nullptr, nullptr, pre_barriers);+ const VkRenderPassBeginInfo renderpass_bi{+ .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,+ .pNext = nullptr,+ .renderPass = renderpass,+ .framebuffer = framebuffer_handle,+ .renderArea = render_area,+ .clearValueCount = 0,+ .pClearValues = nullptr,+ };+ cmdbuf.BeginRenderPass(renderpass_bi, VK_SUBPASS_CONTENTS_INLINE);+ const VkDescriptorSet descriptor_set = one_texture_descriptor_allocator.Commit();+ UpdateOneTextureDescriptorSet(device, descriptor_set, sampler, src_view_handle);+ cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);+ cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,+ nullptr);+ const VkViewport viewport{+ .x = static_cast<float>(render_area.offset.x),+ .y = static_cast<float>(render_area.offset.y),+ .width = static_cast<float>(render_area.extent.width),+ .height = static_cast<float>(render_area.extent.height),+ .minDepth = 0.0f,+ .maxDepth = 1.0f,+ };+ cmdbuf.SetViewport(0, viewport);+ cmdbuf.SetScissor(0, render_area);+ cmdbuf.PushConstants(layout, VK_SHADER_STAGE_FRAGMENT_BIT, push_constants);+ cmdbuf.Draw(3, 1, 0, 0);+ cmdbuf.EndRenderPass();+ const VkImageMemoryBarrier post_barrier{+ .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,+ .pNext = nullptr,+ .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,+ .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT,+ .oldLayout = VK_IMAGE_LAYOUT_GENERAL,+ .newLayout = VK_IMAGE_LAYOUT_GENERAL,+ .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .image = dst,+ .subresourceRange = color_range,+ };+ cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,+ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |+ VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |+ VK_PIPELINE_STAGE_TRANSFER_BIT,+ 0, post_barrier);+ });+ msaa_copy_resources.push_back(MSAACopyResources{+ .tick = scheduler.CurrentTick(),+ .src_view = std::move(src_view),+ .dst_view = std::move(dst_view),+ .framebuffer = std::move(framebuffer),+ });+ }+ scheduler.InvalidateState();+}+void BlitImageHelper::Convert(VkPipeline pipeline, const Framebuffer* dst_framebuffer,const ImageView& src_image_view) {const VkPipelineLayout layout = *one_texture_pipeline_layout;@@ -905,7 +1216,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceDepthStencilPipeline(const BlitImagePip.pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,.pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,.pDepthStencilState = &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,- .pColorBlendState = &PIPELINE_COLOR_BLEND_STATE_GENERIC_CREATE_INFO,+ .pColorBlendState = &PIPELINE_COLOR_BLEND_STATE_EMPTY_CREATE_INFO,.pDynamicState = &PIPELINE_DYNAMIC_STATE_CREATE_INFO,.layout = *two_textures_pipeline_layout,.renderPass = key.renderpass,@@ -1025,14 +1336,63 @@ VkPipeline BlitImageHelper::FindOrEmplaceClearStencilPipeline(return *clear_stencil_pipelines.back();}-void BlitImageHelper::ConvertDepthToColorPipeline(vk::Pipeline& pipeline, VkRenderPass renderpass) {- if (pipeline) {- return;+VkPipeline BlitImageHelper::FindOrEmplaceBlitColorMSAAPipeline(const BlitMSAAPipelineKey& key) {+ const auto it = std::ranges::find(blit_msaa_color_keys, key);+ if (it != blit_msaa_color_keys.end()) {+ return *blit_msaa_color_pipelines[std::distance(blit_msaa_color_keys.begin(), it)];}- VkShaderModule frag_shader = *convert_float_to_depth_frag;- const std::array stages = MakeStages(*full_screen_vert, frag_shader);+ blit_msaa_color_keys.push_back(key);+ const std::array stages = MakeStages(*full_screen_vert, *blit_color_msaa_frag);+ const VkPipelineMultisampleStateCreateInfo multisample_ci{+ .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,+ .pNext = nullptr,+ .flags = 0,+ .rasterizationSamples = key.samples,+ .sampleShadingEnable = VK_TRUE,+ .minSampleShading = 1.0f,+ .pSampleMask = nullptr,+ .alphaToCoverageEnable = VK_FALSE,+ .alphaToOneEnable = VK_FALSE,+ };const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);- pipeline = device.GetLogical().CreateGraphicsPipeline(VkGraphicsPipelineCreateInfo{+ blit_msaa_color_pipelines.push_back(device.GetLogical().CreateGraphicsPipeline({+ .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,+ .pNext = nullptr,+ .flags = 0,+ .stageCount = static_cast<u32>(stages.size()),+ .pStages = stages.data(),+ .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,+ .pInputAssemblyState = &input_assembly_ci,+ .pTessellationState = nullptr,+ .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,+ .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,+ .pMultisampleState = &multisample_ci,+ .pDepthStencilState = nullptr,+ .pColorBlendState = &PIPELINE_COLOR_BLEND_STATE_GENERIC_CREATE_INFO,+ .pDynamicState = &PIPELINE_DYNAMIC_STATE_CREATE_INFO,+ .layout = *one_texture_pipeline_layout,+ .renderPass = key.renderpass,+ .subpass = 0,+ .basePipelineHandle = VK_NULL_HANDLE,+ .basePipelineIndex = 0,+ }));+ return *blit_msaa_color_pipelines.back();+}++VkPipeline BlitImageHelper::FindOrEmplaceResolveDepthStencilPipeline(VkRenderPass renderpass,+ bool resolve_stencil) {+ auto& keys = resolve_stencil ? resolve_depth_stencil_keys : resolve_depth_keys;+ auto& pipelines = resolve_stencil ? resolve_depth_stencil_pipelines : resolve_depth_pipelines;+ const auto it = std::ranges::find(keys, renderpass);+ if (it != keys.end()) {+ return *pipelines[std::distance(keys.begin(), it)];+ }+ keys.push_back(renderpass);+ const std::array stages =+ MakeStages(*full_screen_vert,+ resolve_stencil ? *blit_depth_stencil_msaa_frag : *blit_depth_msaa_frag);+ const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);+ pipelines.push_back(device.GetLogical().CreateGraphicsPipeline({.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,.pNext = nullptr,.flags = 0,@@ -1044,25 +1404,41 @@ void BlitImageHelper::ConvertDepthToColorPipeline(vk::Pipeline& pipeline, VkRend.pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,.pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,.pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,- .pDepthStencilState = &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,+ .pDepthStencilState = resolve_stencil ? &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO+ : &PIPELINE_DEPTH_ONLY_STATE_CREATE_INFO,.pColorBlendState = &PIPELINE_COLOR_BLEND_STATE_EMPTY_CREATE_INFO,.pDynamicState = &PIPELINE_DYNAMIC_STATE_CREATE_INFO,- .layout = *one_texture_pipeline_layout,+ .layout = resolve_stencil ? *two_textures_pipeline_layout : *one_texture_pipeline_layout,.renderPass = renderpass,.subpass = 0,.basePipelineHandle = VK_NULL_HANDLE,.basePipelineIndex = 0,- });+ }));+ return *pipelines.back();}-void BlitImageHelper::ConvertColorToDepthPipeline(vk::Pipeline& pipeline, VkRenderPass renderpass) {- if (pipeline) {- return;+VkPipeline BlitImageHelper::FindOrEmplaceMSAACopyPipeline(const MSAACopyPipelineKey& key) {+ const auto it = std::ranges::find(msaa_copy_keys, key);+ if (it != msaa_copy_keys.end()) {+ return *msaa_copy_pipelines[std::distance(msaa_copy_keys.begin(), it)];}- VkShaderModule frag_shader = *convert_depth_to_float_frag;- const std::array stages = MakeStages(*full_screen_vert, frag_shader);+ msaa_copy_keys.push_back(key);+ const std::array stages = MakeStages(*clear_color_vert, key.msaa_to_non_msaa+ ? *convert_msaa_to_non_msaa_frag+ : *convert_non_msaa_to_msaa_frag);+ const VkPipelineMultisampleStateCreateInfo multisample_ci{+ .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,+ .pNext = nullptr,+ .flags = 0,+ .rasterizationSamples = key.samples,+ .sampleShadingEnable = key.msaa_to_non_msaa ? VK_FALSE : VK_TRUE,+ .minSampleShading = key.msaa_to_non_msaa ? 0.0f : 1.0f,+ .pSampleMask = nullptr,+ .alphaToCoverageEnable = VK_FALSE,+ .alphaToOneEnable = VK_FALSE,+ };const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);- pipeline = device.GetLogical().CreateGraphicsPipeline(VkGraphicsPipelineCreateInfo{+ msaa_copy_pipelines.push_back(device.GetLogical().CreateGraphicsPipeline({.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,.pNext = nullptr,.flags = 0,@@ -1073,16 +1449,25 @@ void BlitImageHelper::ConvertColorToDepthPipeline(vk::Pipeline& pipeline, VkRend.pTessellationState = nullptr,.pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,.pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,- .pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,- .pDepthStencilState = &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,+ .pMultisampleState = &multisample_ci,+ .pDepthStencilState = nullptr,.pColorBlendState = &PIPELINE_COLOR_BLEND_STATE_GENERIC_CREATE_INFO,.pDynamicState = &PIPELINE_DYNAMIC_STATE_CREATE_INFO,- .layout = *one_texture_pipeline_layout,- .renderPass = renderpass,+ .layout = *msaa_copy_pipeline_layout,+ .renderPass = key.renderpass,.subpass = 0,.basePipelineHandle = VK_NULL_HANDLE,.basePipelineIndex = 0,- });+ }));+ return *msaa_copy_pipelines.back();+}++void BlitImageHelper::ConvertDepthToColorPipeline(vk::Pipeline& pipeline, VkRenderPass renderpass) {+ ConvertPipeline(pipeline, renderpass, false);+}++void BlitImageHelper::ConvertColorToDepthPipeline(vk::Pipeline& pipeline, VkRenderPass renderpass) {+ ConvertPipeline(pipeline, renderpass, true);}void BlitImageHelper::ConvertPipelineEx(vk::Pipeline& pipeline, VkRenderPass renderpass,@@ -1106,7 +1491,8 @@ void BlitImageHelper::ConvertPipelineEx(vk::Pipeline& pipeline, VkRenderPass ren.pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,.pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,.pDepthStencilState = is_target_depth ? &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO : nullptr,- .pColorBlendState = &PIPELINE_COLOR_BLEND_STATE_GENERIC_CREATE_INFO,+ .pColorBlendState = is_target_depth ? &PIPELINE_COLOR_BLEND_STATE_EMPTY_CREATE_INFO+ : &PIPELINE_COLOR_BLEND_STATE_GENERIC_CREATE_INFO,.pDynamicState = &PIPELINE_DYNAMIC_STATE_CREATE_INFO,.layout = single_texture ? *one_texture_pipeline_layout : *two_textures_pipeline_layout,.renderPass = renderpass,diff --git a/src/video_core/renderer_vulkan/blit_image.h b/src/video_core/renderer_vulkan/blit_image.hindex 34f1b25f0f..67294d594b 100644--- a/src/video_core/renderer_vulkan/blit_image.h+++ b/src/video_core/renderer_vulkan/blit_image.h@@ -6,8 +6,12 @@#pragma once+#include <deque>+#include <span>+#include "video_core/engines/fermi_2d.h"#include "video_core/renderer_vulkan/vk_descriptor_pool.h"+#include "video_core/surface.h"#include "video_core/texture_cache/types.h"#include "video_core/vulkan_common/vulkan_wrapper.h"@@ -20,6 +24,7 @@ using VideoCommon::Region2D;class Device;class Framebuffer;class ImageView;+class RenderPassCache;class StateTracker;class Scheduler;@@ -40,6 +45,21 @@ struct BlitDepthStencilPipelineKey {u32 stencil_ref;};+struct MSAACopyPipelineKey {+ constexpr auto operator<=>(const MSAACopyPipelineKey&) const noexcept = default;++ VkRenderPass renderpass;+ VkSampleCountFlagBits samples;+ bool msaa_to_non_msaa;+};++struct BlitMSAAPipelineKey {+ constexpr auto operator<=>(const BlitMSAAPipelineKey&) const noexcept = default;++ VkRenderPass renderpass;+ VkSampleCountFlagBits samples;+};+class BlitImageHelper {public:explicit BlitImageHelper(const Device& device, Scheduler& scheduler,@@ -55,6 +75,12 @@ public:VkImage src_image, VkSampler src_sampler, const Region2D& dst_region,const Region2D& src_region, const Extent3D& src_size);+ void BlitColorMSAA(const Framebuffer* dst_framebuffer, const ImageView& src_image_view,+ const Region2D& dst_region, const Region2D& src_region);++ void ResolveDepthStencil(const Framebuffer* dst_framebuffer, ImageView& src_image_view,+ const Region2D& dst_region, const Region2D& src_region);+void BlitDepthStencil(const Framebuffer* dst_framebuffer, ImageView& src_image_view,const Region2D& dst_region, const Region2D& src_region,Tegra::Engines::Fermi2D::Filter filter,@@ -84,6 +110,12 @@ public:void ClearDepthStencil(const Framebuffer* dst_framebuffer, bool depth_clear, f32 clear_depth,u8 stencil_mask, u32 stencil_ref, u32 stencil_compare_mask,const Region2D& dst_region);++ void CopyMSAA(RenderPassCache& render_pass_cache, VkImage dst_image,+ VideoCore::Surface::PixelFormat dst_format, VkImage src_image,+ VideoCore::Surface::PixelFormat src_format, u32 num_samples,+ std::span<const VideoCommon::ImageCopy> copies, bool msaa_to_non_msaa);+private:void Convert(VkPipeline pipeline, const Framebuffer* dst_framebuffer,const ImageView& src_image_view);@@ -98,6 +130,10 @@ private:[[nodiscard]] VkPipeline FindOrEmplaceClearColorPipeline(const BlitImagePipelineKey& key);[[nodiscard]] VkPipeline FindOrEmplaceClearStencilPipeline(const BlitDepthStencilPipelineKey& key);+ [[nodiscard]] VkPipeline FindOrEmplaceMSAACopyPipeline(const MSAACopyPipelineKey& key);+ [[nodiscard]] VkPipeline FindOrEmplaceBlitColorMSAAPipeline(const BlitMSAAPipelineKey& key);+ [[nodiscard]] VkPipeline FindOrEmplaceResolveDepthStencilPipeline(VkRenderPass renderpass,+ bool resolve_stencil);void ConvertPipeline(vk::Pipeline& pipeline, VkRenderPass renderpass, bool is_target_depth);@@ -125,9 +161,13 @@ private:vk::PipelineLayout one_texture_pipeline_layout;vk::PipelineLayout two_textures_pipeline_layout;vk::PipelineLayout clear_color_pipeline_layout;+ vk::PipelineLayout msaa_copy_pipeline_layout;vk::ShaderModule full_screen_vert;vk::ShaderModule blit_color_to_color_frag;+ vk::ShaderModule blit_color_msaa_frag;vk::ShaderModule blit_depth_stencil_frag;+ vk::ShaderModule blit_depth_msaa_frag;+ vk::ShaderModule blit_depth_stencil_msaa_frag;vk::ShaderModule clear_color_vert;vk::ShaderModule clear_color_frag;vk::ShaderModule clear_stencil_frag;@@ -138,6 +178,8 @@ private:vk::ShaderModule convert_d32f_to_abgr8_frag;vk::ShaderModule convert_d24s8_to_abgr8_frag;vk::ShaderModule convert_s8d24_to_abgr8_frag;+ vk::ShaderModule convert_msaa_to_non_msaa_frag;+ vk::ShaderModule convert_non_msaa_to_msaa_frag;vk::Sampler linear_sampler;vk::Sampler nearest_sampler;@@ -149,6 +191,21 @@ private:std::vector<vk::Pipeline> clear_color_pipelines;std::vector<BlitDepthStencilPipelineKey> clear_stencil_keys;std::vector<vk::Pipeline> clear_stencil_pipelines;+ std::vector<MSAACopyPipelineKey> msaa_copy_keys;+ std::vector<vk::Pipeline> msaa_copy_pipelines;+ std::vector<BlitMSAAPipelineKey> blit_msaa_color_keys;+ std::vector<vk::Pipeline> blit_msaa_color_pipelines;+ std::vector<VkRenderPass> resolve_depth_keys;+ std::vector<vk::Pipeline> resolve_depth_pipelines;+ std::vector<VkRenderPass> resolve_depth_stencil_keys;+ std::vector<vk::Pipeline> resolve_depth_stencil_pipelines;+ struct MSAACopyResources {+ u64 tick;+ vk::ImageView src_view;+ vk::ImageView dst_view;+ vk::Framebuffer framebuffer;+ };+ std::deque<MSAACopyResources> msaa_copy_resources;vk::Pipeline convert_d32_to_r32_pipeline;vk::Pipeline convert_r32_to_d32_pipeline;vk::Pipeline convert_d16_to_r16_pipeline;diff --git a/src/video_core/renderer_vulkan/vk_compute_pass.cpp b/src/video_core/renderer_vulkan/vk_compute_pass.cppindex edc0283d9a..80c434dc8f 100644--- a/src/video_core/renderer_vulkan/vk_compute_pass.cpp+++ b/src/video_core/renderer_vulkan/vk_compute_pass.cpp@@ -17,8 +17,6 @@#include "common/div_ceil.h"#include "common/vector_math.h"#include "video_core/host_shaders/astc_decoder_comp_spv.h"-#include "video_core/host_shaders/convert_msaa_to_non_msaa_comp_spv.h"-#include "video_core/host_shaders/convert_non_msaa_to_msaa_comp_spv.h"#include "video_core/host_shaders/queries_prefix_scan_sum_comp_spv.h"#include "video_core/host_shaders/queries_prefix_scan_sum_nosubgroups_comp_spv.h"#include "video_core/host_shaders/resolve_conditional_render_comp_spv.h"@@ -140,33 +138,6 @@ constexpr DescriptorBankInfo ASTC_BANK_INFO{.score = 2,};-constexpr std::array<VkDescriptorSetLayoutBinding, ASTC_NUM_BINDINGS> MSAA_DESCRIPTOR_SET_BINDINGS{{- {- .binding = 0,- .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,- .descriptorCount = 1,- .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,- .pImmutableSamplers = nullptr,- },- {- .binding = 1,- .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,- .descriptorCount = 1,- .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,- .pImmutableSamplers = nullptr,- },-}};--constexpr DescriptorBankInfo MSAA_BANK_INFO{- .uniform_buffers = 0,- .storage_buffers = 0,- .texture_buffers = 0,- .image_buffers = 0,- .textures = 0,- .images = 2,- .score = 2,-};-constexpr VkDescriptorUpdateTemplateEntry INPUT_OUTPUT_DESCRIPTOR_UPDATE_TEMPLATE{.dstBinding = 0,.dstArrayElement = 0,@@ -185,15 +156,6 @@ constexpr VkDescriptorUpdateTemplateEntry QUERIES_SCAN_DESCRIPTOR_UPDATE_TEMPLAT.stride = sizeof(DescriptorUpdateEntry),};-constexpr VkDescriptorUpdateTemplateEntry MSAA_DESCRIPTOR_UPDATE_TEMPLATE{- .dstBinding = 0,- .dstArrayElement = 0,- .descriptorCount = 2,- .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,- .offset = 0,- .stride = sizeof(DescriptorUpdateEntry),-};-constexpr std::array<VkDescriptorUpdateTemplateEntry, ASTC_NUM_BINDINGS>ASTC_PASS_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY{{{@@ -910,100 +872,4 @@ void BlockLinearUnswizzle3DPass::UnswizzleChunk(});}-MSAACopyPass::MSAACopyPass(const Device& device_, Scheduler& scheduler_,- DescriptorPool& descriptor_pool_,- StagingBufferPool& staging_buffer_pool_,- ComputePassDescriptorQueue& compute_pass_descriptor_queue_)- : ComputePass(device_, scheduler_, descriptor_pool_, MSAA_DESCRIPTOR_SET_BINDINGS,- MSAA_DESCRIPTOR_UPDATE_TEMPLATE, MSAA_BANK_INFO, {},- CONVERT_NON_MSAA_TO_MSAA_COMP_SPV),- scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},- compute_pass_descriptor_queue{compute_pass_descriptor_queue_} {- const auto make_msaa_pipeline = [this](size_t i, std::span<const u32> code) {- modules[i] = device.GetLogical().CreateShaderModule({- .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,- .pNext = nullptr,- .flags = 0,- .codeSize = static_cast<u32>(code.size_bytes()),- .pCode = code.data(),- });- pipelines[i] = device.GetLogical().CreateComputePipeline(VkComputePipelineCreateInfo{- .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,- .pNext = nullptr,- .flags = 0,- .stage{- .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,- .pNext = nullptr,- .flags = 0,- .stage = VK_SHADER_STAGE_COMPUTE_BIT,- .module = *modules[i],- .pName = "main",- .pSpecializationInfo = nullptr,- },- .layout = *layout,- .basePipelineHandle = {},- .basePipelineIndex = 0,- });- };- make_msaa_pipeline(0, CONVERT_NON_MSAA_TO_MSAA_COMP_SPV);- make_msaa_pipeline(1, CONVERT_MSAA_TO_NON_MSAA_COMP_SPV);-}--MSAACopyPass::~MSAACopyPass() = default;--void MSAACopyPass::CopyImage(Image& dst_image, Image& src_image,- std::span<const VideoCommon::ImageCopy> copies,- bool msaa_to_non_msaa) {- const VkPipeline msaa_pipeline = *pipelines[msaa_to_non_msaa ? 1 : 0];- scheduler.RequestOutsideRenderPassOperationContext();- for (const VideoCommon::ImageCopy& copy : copies) {- ASSERT(copy.src_subresource.base_layer == 0);- ASSERT(copy.src_subresource.num_layers == 1);- ASSERT(copy.dst_subresource.base_layer == 0);- ASSERT(copy.dst_subresource.num_layers == 1);-- compute_pass_descriptor_queue.Acquire(scheduler, 2);- compute_pass_descriptor_queue.AddImage(- src_image.StorageImageView(copy.src_subresource.base_level));- compute_pass_descriptor_queue.AddImage(- dst_image.StorageImageView(copy.dst_subresource.base_level));- const void* const descriptor_data{compute_pass_descriptor_queue.UpdateData()};-- const Common::Vec3<u32> num_dispatches = {- Common::DivCeil(copy.extent.width, 8U),- Common::DivCeil(copy.extent.height, 8U),- copy.extent.depth,- };-- scheduler.Record([this, dst = dst_image.Handle(), msaa_pipeline, num_dispatches,- descriptor_data](vk::CommandBuffer cmdbuf) {- const VkDescriptorSet set = descriptor_allocator.Commit();- device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);- cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, msaa_pipeline);- cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});- cmdbuf.Dispatch(num_dispatches.x, num_dispatches.y, num_dispatches.z);- const VkImageMemoryBarrier write_barrier{- .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,- .pNext = nullptr,- .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,- .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,- .oldLayout = VK_IMAGE_LAYOUT_GENERAL,- .newLayout = VK_IMAGE_LAYOUT_GENERAL,- .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,- .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,- .image = dst,- .subresourceRange{- .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,- .baseMipLevel = 0,- .levelCount = VK_REMAINING_MIP_LEVELS,- .baseArrayLayer = 0,- .layerCount = VK_REMAINING_ARRAY_LAYERS,- },- };- cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,- VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, write_barrier);- });- }-}-} // namespace Vulkandiff --git a/src/video_core/renderer_vulkan/vk_compute_pass.h b/src/video_core/renderer_vulkan/vk_compute_pass.hindex cb213dae7e..3d30aa6bdc 100644--- a/src/video_core/renderer_vulkan/vk_compute_pass.h+++ b/src/video_core/renderer_vulkan/vk_compute_pass.h@@ -164,23 +164,4 @@ private:ComputePassDescriptorQueue& compute_pass_descriptor_queue;};--class MSAACopyPass final : public ComputePass {-public:- explicit MSAACopyPass(const Device& device_, Scheduler& scheduler_,- DescriptorPool& descriptor_pool_, StagingBufferPool& staging_buffer_pool_,- ComputePassDescriptorQueue& compute_pass_descriptor_queue_);- ~MSAACopyPass();-- void CopyImage(Image& dst_image, Image& src_image,- std::span<const VideoCommon::ImageCopy> copies, bool msaa_to_non_msaa);--private:- Scheduler& scheduler;- StagingBufferPool& staging_buffer_pool;- ComputePassDescriptorQueue& compute_pass_descriptor_queue;- std::array<vk::ShaderModule, 2> modules;- std::array<vk::Pipeline, 2> pipelines;-};-} // namespace Vulkandiff --git a/src/video_core/renderer_vulkan/vk_compute_pipeline.h b/src/video_core/renderer_vulkan/vk_compute_pipeline.hindex c9704b7c6c..073e4b5079 100644--- a/src/video_core/renderer_vulkan/vk_compute_pipeline.h+++ b/src/video_core/renderer_vulkan/vk_compute_pipeline.h@@ -48,6 +48,10 @@ public:void Configure(Tegra::Engines::KeplerCompute& kepler_compute, Tegra::MemoryManager& gpu_memory,Scheduler& scheduler, BufferCache& buffer_cache, TextureCache& texture_cache);+ bool IsBound() const noexcept {+ return static_cast<bool>(pipeline);+ }+private:const Device& device;vk::PipelineCache& pipeline_cache;diff --git a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cppindex 9c9a599f2e..757e0f3ccf 100644--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp@@ -124,8 +124,8 @@ PixelFormat DecodeFormat(u8 encoded_format) {return PixelFormatFromRenderTargetFormat(format);}-RenderPassKey MakeRenderPassKey(const FixedPipelineState& state) {- RenderPassKey key;+RenderPassKey MakeRenderPassKey(const FixedPipelineState& state, const Device& device) {+ RenderPassKey key{};std::ranges::transform(state.color_formats, key.color_formats.begin(), DecodeFormat);if (state.depth_enabled != 0) {const auto depth_format{static_cast<Tegra::DepthFormat>(state.depth_format.Value())};@@ -134,6 +134,11 @@ RenderPassKey MakeRenderPassKey(const FixedPipelineState& state) {key.depth_format = PixelFormat::Invalid;}key.samples = MaxwellToVK::MsaaMode(state.msaa_mode);+ const bool has_color = std::ranges::any_of(key.color_formats, [](PixelFormat format) {+ return format != PixelFormat::Invalid;+ });+ key.resolve_color =+ key.samples != VK_SAMPLE_COUNT_1_BIT && has_color && device.IsTiler();return key;}@@ -285,9 +290,20 @@ GraphicsPipeline::GraphicsPipeline(descriptor_update_template =builder.CreateTemplate(set_layout, *pipeline_layout, uses_push_descriptor);- const VkRenderPass render_pass{render_pass_cache.Get(MakeRenderPassKey(key.state))};+ const VkRenderPass render_pass{render_pass_cache.Get(MakeRenderPassKey(key.state, device))};Validate();- MakePipeline(render_pass);+ try {+ MakePipeline(render_pass);+ } catch (const vk::Exception& exception) {+ LOG_CRITICAL(Render_Vulkan, "Graphics pipeline build failed: {}", exception.what());+ std::scoped_lock lock{build_mutex};+ is_built = true;+ build_condvar.notify_one();+ if (shader_notify) {+ shader_notify->MarkShaderComplete();+ }+ return;+ }if (pipeline_statistics) {pipeline_statistics->Collect(device, *pipeline);}@@ -519,6 +535,9 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {texture_cache.UpdateRenderTargets(false);texture_cache.CheckFeedbackLoop(std::span<const VideoCommon::ImageViewInOut>{views.data(),views.size()});+ if (IsBuilt() && !pipeline) {+ return false;+ }ConfigureDraw(rescaling, render_area);return true;@@ -551,6 +570,9 @@ void GraphicsPipeline::ConfigureDraw(const RescalingPushConstant& rescaling,uses_render_area = render_area.uses_render_area,render_area_data = render_area.words](vk::CommandBuffer cmdbuf) {if (bind_pipeline) {+ if (!pipeline) {+ return;+ }cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);}cmdbuf.PushConstants(*pipeline_layout, VK_SHADER_STAGE_ALL_GRAPHICS,diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cppindex 6ca9fe4c71..0ff4e52c54 100644--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp@@ -374,9 +374,11 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,.support_int8 = device.IsInt8Supported(),.support_uniform_and_storage_buffer_8bit =device.IsUniformAndStorageBuffer8BitAccessSupported(),+ .support_storage_buffer_8bit = device.IsStorageBuffer8BitAccessSupported(),.support_int16 = device.IsShaderInt16Supported(),.support_uniform_and_storage_buffer_16bit =device.IsUniformAndStorageBuffer16BitAccessSupported(),+ .support_storage_buffer_16bit = device.IsStorageBuffer16BitAccessSupported(),.support_int64 = device.IsShaderInt64Supported(),.support_vertex_instance_id = false,.support_float_controls = device.IsKhrShaderFloatControlsSupported(),@@ -395,6 +397,10 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,.support_fp64_signed_zero_nan_preserve =float_control.shaderSignedZeroInfNanPreserveFloat64 != VK_FALSE,.support_explicit_workgroup_layout = device.IsKhrWorkgroupMemoryExplicitLayoutSupported(),+ .support_workgroup_layout_8bit_access =+ device.IsWorkgroupMemoryExplicitLayout8BitAccessSupported(),+ .support_workgroup_layout_16bit_access =+ device.IsWorkgroupMemoryExplicitLayout16BitAccessSupported(),.support_vote = device.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_VOTE_BIT),.supported_subgroup_stages = supported_subgroup_stages,.support_viewport_index_layer_non_geometry =@@ -404,6 +410,7 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,.support_demote_to_helper_invocation =device.IsExtShaderDemoteToHelperInvocationSupported(),.support_int64_atomics = device.IsExtShaderAtomicInt64Supported(),+ .support_shared_int64_atomics = device.IsSharedInt64AtomicsSupported(),.support_derivative_control = true,.support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),.support_native_ndc = device.IsExtDepthClipControlSupported(),@@ -412,6 +419,12 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,.support_geometry_streams = device.AreTransformFeedbackGeometryStreamsSupported(),.support_sampled_image_array_nonuniform_indexing =device.IsSampledImageArrayNonUniformIndexingSupported(),+ .support_storage_image_array_nonuniform_indexing =+ device.IsStorageImageArrayNonUniformIndexingSupported(),+ .support_uniform_texel_buffer_array_nonuniform_indexing =+ device.IsUniformTexelBufferArrayNonUniformIndexingSupported(),+ .support_storage_texel_buffer_array_nonuniform_indexing =+ device.IsStorageTexelBufferArrayNonUniformIndexingSupported(),.warp_size_potentially_larger_than_guest = device.IsWarpSizePotentiallyBiggerThanGuest(),diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.cpp b/src/video_core/renderer_vulkan/vk_rasterizer.cppindex 26663d4b25..720f3b868c 100644--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp@@ -410,7 +410,23 @@ void RasterizerVulkan::Clear(u32 layer_count) {texture_cache.UpdateRenderTargets(true);const Framebuffer* const framebuffer = texture_cache.GetFramebuffer();const VkExtent2D render_area = framebuffer->RenderArea();- scheduler.RequestRenderpass(framebuffer);++ constexpr bool ENABLE_DEFERRED_CLEAR = true;+ const bool color_full_channels = regs.clear_surface.R && regs.clear_surface.G &&+ regs.clear_surface.B && regs.clear_surface.A;+ const bool stencil_partial = use_stencil && framebuffer->HasAspectStencilBit() &&+ regs.stencil_front_mask != 0xFF && regs.stencil_front_mask != 0;+ const bool ds_used = use_depth || use_stencil;+ const bool ds_deferrable =+ !ds_used || ((!framebuffer->HasAspectDepthBit() || use_depth) &&+ (!framebuffer->HasAspectStencilBit() || use_stencil) && !stencil_partial);+ const bool can_defer_clear = ENABLE_DEFERRED_CLEAR && !regs.clear_control.use_scissor &&+ regs.clear_surface.layer == 0 &&+ !scheduler.IsRenderPassActive() &&+ (!use_color || color_full_channels) && ds_deferrable;+ if (!can_defer_clear) {+ scheduler.RequestRenderpass(framebuffer);+ }query_cache.NotifySegment(true);query_cache.CounterEnable(VideoCommon::QueryType::ZPassPixelCount64, maxwell3d->regs.zpass_pixel_count_enable);@@ -494,15 +510,19 @@ void RasterizerVulkan::Clear(u32 layer_count) {clear_value.color.int32[i] = s32(f32(s64(int_size - 1) << 1) * (regs.clear_color[i] - 0.5f));}- if (regs.clear_surface.R && regs.clear_surface.G && regs.clear_surface.B && regs.clear_surface.A) {- scheduler.Record([color_attachment, clear_value, clear_rect](vk::CommandBuffer cmdbuf) {- const VkClearAttachment attachment{- .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,- .colorAttachment = color_attachment,- .clearValue = clear_value,- };- cmdbuf.ClearAttachments(attachment, clear_rect);- });+ if (color_full_channels) {+ if (can_defer_clear) {+ scheduler.DeferColorClear(framebuffer, color_attachment, clear_value);+ } else {+ scheduler.Record([color_attachment, clear_value, clear_rect](vk::CommandBuffer cmdbuf) {+ const VkClearAttachment attachment{+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,+ .colorAttachment = color_attachment,+ .clearValue = clear_value,+ };+ cmdbuf.ClearAttachments(attachment, clear_rect);+ });+ }} else {u8 color_mask = u8(regs.clear_surface.R | regs.clear_surface.G << 1 | regs.clear_surface.B << 2 | regs.clear_surface.A << 3);Region2D dst_region = {@@ -536,6 +556,11 @@ void RasterizerVulkan::Clear(u32 layer_count) {blit_image.ClearDepthStencil(framebuffer, use_depth, regs.clear_depth,u8(regs.stencil_front_mask), regs.clear_stencil,regs.stencil_front_func_mask, dst_region);+ } else if (can_defer_clear) {+ VkClearValue ds_value{};+ ds_value.depthStencil.depth = regs.clear_depth;+ ds_value.depthStencil.stencil = regs.clear_stencil;+ scheduler.DeferDepthStencilClear(framebuffer, ds_value);} else {scheduler.Record([clear_depth = regs.clear_depth, clear_stencil = regs.clear_stencil,clear_rect, aspect_flags](vk::CommandBuffer cmdbuf) {@@ -569,13 +594,20 @@ void RasterizerVulkan::DispatchCompute() {const auto [buffer, offset] =buffer_cache.ObtainBuffer(*indirect_address, 12, sync_info, post_op);scheduler.RequestOutsideRenderPassOperationContext();- scheduler.Record([indirect_buffer = buffer->Handle(),+ scheduler.Record([pipeline, indirect_buffer = buffer->Handle(),indirect_offset = offset](vk::CommandBuffer cmdbuf) {+ if (!pipeline->IsBound()) {+ return;+ }cmdbuf.DispatchIndirect(indirect_buffer, indirect_offset);});return;}const std::array<u32, 3> dim{qmd.grid_dim_x, qmd.grid_dim_y, qmd.grid_dim_z};+ const std::array<u32, 3> max_dim{device.GetMaxComputeWorkGroupCount()};+ if (dim[0] > max_dim[0] || dim[1] > max_dim[1] || dim[2] > max_dim[2]) {+ return;+ }scheduler.RequestOutsideRenderPassOperationContext();static constexpr VkMemoryBarrier READ_BARRIER{.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,@@ -585,7 +617,12 @@ void RasterizerVulkan::DispatchCompute() {};scheduler.Record([](vk::CommandBuffer cmdbuf) { cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,0, READ_BARRIER); });- scheduler.Record([dim](vk::CommandBuffer cmdbuf) { cmdbuf.Dispatch(dim[0], dim[1], dim[2]); });+ scheduler.Record([pipeline, dim](vk::CommandBuffer cmdbuf) {+ if (!pipeline->IsBound()) {+ return;+ }+ cmdbuf.Dispatch(dim[0], dim[1], dim[2]);+ });// Log compute dispatchif (GPU::Logging::IsActive() &&@@ -1309,15 +1346,22 @@ void RasterizerVulkan::UpdateStencilFaces(Tegra::Engines::Maxwell3D::Regs& regs)}if (update_references) {[&]() {+ bool changed;if (regs.stencil_two_side_enable) {- if (!state_tracker.CheckStencilReferenceFront(regs.stencil_front_ref) &&- !state_tracker.CheckStencilReferenceBack(regs.stencil_back_ref)) {- return;- }+ const bool front_changed =+ state_tracker.CheckStencilReferenceFront(regs.stencil_front_ref);+ const bool back_changed =+ state_tracker.CheckStencilReferenceBack(regs.stencil_back_ref);+ changed = front_changed || back_changed;} else {- if (!state_tracker.CheckStencilReferenceFront(regs.stencil_front_ref)) {- return;- }+ const bool front_changed =+ state_tracker.CheckStencilReferenceFront(regs.stencil_front_ref);+ const bool back_changed =+ state_tracker.CheckStencilReferenceBack(regs.stencil_front_ref);+ changed = front_changed || back_changed;+ }+ if (!changed) {+ return;}scheduler.Record([front_ref = regs.stencil_front_ref, back_ref = regs.stencil_back_ref,two_sided = regs.stencil_two_side_enable](vk::CommandBuffer cmdbuf) {@@ -1334,15 +1378,22 @@ void RasterizerVulkan::UpdateStencilFaces(Tegra::Engines::Maxwell3D::Regs& regs)}if (update_write_mask) {[&]() {+ bool changed;if (regs.stencil_two_side_enable) {- if (!state_tracker.CheckStencilWriteMaskFront(regs.stencil_front_mask) &&- !state_tracker.CheckStencilWriteMaskBack(regs.stencil_back_mask)) {- return;- }+ const bool front_changed =+ state_tracker.CheckStencilWriteMaskFront(regs.stencil_front_mask);+ const bool back_changed =+ state_tracker.CheckStencilWriteMaskBack(regs.stencil_back_mask);+ changed = front_changed || back_changed;} else {- if (!state_tracker.CheckStencilWriteMaskFront(regs.stencil_front_mask)) {- return;- }+ const bool front_changed =+ state_tracker.CheckStencilWriteMaskFront(regs.stencil_front_mask);+ const bool back_changed =+ state_tracker.CheckStencilWriteMaskBack(regs.stencil_front_mask);+ changed = front_changed || back_changed;+ }+ if (!changed) {+ return;}scheduler.Record([front_write_mask = regs.stencil_front_mask,back_write_mask = regs.stencil_back_mask,@@ -1360,15 +1411,22 @@ void RasterizerVulkan::UpdateStencilFaces(Tegra::Engines::Maxwell3D::Regs& regs)}if (update_compare_masks) {[&]() {+ bool changed;if (regs.stencil_two_side_enable) {- if (!state_tracker.CheckStencilCompareMaskFront(regs.stencil_front_func_mask) &&- !state_tracker.CheckStencilCompareMaskBack(regs.stencil_back_func_mask)) {- return;- }+ const bool front_changed =+ state_tracker.CheckStencilCompareMaskFront(regs.stencil_front_func_mask);+ const bool back_changed =+ state_tracker.CheckStencilCompareMaskBack(regs.stencil_back_func_mask);+ changed = front_changed || back_changed;} else {- if (!state_tracker.CheckStencilCompareMaskFront(regs.stencil_front_func_mask)) {- return;- }+ const bool front_changed =+ state_tracker.CheckStencilCompareMaskFront(regs.stencil_front_func_mask);+ const bool back_changed =+ state_tracker.CheckStencilCompareMaskBack(regs.stencil_front_func_mask);+ changed = front_changed || back_changed;+ }+ if (!changed) {+ return;}scheduler.Record([front_test_mask = regs.stencil_front_func_mask,back_test_mask = regs.stencil_back_func_mask,diff --git a/src/video_core/renderer_vulkan/vk_render_pass_cache.cpp b/src/video_core/renderer_vulkan/vk_render_pass_cache.cppindex 118b2a0832..66bade9a2e 100644--- a/src/video_core/renderer_vulkan/vk_render_pass_cache.cpp+++ b/src/video_core/renderer_vulkan/vk_render_pass_cache.cpp@@ -44,7 +44,9 @@ using VideoCore::Surface::SurfaceType;}VkAttachmentDescription AttachmentDescription(const Device& device, PixelFormat format,- VkSampleCountFlagBits samples) {+ VkSampleCountFlagBits samples,+ VkAttachmentLoadOp load_op,+ VkAttachmentStoreOp store_op) {using MaxwellToVK::SurfaceFormat;const SurfaceType surface_type = GetSurfaceType(format);@@ -55,12 +57,10 @@ using VideoCore::Surface::SurfaceType;.flags = {},.format = SurfaceFormat(device, FormatType::Optimal, true, format).format,.samples = samples,- .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,- .storeOp = VK_ATTACHMENT_STORE_OP_STORE,- .stencilLoadOp = has_stencil ? VK_ATTACHMENT_LOAD_OP_LOAD- : VK_ATTACHMENT_LOAD_OP_DONT_CARE,- .stencilStoreOp = has_stencil ? VK_ATTACHMENT_STORE_OP_STORE- : VK_ATTACHMENT_STORE_OP_DONT_CARE,+ .loadOp = load_op,+ .storeOp = store_op,+ .stencilLoadOp = has_stencil ? load_op : VK_ATTACHMENT_LOAD_OP_DONT_CARE,+ .stencilStoreOp = has_stencil ? store_op : VK_ATTACHMENT_STORE_OP_DONT_CARE,.initialLayout = VK_IMAGE_LAYOUT_GENERAL,.finalLayout = VK_IMAGE_LAYOUT_GENERAL,};@@ -87,7 +87,14 @@ VkRenderPass RenderPassCache::Get(const RenderPassKey& key) {.layout = VK_IMAGE_LAYOUT_GENERAL,};if (is_valid) {- descriptions.push_back(AttachmentDescription(*device, format, key.samples));+ const VkAttachmentLoadOp load_op = (key.color_clear_mask & (1u << index)) != 0+ ? VK_ATTACHMENT_LOAD_OP_CLEAR+ : VK_ATTACHMENT_LOAD_OP_LOAD;+ const VkAttachmentStoreOp store_op = (key.color_discard_mask & (1u << index)) != 0+ ? VK_ATTACHMENT_STORE_OP_DONT_CARE+ : VK_ATTACHMENT_STORE_OP_STORE;+ descriptions.push_back(+ AttachmentDescription(*device, format, key.samples, load_op, store_op));num_attachments = static_cast<u32>(index + 1);++num_colors;}@@ -99,7 +106,32 @@ VkRenderPass RenderPassCache::Get(const RenderPassKey& key) {.attachment = num_colors,.layout = VK_IMAGE_LAYOUT_GENERAL,};- descriptions.push_back(AttachmentDescription(*device, key.depth_format, key.samples));+ const VkAttachmentLoadOp depth_load_op = key.depth_stencil_clear+ ? VK_ATTACHMENT_LOAD_OP_CLEAR+ : VK_ATTACHMENT_LOAD_OP_LOAD;+ descriptions.push_back(AttachmentDescription(*device, key.depth_format, key.samples,+ depth_load_op, VK_ATTACHMENT_STORE_OP_STORE));+ }+ std::array<VkAttachmentReference, 8> resolve_references{};+ const bool do_resolve_color =+ key.resolve_color && key.samples != VK_SAMPLE_COUNT_1_BIT && num_colors > 0;+ if (do_resolve_color) {+ for (size_t index = 0; index < key.color_formats.size(); ++index) {+ const PixelFormat format{key.color_formats[index]};+ const bool is_valid{format != PixelFormat::Invalid};+ resolve_references[index] = VkAttachmentReference{+ .attachment = is_valid ? static_cast<u32>(descriptions.size()) : VK_ATTACHMENT_UNUSED,+ .layout = VK_IMAGE_LAYOUT_GENERAL,+ };+ if (is_valid) {+ VkAttachmentDescription resolve_desc =+ AttachmentDescription(*device, format, VK_SAMPLE_COUNT_1_BIT,+ VK_ATTACHMENT_LOAD_OP_DONT_CARE,+ VK_ATTACHMENT_STORE_OP_STORE);+ resolve_desc.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;+ descriptions.push_back(resolve_desc);+ }+ }}const VkSubpassDescription subpass{.flags = 0,@@ -108,7 +140,7 @@ VkRenderPass RenderPassCache::Get(const RenderPassKey& key) {.pInputAttachments = nullptr,.colorAttachmentCount = num_attachments,.pColorAttachments = references.data(),- .pResolveAttachments = nullptr,+ .pResolveAttachments = do_resolve_color ? resolve_references.data() : nullptr,.pDepthStencilAttachment = has_depth ? &depth_reference : nullptr,.preserveAttachmentCount = 0,.pPreserveAttachments = nullptr,diff --git a/src/video_core/renderer_vulkan/vk_render_pass_cache.h b/src/video_core/renderer_vulkan/vk_render_pass_cache.hindex 5c7b3c2aed..75999a655e 100644--- a/src/video_core/renderer_vulkan/vk_render_pass_cache.h+++ b/src/video_core/renderer_vulkan/vk_render_pass_cache.h@@ -20,6 +20,10 @@ struct RenderPassKey {std::array<VideoCore::Surface::PixelFormat, 8> color_formats;VideoCore::Surface::PixelFormat depth_format;VkSampleCountFlagBits samples;+ bool resolve_color;+ u32 color_clear_mask;+ bool depth_stencil_clear;+ u32 color_discard_mask;};} // namespace Vulkan@@ -30,6 +34,10 @@ struct hash<Vulkan::RenderPassKey> {[[nodiscard]] size_t operator()(const Vulkan::RenderPassKey& key) const noexcept {size_t value = static_cast<size_t>(key.depth_format) << 48;value ^= static_cast<size_t>(key.samples) << 52;+ value ^= static_cast<size_t>(key.resolve_color) << 63;+ value ^= static_cast<size_t>(key.color_clear_mask) << 54;+ value ^= static_cast<size_t>(key.depth_stencil_clear) << 62;+ value ^= static_cast<size_t>(key.color_discard_mask) << 24;for (size_t i = 0; i < key.color_formats.size(); ++i) {value ^= static_cast<size_t>(key.color_formats[i]) << (i * 6);}diff --git a/src/video_core/renderer_vulkan/vk_scheduler.cpp b/src/video_core/renderer_vulkan/vk_scheduler.cppindex 334d82efff..6234b41978 100644--- a/src/video_core/renderer_vulkan/vk_scheduler.cpp+++ b/src/video_core/renderer_vulkan/vk_scheduler.cpp@@ -93,30 +93,27 @@ void Scheduler::DispatchWork() {}}-void Scheduler::RequestRenderpass(const Framebuffer* framebuffer) {- const VkRenderPass renderpass = framebuffer->RenderPass();+void Scheduler::BeginRenderPassImpl(const Framebuffer* framebuffer, VkRenderPass renderpass,+ const VkClearValue* clear_values, u32 clear_value_count) {const VkFramebuffer framebuffer_handle = framebuffer->Handle();const VkExtent2D render_area = framebuffer->RenderArea();- if (renderpass == state.renderpass && framebuffer_handle == state.framebuffer &&- render_area.width == state.render_area.width &&- render_area.height == state.render_area.height) {- return;- }- EndRenderPass();state.renderpass = renderpass;state.framebuffer = framebuffer_handle;state.render_area = render_area;- // Log render pass begin- if (GPU::Logging::IsActive() &&- Settings::values.gpu_log_vulkan_calls.GetValue()) {- const std::string render_pass_info = fmt::format(- "renderArea={}x{}, numImages={}",- render_area.width, render_area.height, framebuffer->NumImages());+ if (GPU::Logging::IsActive() && Settings::values.gpu_log_vulkan_calls.GetValue()) {+ const std::string render_pass_info =+ fmt::format("renderArea={}x{}, numImages={}", render_area.width, render_area.height,+ framebuffer->NumImages());GPU::Logging::GPULogger::GetInstance().LogRenderPassBegin(render_pass_info);}- Record([renderpass, framebuffer_handle, render_area](vk::CommandBuffer cmdbuf) {+ std::array<VkClearValue, 9> values{};+ for (u32 i = 0; i < clear_value_count && i < values.size(); ++i) {+ values[i] = clear_values[i];+ }+ Record([renderpass, framebuffer_handle, render_area, values, clear_value_count](+ vk::CommandBuffer cmdbuf) {const VkRenderPassBeginInfo renderpass_bi{.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,.pNext = nullptr,@@ -127,8 +124,8 @@ void Scheduler::RequestRenderpass(const Framebuffer* framebuffer) {.offset = {.x = 0, .y = 0},.extent = render_area,},- .clearValueCount = 0,- .pClearValues = nullptr,+ .clearValueCount = clear_value_count,+ .pClearValues = clear_value_count != 0 ? values.data() : nullptr,};cmdbuf.BeginRenderPass(renderpass_bi, VK_SUBPASS_CONTENTS_INLINE);});@@ -137,6 +134,80 @@ void Scheduler::RequestRenderpass(const Framebuffer* framebuffer) {renderpass_image_ranges = framebuffer->ImageRanges();}+void Scheduler::RealizeDeferredClear() {+ if (deferred_clear.framebuffer == nullptr) {+ return;+ }+ const DeferredClear dc = deferred_clear;+ deferred_clear = {};++ std::array<VkClearValue, 9> clear_values{};+ u32 count = 0;+ const RenderPassKey& base = dc.framebuffer->RenderPassKeyBase();+ for (u32 slot = 0; slot < 8; ++slot) {+ if (base.color_formats[slot] == VideoCore::Surface::PixelFormat::Invalid) {+ continue;+ }+ clear_values[count++] = dc.color_values[slot];+ }+ if (base.depth_format != VideoCore::Surface::PixelFormat::Invalid) {+ clear_values[count++] = dc.depth_stencil_value;+ }+ const u32 color_discard_mask =+ dc.framebuffer->DiscardsMsaaColor() ? dc.color_clear_mask : 0u;+ const VkRenderPass renderpass = dc.framebuffer->RenderPassVariant(+ dc.color_clear_mask, dc.depth_stencil, color_discard_mask);+ EndRenderPass();+ BeginRenderPassImpl(dc.framebuffer, renderpass, clear_values.data(), count);+}++bool Scheduler::DeferColorClear(const Framebuffer* framebuffer, u32 rt_slot,+ const VkClearValue& value) {+ if (IsRenderPassActive()) {+ return false;+ }+ if (deferred_clear.framebuffer != nullptr && deferred_clear.framebuffer != framebuffer) {+ RealizeDeferredClear();+ EndRenderPass();+ }+ deferred_clear.framebuffer = framebuffer;+ deferred_clear.color_clear_mask |= 1u << rt_slot;+ deferred_clear.color_values[rt_slot] = value;+ return true;+}++bool Scheduler::DeferDepthStencilClear(const Framebuffer* framebuffer, const VkClearValue& value) {+ if (IsRenderPassActive()) {+ return false;+ }+ if (deferred_clear.framebuffer != nullptr && deferred_clear.framebuffer != framebuffer) {+ RealizeDeferredClear();+ EndRenderPass();+ }+ deferred_clear.framebuffer = framebuffer;+ deferred_clear.depth_stencil = true;+ deferred_clear.depth_stencil_value = value;+ return true;+}++void Scheduler::RequestRenderpass(const Framebuffer* framebuffer) {+ if (deferred_clear.framebuffer == framebuffer) {+ RealizeDeferredClear();+ return;+ }+ const VkRenderPass renderpass = framebuffer->RenderPass();+ const VkFramebuffer framebuffer_handle = framebuffer->Handle();+ const VkExtent2D render_area = framebuffer->RenderArea();+ if (renderpass == state.renderpass && framebuffer_handle == state.framebuffer &&+ render_area.width == state.render_area.width &&+ render_area.height == state.render_area.height) {+ return;+ }+ // Ends any active pass and realizes a deferred clear+ EndRenderPass();+ BeginRenderPassImpl(framebuffer, renderpass, nullptr, 0);+}+void Scheduler::RequestOutsideRenderPassOperationContext() {EndRenderPass();}@@ -308,6 +379,7 @@ void Scheduler::EndPendingOperations() {void Scheduler::EndRenderPass(){+ RealizeDeferredClear();if (!state.renderpass) {return;}diff --git a/src/video_core/renderer_vulkan/vk_scheduler.h b/src/video_core/renderer_vulkan/vk_scheduler.hindex 0709c3a370..5c4af8c146 100644--- a/src/video_core/renderer_vulkan/vk_scheduler.h+++ b/src/video_core/renderer_vulkan/vk_scheduler.h@@ -59,6 +59,12 @@ public:/// Requests to begin a renderpass.void RequestRenderpass(const Framebuffer* framebuffer);+ /// Defers a full-attachment color clear so it becomes the next render pass.+ bool DeferColorClear(const Framebuffer* framebuffer, u32 rt_slot, const VkClearValue& value);++ /// Defers a full depth/stencil clear so it becomes the next render pass.+ bool DeferDepthStencilClear(const Framebuffer* framebuffer, const VkClearValue& value);+/// Requests the current execution context to be able to execute operations only allowed outside/// of a renderpass.void RequestOutsideRenderPassOperationContext();@@ -251,6 +257,21 @@ private:bool needs_state_enable_refresh = false;};+ struct DeferredClear {+ const Framebuffer* framebuffer = nullptr;+ u32 color_clear_mask = 0;+ std::array<VkClearValue, 8> color_values{};+ bool depth_stencil = false;+ VkClearValue depth_stencil_value{};+ };++ /// Begins a render pass for the given framebuffer, optionally with clear values.+ void BeginRenderPassImpl(const Framebuffer* framebuffer, VkRenderPass renderpass,+ const VkClearValue* clear_values, u32 clear_value_count);++ /// If a deferred clear is pending.+ void RealizeDeferredClear();+void WorkerThread(std::stop_token stop_token);void AllocateWorkerCommandBuffer();@@ -276,6 +297,8 @@ private:vk::CommandBuffer current_cmdbuf;vk::CommandBuffer current_upload_cmdbuf;+ DeferredClear deferred_clear;+std::unique_ptr<CommandChunk> chunk;std::function<void()> on_submit;diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cppindex 960dafb99d..44a4227a19 100644--- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp+++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp@@ -52,6 +52,9 @@ using VideoCore::Surface::IsPixelFormatInteger;using VideoCore::Surface::SurfaceType;namespace {+constexpr bool ENABLE_MSAA_RESOLVE_CONSUME = true;+constexpr bool ENABLE_MSAA_COLOR_DISCARD = true;+constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {if (color == std::array<float, 4>{0, 0, 0, 0}) {return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;@@ -909,9 +912,6 @@ TextureCacheRuntime::TextureCacheRuntime(const Device& device_, Scheduler& schedastc_decoder_pass.emplace(device, scheduler, descriptor_pool, staging_buffer_pool,compute_pass_descriptor_queue, memory_allocator);}- if (device.IsStorageImageMultisampleSupported()) {- msaa_copy_pass.emplace(device, scheduler, descriptor_pool, staging_buffer_pool, compute_pass_descriptor_queue);- }if (!device.IsKhrImageFormatListSupported()) {return;}@@ -995,12 +995,84 @@ VkBuffer TextureCacheRuntime::GetTemporaryBuffer(size_t needed_size) {return *buffers[level];}+VkImageView TextureCacheRuntime::GetOrCreateResolveShadow(VkImage msaa_image, VkFormat format,+ VkExtent2D extent, u32 layers) {+ ResolveShadow& shadow = resolve_shadows[msaa_image];+ if (shadow.image && shadow.format == format && shadow.extent.width == extent.width &&+ shadow.extent.height == extent.height && shadow.layers == layers) {+ shadow.up_to_date = true;+ return *shadow.view;+ }+ shadow.image = memory_allocator.CreateImage(VkImageCreateInfo{+ .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,+ .pNext = nullptr,+ .flags = 0,+ .imageType = VK_IMAGE_TYPE_2D,+ .format = format,+ .extent = {extent.width, extent.height, 1},+ .mipLevels = 1,+ .arrayLayers = layers,+ .samples = VK_SAMPLE_COUNT_1_BIT,+ .tiling = VK_IMAGE_TILING_OPTIMAL,+ .usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT,+ .sharingMode = VK_SHARING_MODE_EXCLUSIVE,+ .queueFamilyIndexCount = 0,+ .pQueueFamilyIndices = nullptr,+ .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,+ });+ shadow.view = device.GetLogical().CreateImageView(VkImageViewCreateInfo{+ .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,+ .pNext = nullptr,+ .flags = 0,+ .image = *shadow.image,+ .viewType = layers > 1 ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D,+ .format = format,+ .components{},+ .subresourceRange{+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,+ .baseMipLevel = 0,+ .levelCount = 1,+ .baseArrayLayer = 0,+ .layerCount = layers,+ },+ });+ shadow.format = format;+ shadow.extent = extent;+ shadow.layers = layers;+ shadow.up_to_date = true;+ return *shadow.view;+}++const TextureCacheRuntime::ResolveShadow* TextureCacheRuntime::GetValidResolveShadow(+ VkImage msaa_image) const {+ const auto it = resolve_shadows.find(msaa_image);+ if (it == resolve_shadows.end() || !it->second.up_to_date || !it->second.image) {+ return nullptr;+ }+ return &it->second;+}++void TextureCacheRuntime::InvalidateResolveShadow(VkImage msaa_image) {+ const auto it = resolve_shadows.find(msaa_image);+ if (it != resolve_shadows.end()) {+ it->second.up_to_date = false;+ }+}++void TextureCacheRuntime::EraseResolveShadow(VkImage msaa_image) {+ resolve_shadows.erase(msaa_image);+}+void TextureCacheRuntime::BarrierFeedbackLoop() {scheduler.RequestOutsideRenderPassOperationContext();}void TextureCacheRuntime::ReinterpretImage(Image& dst, Image& src,std::span<const VideoCommon::ImageCopy> copies) {+ if (ENABLE_MSAA_RESOLVE_CONSUME) {+ InvalidateResolveShadow(dst.Handle());+ }boost::container::small_vector<VkBufferImageCopy, 16> vk_in_copies(copies.size());boost::container::small_vector<VkBufferImageCopy, 16> vk_out_copies(copies.size());const VkImageAspectFlags src_aspect_mask = src.AspectMask();@@ -1147,6 +1219,15 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dstreturn;}ASSERT(src.format == dst.format);+ if (is_src_msaa && !is_dst_msaa &&+ (aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != 0) {+ if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) == 0) {+ UNIMPLEMENTED_MSG("Stencil-only MSAA resolve is not supported");+ return;+ }+ blit_image_helper.ResolveDepthStencil(dst_framebuffer, src, dst_region, src_region);+ return;+ }if (aspect_mask == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {const auto format = src.format;const auto can_blit_depth_stencil = [this, format] {@@ -1172,19 +1253,20 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dstASSERT(!(is_dst_msaa && !is_src_msaa));ASSERT(operation == Fermi2D::Operation::SrcCopy);- const VkImage dst_image = dst.ImageHandle();- const VkImage src_image = src.ImageHandle();- const VkImageSubresourceLayers dst_layers = MakeSubresourceLayers(&dst);- const VkImageSubresourceLayers src_layers = MakeSubresourceLayers(&src);const bool is_msaa_to_msaa = is_src_msaa && is_dst_msaa;-- // NVIDIA 510+ and Intel crash on MSAA->MSAA blits (scaling operations)- // Fall back to 3D helpers for MSAA scaling+ if (is_msaa_to_msaa && aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT) {+ blit_image_helper.BlitColorMSAA(dst_framebuffer, src, dst_region, src_region);+ return;+ }if (is_msaa_to_msaa && device.CantBlitMSAA()) {- // This should be handled by NeedsScaleHelper() and use 3D helpers instead- UNIMPLEMENTED_MSG("MSAA to MSAA blit not supported on this driver");+ UNIMPLEMENTED_MSG("MSAA to MSAA depth-stencil blit is not supported on this driver");return;}++ const VkImage dst_image = dst.ImageHandle();+ const VkImage src_image = src.ImageHandle();+ const VkImageSubresourceLayers dst_layers = MakeSubresourceLayers(&dst);+ const VkImageSubresourceLayers src_layers = MakeSubresourceLayers(&src);const bool is_resolve = is_src_msaa && !is_dst_msaa;scheduler.RequestOutsideRenderPassOperationContext();scheduler.Record([filter, dst_region, src_region, dst_image, src_image, dst_layers, src_layers,@@ -1442,6 +1524,9 @@ bool TextureCacheRuntime::IsFormatScalable(PixelFormat format) {void TextureCacheRuntime::CopyImage(Image& dst, Image& src,std::span<const VideoCommon::ImageCopy> copies) {+ if (ENABLE_MSAA_RESOLVE_CONSUME) {+ InvalidateResolveShadow(dst.Handle());+ }// As per the size-compatible formats section of vulkan, copy manually via ReinterpretImage// these images that aren't size-compatibleif (BytesPerBlock(src.info.format) != BytesPerBlock(dst.info.format)) {@@ -1555,10 +1640,117 @@ void TextureCacheRuntime::CopyImage(Image& dst, Image& src,void TextureCacheRuntime::CopyImageMSAA(Image& dst, Image& src,std::span<const VideoCommon::ImageCopy> copies) {const bool msaa_to_non_msaa = src.info.num_samples > 1 && dst.info.num_samples == 1;- if (msaa_copy_pass) {- return msaa_copy_pass->CopyImage(dst, src, copies, msaa_to_non_msaa);+ const u32 num_samples = msaa_to_non_msaa ? src.info.num_samples : dst.info.num_samples;+ if (dst.AspectMask() != VK_IMAGE_ASPECT_COLOR_BIT ||+ VideoCore::Surface::IsPixelFormatInteger(dst.info.format)) {+ UNIMPLEMENTED_MSG("Copying images with different samples is not supported.");+ return;+ }+ if (ENABLE_MSAA_RESOLVE_CONSUME && msaa_to_non_msaa && copies.size() == 1 &&+ src.info.format == dst.info.format) {+ const VideoCommon::ImageCopy& copy = copies.front();+ const ResolveShadow* const shadow = GetValidResolveShadow(src.Handle());+ if (shadow != nullptr && copy.src_offset.x == 0 && copy.src_offset.y == 0 &&+ copy.src_subresource.base_level == 0 &&+ static_cast<u32>(copy.extent.width) <= shadow->extent.width &&+ static_cast<u32>(copy.extent.height) <= shadow->extent.height) {+ const VkImage shadow_image = *shadow->image;+ const VkImage dst_image = dst.Handle();+ const VkImageCopy region{+ .srcSubresource{+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,+ .mipLevel = 0,+ .baseArrayLayer = static_cast<u32>(copy.src_subresource.base_layer),+ .layerCount = static_cast<u32>(copy.src_subresource.num_layers),+ },+ .srcOffset = {0, 0, 0},+ .dstSubresource{+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,+ .mipLevel = static_cast<u32>(copy.dst_subresource.base_level),+ .baseArrayLayer = static_cast<u32>(copy.dst_subresource.base_layer),+ .layerCount = static_cast<u32>(copy.dst_subresource.num_layers),+ },+ .dstOffset = {copy.dst_offset.x, copy.dst_offset.y, copy.dst_offset.z},+ .extent = {copy.extent.width, copy.extent.height, 1},+ };+ scheduler.RequestOutsideRenderPassOperationContext();+ scheduler.Record([shadow_image, dst_image, region](vk::CommandBuffer cmdbuf) {+ const std::array pre_barriers{+ VkImageMemoryBarrier{+ .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,+ .pNext = nullptr,+ .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,+ .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,+ .oldLayout = VK_IMAGE_LAYOUT_GENERAL,+ .newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,+ .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .image = shadow_image,+ .subresourceRange{VK_IMAGE_ASPECT_COLOR_BIT, 0, VK_REMAINING_MIP_LEVELS, 0,+ VK_REMAINING_ARRAY_LAYERS},+ },+ VkImageMemoryBarrier{+ .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,+ .pNext = nullptr,+ .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT |+ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |+ VK_ACCESS_TRANSFER_WRITE_BIT,+ .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,+ .oldLayout = VK_IMAGE_LAYOUT_GENERAL,+ .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,+ .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .image = dst_image,+ .subresourceRange{VK_IMAGE_ASPECT_COLOR_BIT, 0, VK_REMAINING_MIP_LEVELS, 0,+ VK_REMAINING_ARRAY_LAYERS},+ },+ };+ const std::array post_barriers{+ VkImageMemoryBarrier{+ .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,+ .pNext = nullptr,+ .srcAccessMask = 0,+ .dstAccessMask = 0,+ .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,+ .newLayout = VK_IMAGE_LAYOUT_GENERAL,+ .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .image = shadow_image,+ .subresourceRange{VK_IMAGE_ASPECT_COLOR_BIT, 0, VK_REMAINING_MIP_LEVELS, 0,+ VK_REMAINING_ARRAY_LAYERS},+ },+ VkImageMemoryBarrier{+ .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,+ .pNext = nullptr,+ .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,+ .dstAccessMask = VK_ACCESS_SHADER_READ_BIT |+ VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |+ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |+ VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,+ .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,+ .newLayout = VK_IMAGE_LAYOUT_GENERAL,+ .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .image = dst_image,+ .subresourceRange{VK_IMAGE_ASPECT_COLOR_BIT, 0, VK_REMAINING_MIP_LEVELS, 0,+ VK_REMAINING_ARRAY_LAYERS},+ },+ };+ cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |+ VK_PIPELINE_STAGE_TRANSFER_BIT,+ VK_PIPELINE_STAGE_TRANSFER_BIT, 0, nullptr, nullptr,+ pre_barriers);+ cmdbuf.CopyImage(shadow_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_image,+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, region);+ cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,+ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, nullptr, nullptr,+ post_barriers);+ });+ return;+ }}- UNIMPLEMENTED_MSG("Copying images with different samples is not supported.");+ blit_image_helper.CopyMSAA(render_pass_cache, dst.Handle(), dst.info.format, src.Handle(),+ src.info.format, num_samples, copies, msaa_to_non_msaa);}u64 TextureCacheRuntime::GetDeviceLocalMemory() const {@@ -1577,7 +1769,11 @@ std::optional<size_t> TextureCacheRuntime::GetSamplerHeapBudget() const {return device.GetSamplerHeapBudget();}-void TextureCacheRuntime::TickFrame() {}+void TextureCacheRuntime::TickFrame() {+ std::erase_if(pending_msaa_images, [this](const auto& pending) {+ return scheduler.IsFree(pending.first);+ });+}Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu_addr_,VAddr cpu_addr_)@@ -1632,7 +1828,16 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpuImage::Image(const VideoCommon::NullImageParams& params) : VideoCommon::ImageBase{params} {}-Image::~Image() = default;+Image::~Image() {+ if (ENABLE_MSAA_RESOLVE_CONSUME && runtime != nullptr) {+ if (original_image) {+ runtime->EraseResolveShadow(*original_image);+ }+ if (scaled_image) {+ runtime->EraseResolveShadow(*scaled_image);+ }+ }+}void Image::AllocateComputeUnswizzleBuffer(u32 max_slices) {using VideoCore::Surface::BytesPerBlock;@@ -1679,82 +1884,75 @@ void Image::AllocateComputeUnswizzleBuffer(u32 max_slices) {void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset,std::span<const VideoCommon::BufferImageCopy> copies) {// TODO: Move this to another API+ if (ENABLE_MSAA_RESOLVE_CONSUME && runtime != nullptr) {+ runtime->InvalidateResolveShadow(Handle());+ }const bool is_rescaled = True(flags & ImageFlagBits::Rescaled);if (is_rescaled) {ScaleDown(true);}- // Handle MSAA upload if necessary- /* WARNING, TODO: This code uses some hacks, besides being fundamentally ugly- since tropic didn't want to touch it for a long time, so it needs a rewrite from someone- better than me at vulkan. */- // CHANGE: Gate the MSAA path more strictly and only use it for color, when the pass and device- // support are available. Avoid running the MSAA path when prerequisites aren't met,- // preventing validation and runtime issues.const bool wants_msaa_upload = info.num_samples > 1&& (aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != 0- && runtime->CanUploadMSAA() && runtime->msaa_copy_pass.has_value()- && runtime->device.IsStorageImageMultisampleSupported();+ && !VideoCore::Surface::IsPixelFormatInteger(info.format);if (wants_msaa_upload) {- // Create a temporary non-MSAA image to upload the data firstImageInfo temp_info = info;temp_info.num_samples = 1;- // CHANGE: Build a fresh VkImageCreateInfo with robust usage flags for the temp image.- // Using the target image's usage as-is could miss STORAGE/TRANSFER bits and trigger- // validation errors.VkImageCreateInfo image_ci = MakeImageCreateInfo(runtime->device, temp_info);- image_ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |- VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT;-- // CHANGE: The previous stack-allocated wrapper was destroyed at function exit,- // which could destroy VkImage before the GPU used it.- auto temp_wrapper = std::make_shared<Image>(*runtime, temp_info, 0, 0);- temp_wrapper->original_image = runtime->memory_allocator.CreateImage(image_ci);- temp_wrapper->current_image = &Image::original_image;- temp_wrapper->aspect_mask = aspect_mask;- temp_wrapper->initialized = true;-- // Upload to the temporary non-MSAA image+ image_ci.format =+ MaxwellToVK::SurfaceFormat(runtime->device, FormatType::Optimal, true, info.format)+ .format;+ image_ci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;+ vk::Image temp_image = runtime->memory_allocator.CreateImage(image_ci);+scheduler->RequestOutsideRenderPassOperationContext();- auto vk_copies = TransformBufferImageCopies(copies, offset, temp_wrapper->aspect_mask);+ auto vk_copies = TransformBufferImageCopies(copies, offset, aspect_mask);const VkBuffer src_buffer = buffer;- const VkImage temp_vk_image = *temp_wrapper->original_image;- const VkImageAspectFlags vk_aspect_mask = temp_wrapper->aspect_mask;+ const VkImage temp_vk_image = *temp_image;+ const VkImageAspectFlags vk_aspect_mask = aspect_mask;- scheduler->Record([src_buffer, temp_vk_image, vk_aspect_mask, vk_copies,- keep = temp_wrapper](vk::CommandBuffer cmdbuf) {+ scheduler->Record([src_buffer, temp_vk_image, vk_aspect_mask,+ vk_copies](vk::CommandBuffer cmdbuf) {CopyBufferToImage(cmdbuf, src_buffer, temp_vk_image, vk_aspect_mask, false, VideoCommon::FixSmallVectorADL(vk_copies));});- // Use MSAACopyPass to convert from non-MSAA to MSAA+ const auto [samples_x, samples_y] = VideoCommon::SamplesLog2(info.num_samples);std::vector<VideoCommon::ImageCopy> image_copies;image_copies.reserve(copies.size());for (const auto& copy : copies) {VideoCommon::ImageCopy image_copy{};- image_copy.src_offset = {0, 0, 0}; // Use zero offset for source- image_copy.dst_offset = copy.image_offset;+ image_copy.src_offset = {0, 0, 0};+ image_copy.dst_offset = {copy.image_offset.x >> samples_x,+ copy.image_offset.y >> samples_y, copy.image_offset.z};image_copy.src_subresource = copy.image_subresource;image_copy.dst_subresource = copy.image_subresource;- image_copy.extent = copy.image_extent;+ image_copy.extent = {copy.image_extent.width >> samples_x,+ copy.image_extent.height >> samples_y, copy.image_extent.depth};image_copies.push_back(image_copy);}- runtime->msaa_copy_pass->CopyImage(*this, *temp_wrapper, image_copies,- /*msaa_to_non_msaa=*/false);- std::exchange(initialized, true);+ runtime->blit_image_helper.CopyMSAA(runtime->render_pass_cache, Handle(), info.format,+ temp_vk_image, info.format, info.num_samples,+ image_copies, false);+ initialized = true;+ runtime->pending_msaa_images.emplace_back(scheduler->CurrentTick(), std::move(temp_image));- const u64 tick = scheduler->Flush();- scheduler->Wait(tick);+ if (is_rescaled) {+ ScaleUp();+ }+ return;+ }+ if (info.num_samples > 1) {+ LOG_WARNING(Render_Vulkan, "MSAA upload not implemented for format {}", info.format);if (is_rescaled) {ScaleUp();}return;}- // Regular non-MSAA upload (original behavior preserved)scheduler->RequestOutsideRenderPassOperationContext();auto vk_copies = TransformBufferImageCopies(copies, offset, aspect_mask);const VkBuffer src_buffer = buffer;@@ -1794,22 +1992,45 @@ void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> oScaleDown();}- // RE-USE MSAA UPLOAD CODE BUT NOW FOR DOWNLOAD- if (info.num_samples > 1 && runtime->msaa_copy_pass) {- // TODO: Depth/stencil formats need special handling- if (aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT) {+ if (info.num_samples > 1) {+ if (aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT &&+ !VideoCore::Surface::IsPixelFormatInteger(info.format)) {ImageInfo temp_info = info;temp_info.num_samples = 1;VkImageCreateInfo image_ci = MakeImageCreateInfo(runtime->device, temp_info);- image_ci.usage = original_image.UsageFlags();+ image_ci.format =+ MaxwellToVK::SurfaceFormat(runtime->device, FormatType::Optimal, true, info.format)+ .format;+ image_ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;vk::Image temp_image = runtime->memory_allocator.CreateImage(image_ci);+ const VkImage temp_vk_image = *temp_image;- Image temp_wrapper(*runtime, temp_info, 0, 0);- temp_wrapper.original_image = std::move(temp_image);- temp_wrapper.current_image = &Image::original_image;- temp_wrapper.aspect_mask = aspect_mask;- temp_wrapper.initialized = true;+ scheduler->RequestOutsideRenderPassOperationContext();+ scheduler->Record([temp_vk_image](vk::CommandBuffer cmdbuf) {+ const VkImageMemoryBarrier init_barrier{+ .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,+ .pNext = nullptr,+ .srcAccessMask = 0,+ .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |+ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,+ .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,+ .newLayout = VK_IMAGE_LAYOUT_GENERAL,+ .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,+ .image = temp_vk_image,+ .subresourceRange{+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,+ .baseMipLevel = 0,+ .levelCount = VK_REMAINING_MIP_LEVELS,+ .baseArrayLayer = 0,+ .layerCount = VK_REMAINING_ARRAY_LAYERS,+ },+ };+ cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,+ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0,+ init_barrier);+ });std::vector<VideoCommon::ImageCopy> image_copies;for (const auto& copy : copies) {@@ -1822,7 +2043,9 @@ void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> oimage_copies.push_back(image_copy);}- runtime->msaa_copy_pass->CopyImage(temp_wrapper, *this, image_copies, true);+ runtime->blit_image_helper.CopyMSAA(runtime->render_pass_cache, temp_vk_image,+ info.format, Handle(), info.format,+ info.num_samples, image_copies, true);boost::container::small_vector<VkBuffer, 8> buffers_vector{};boost::container::small_vector<boost::container::small_vector<VkBufferImageCopy, 16>, 8>@@ -1834,7 +2057,7 @@ void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> o}scheduler->RequestOutsideRenderPassOperationContext();- scheduler->Record([buffers = std::move(buffers_vector), image = *temp_wrapper.original_image,+ scheduler->Record([buffers = std::move(buffers_vector), image = temp_vk_image,aspect_mask_ = aspect_mask, vk_copies](vk::CommandBuffer cmdbuf) {const VkImageMemoryBarrier read_barrier{.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,@@ -1889,6 +2112,8 @@ void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> ocmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,0, memory_write_barrier, nullptr, image_write_barrier);});+ runtime->pending_msaa_images.emplace_back(scheduler->CurrentTick(),+ std::move(temp_image));return;}} else {@@ -2074,10 +2299,11 @@ bool Image::BlitScaleHelper(bool scale_up) {blit_view = std::make_unique<ImageView>(*runtime, view_info, NULL_IMAGE_ID, *this);}- const u32 src_width = scale_up ? info.size.width : scaled_width;- const u32 src_height = scale_up ? info.size.height : scaled_height;- const u32 dst_width = scale_up ? scaled_width : info.size.width;- const u32 dst_height = scale_up ? scaled_height : info.size.height;+ const auto [samples_x, samples_y] = VideoCommon::SamplesLog2(info.num_samples);+ const u32 src_width = (scale_up ? info.size.width : scaled_width) >> samples_x;+ const u32 src_height = (scale_up ? info.size.height : scaled_height) >> samples_y;+ const u32 dst_width = (scale_up ? scaled_width : info.size.width) >> samples_x;+ const u32 dst_height = (scale_up ? scaled_height : info.size.height) >> samples_y;const Region2D src_region{.start = {0, 0},.end = {s32(src_width), s32(src_height)},@@ -2087,17 +2313,23 @@ bool Image::BlitScaleHelper(bool scale_up) {.end = {s32(dst_width), s32(dst_height)},};const VkExtent2D extent{- .width = (std::max)(scaled_width, info.size.width),- .height = (std::max)(scaled_height, info.size.height),+ .width = (std::max)(scaled_width, info.size.width) >> samples_x,+ .height = (std::max)(scaled_height, info.size.height) >> samples_y,};auto* view_ptr = blit_view.get();if (aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT) {if (!blit_framebuffer)blit_framebuffer.emplace(*runtime, view_ptr, nullptr, extent, scale_up);- runtime->blit_image_helper.BlitColor(&*blit_framebuffer, *blit_view,- dst_region, src_region, operation, BLIT_OPERATION);- } else if (aspect_mask == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {+ if (info.num_samples > 1) {+ runtime->blit_image_helper.BlitColorMSAA(&*blit_framebuffer, *blit_view,+ dst_region, src_region);+ } else {+ runtime->blit_image_helper.BlitColor(&*blit_framebuffer, *blit_view,+ dst_region, src_region, operation, BLIT_OPERATION);+ }+ } else if (aspect_mask == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) &&+ info.num_samples == 1) {if (!blit_framebuffer)blit_framebuffer.emplace(*runtime, nullptr, view_ptr, extent, scale_up);runtime->blit_image_helper.BlitDepthStencil(&*blit_framebuffer, *blit_view,@@ -2113,7 +2345,8 @@ bool Image::BlitScaleHelper(bool scale_up) {bool Image::NeedsScaleHelper() const {const auto& device = runtime->device;- const bool needs_msaa_helper = info.num_samples > 1 && device.CantBlitMSAA();+ const bool needs_msaa_helper = info.num_samples > 1 &&+ (device.CantBlitMSAA() || aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT);if (needs_msaa_helper) {return true;}@@ -2515,11 +2748,76 @@ void Framebuffer::CreateFramebuffer(TextureCacheRuntime& runtime,renderpass_key.depth_format = PixelFormat::Invalid;}renderpass_key.samples = samples;+ const bool do_resolve_color =+ samples != VK_SAMPLE_COUNT_1_BIT && num_colors > 0 && runtime.device.IsTiler();+ renderpass_key.resolve_color = do_resolve_color;++ discard_msaa_color =+ ENABLE_MSAA_RESOLVE_CONSUME && ENABLE_MSAA_COLOR_DISCARD && do_resolve_color;renderpass = runtime.render_pass_cache.Get(renderpass_key);+ render_pass_key = renderpass_key;+ render_pass_cache = &runtime.render_pass_cache;render_area.width = (std::min)(render_area.width, width);render_area.height = (std::min)(render_area.height, height);+ if (do_resolve_color) {+ const u32 layers = static_cast<u32>((std::max)(num_layers, 1));+ for (size_t index = 0; index < NUM_RT; ++index) {+ const PixelFormat format = renderpass_key.color_formats[index];+ if (format == PixelFormat::Invalid) {+ continue;+ }+ const VkFormat vk_format =+ MaxwellToVK::SurfaceFormat(runtime.device, FormatType::Optimal, true, format).format;+ if (ENABLE_MSAA_RESOLVE_CONSUME) {+ const VkImage msaa_image = images[rt_map[index]];+ attachments.push_back(runtime.GetOrCreateResolveShadow(msaa_image, vk_format,+ render_area, layers));+ continue;+ }+ VkImageCreateInfo resolve_ci{+ .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,+ .pNext = nullptr,+ .flags = 0,+ .imageType = VK_IMAGE_TYPE_2D,+ .format = vk_format,+ .extent = {render_area.width, render_area.height, 1},+ .mipLevels = 1,+ .arrayLayers = layers,+ .samples = VK_SAMPLE_COUNT_1_BIT,+ .tiling = VK_IMAGE_TILING_OPTIMAL,+ .usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT,+ .sharingMode = VK_SHARING_MODE_EXCLUSIVE,+ .queueFamilyIndexCount = 0,+ .pQueueFamilyIndices = nullptr,+ .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,+ };+ vk::Image resolve_image = runtime.memory_allocator.CreateImage(resolve_ci);+ vk::ImageView resolve_view =+ runtime.device.GetLogical().CreateImageView(VkImageViewCreateInfo{+ .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,+ .pNext = nullptr,+ .flags = 0,+ .image = *resolve_image,+ .viewType = layers > 1 ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D,+ .format = vk_format,+ .components{},+ .subresourceRange{+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,+ .baseMipLevel = 0,+ .levelCount = 1,+ .baseArrayLayer = 0,+ .layerCount = layers,+ },+ });+ attachments.push_back(*resolve_view);+ resolve_images.push_back(std::move(resolve_image));+ resolve_image_views.push_back(std::move(resolve_view));+ }+ }+num_color_buffers = static_cast<u32>(num_colors);framebuffer = runtime.device.GetLogical().CreateFramebuffer({.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,@@ -2534,6 +2832,18 @@ void Framebuffer::CreateFramebuffer(TextureCacheRuntime& runtime,});}+VkRenderPass Framebuffer::RenderPassVariant(u32 color_clear_mask, bool depth_stencil_clear,+ u32 color_discard_mask) const {+ if (color_clear_mask == 0 && !depth_stencil_clear && color_discard_mask == 0) {+ return renderpass;+ }+ RenderPassKey key = render_pass_key;+ key.color_clear_mask = color_clear_mask;+ key.depth_stencil_clear = depth_stencil_clear;+ key.color_discard_mask = color_discard_mask;+ return render_pass_cache->Get(key);+}+void TextureCacheRuntime::AccelerateImageUpload(Image& image, const StagingBufferRef& map,std::span<const VideoCommon::SwizzleParameters> swizzles,diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.h b/src/video_core/renderer_vulkan/vk_texture_cache.hindex 13f51555a3..99f2978cca 100644--- a/src/video_core/renderer_vulkan/vk_texture_cache.h+++ b/src/video_core/renderer_vulkan/vk_texture_cache.h@@ -12,6 +12,7 @@#include "shader_recompiler/shader_info.h"#include "video_core/renderer_vulkan/vk_compute_pass.h"+#include "video_core/renderer_vulkan/vk_render_pass_cache.h"#include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"#include "video_core/texture_cache/image_view_base.h"#include "video_core/vulkan_common/vulkan_memory_allocator.h"@@ -87,7 +88,7 @@ public:}bool CanUploadMSAA() const noexcept {- return msaa_copy_pass.operator bool();+ return true;}void AccelerateImageUpload(Image&, const StagingBufferRef&,@@ -110,6 +111,24 @@ public:[[nodiscard]] VkBuffer GetTemporaryBuffer(size_t needed_size);+ struct ResolveShadow {+ vk::Image image;+ vk::ImageView view;+ VkFormat format = VK_FORMAT_UNDEFINED;+ VkExtent2D extent{};+ u32 layers = 0;+ bool up_to_date = false;+ };++ [[nodiscard]] VkImageView GetOrCreateResolveShadow(VkImage msaa_image, VkFormat format,+ VkExtent2D extent, u32 layers);++ [[nodiscard]] const ResolveShadow* GetValidResolveShadow(VkImage msaa_image) const;++ void InvalidateResolveShadow(VkImage msaa_image);++ void EraseResolveShadow(VkImage msaa_image);+std::span<const VkFormat> ViewFormats(PixelFormat format) {return view_formats[static_cast<std::size_t>(format)];}@@ -130,12 +149,13 @@ public:std::optional<ASTCDecoderPass> astc_decoder_pass;std::optional<BlockLinearUnswizzle3DPass> bl3d_unswizzle_pass;- std::optional<MSAACopyPass> msaa_copy_pass;const Settings::ResolutionScalingInfo& resolution;std::array<std::vector<VkFormat>, VideoCore::Surface::MaxPixelFormat> view_formats;static constexpr size_t indexing_slots = 8 * sizeof(size_t);std::array<vk::Buffer, indexing_slots> buffers{};+ std::vector<std::pair<u64, vk::Image>> pending_msaa_images;+ ankerl::unordered_dense::map<VkImage, ResolveShadow> resolve_shadows;};class Framebuffer {@@ -166,6 +186,13 @@ public:return renderpass;}+ [[nodiscard]] const RenderPassKey& RenderPassKeyBase() const noexcept {+ return render_pass_key;+ }++ [[nodiscard]] VkRenderPass RenderPassVariant(u32 color_clear_mask, bool depth_stencil_clear,+ u32 color_discard_mask) const;+[[nodiscard]] VkExtent2D RenderArea() const noexcept {return render_area;}@@ -206,6 +233,18 @@ public:return is_rescaled;}+ [[nodiscard]] bool HasResolveColor() const noexcept {+ return !resolve_images.empty();+ }++ [[nodiscard]] VkImage ResolveColorImage(size_t index) const noexcept {+ return index < resolve_images.size() ? *resolve_images[index] : VK_NULL_HANDLE;+ }++ [[nodiscard]] bool DiscardsMsaaColor() const noexcept {+ return discard_msaa_color;+ }+private:vk::Framebuffer framebuffer;VkRenderPass renderpass{};@@ -219,6 +258,11 @@ private:bool has_depth{};bool has_stencil{};bool is_rescaled{};+ std::vector<vk::Image> resolve_images;+ std::vector<vk::ImageView> resolve_image_views;+ RenderPassKey render_pass_key{};+ RenderPassCache* render_pass_cache{nullptr};+ bool discard_msaa_color{};};class Image : public VideoCommon::ImageBase {diff --git a/src/video_core/texture_cache/image_info.cpp b/src/video_core/texture_cache/image_info.cppindex ef02972209..8b59eb6841 100644--- a/src/video_core/texture_cache/image_info.cpp+++ b/src/video_core/texture_cache/image_info.cpp@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Projectdiff --git a/src/video_core/vulkan_common/vulkan_device.cpp b/src/video_core/vulkan_common/vulkan_device.cppindex 8bddca0c70..8fd9b6e69f 100644--- a/src/video_core/vulkan_common/vulkan_device.cpp+++ b/src/video_core/vulkan_common/vulkan_device.cpp@@ -504,8 +504,8 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHRCollectToolingInfo();if (is_qualcomm) {- LOG_WARNING(Render_Vulkan, "Qualcomm drivers require scaled vertex format emulation");must_emulate_scaled_formats = true;+ LOG_WARNING(Render_Vulkan, "Qualcomm drivers require scaled vertex format emulation.");LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken custom border color.");RemoveExtensionFeature(extensions.custom_border_color, features.custom_border_color,VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);@@ -523,11 +523,10 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHRfeatures.shader_atomic_int64.shaderBufferInt64Atomics = false;features.shader_atomic_int64.shaderSharedInt64Atomics = false;features.features.shaderInt64 = false;- LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken storage buffer access.");- features.bit8_storage.storageBuffer8BitAccess = false;- features.bit8_storage.uniformAndStorageBuffer8BitAccess = false;- features.bit16_storage.storageBuffer16BitAccess = false;- features.bit16_storage.uniformAndStorageBuffer16BitAccess = false;+ LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken workgroup memory explicit layout.");+ RemoveExtensionFeature(extensions.workgroup_memory_explicit_layout,+ features.workgroup_memory_explicit_layout,+ VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME);#if defined(__ANDROID__) && defined(ARCHITECTURE_arm64)// BCn patching only safe on Android 9+ (API 28+). Older versions crash on driver load.@@ -1356,10 +1355,7 @@ void Device::RemoveUnsuitableExtensions() {// VK_KHR_workgroup_memory_explicit_layoutextensions.workgroup_memory_explicit_layout =- features.features.shaderInt16 &&features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout &&- features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout8BitAccess &&- features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout16BitAccess &&features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayoutScalarBlockLayout;RemoveExtensionFeatureIfUnsuitable(extensions.workgroup_memory_explicit_layout,features.workgroup_memory_explicit_layout,diff --git a/src/video_core/vulkan_common/vulkan_device.h b/src/video_core/vulkan_common/vulkan_device.hindex db92df70a6..c449f60324 100644--- a/src/video_core/vulkan_common/vulkan_device.h+++ b/src/video_core/vulkan_common/vulkan_device.h@@ -305,6 +305,19 @@ public:return properties.driver.driverID;}+ /// Returns true for tile-based deferred renderers.+ bool IsTiler() const {+ switch (GetDriverID()) {+ case VK_DRIVER_ID_QUALCOMM_PROPRIETARY:+ case VK_DRIVER_ID_ARM_PROPRIETARY:+ case VK_DRIVER_ID_SAMSUNG_PROPRIETARY:+ case VK_DRIVER_ID_MESA_TURNIP:+ return true;+ default:+ return false;+ }+ }+bool ShouldBoostClocks() const;/// Returns uniform buffer alignment requirement.@@ -322,6 +335,11 @@ public:return properties.properties.limits.maxStorageBufferRange;}+ std::array<u32, 3> GetMaxComputeWorkGroupCount() const {+ const auto& count = properties.properties.limits.maxComputeWorkGroupCount;+ return {count[0], count[1], count[2]};+ }+/// Returns the maximum size for push constants.VkDeviceSize GetMaxPushConstantsSize() const {return properties.properties.limits.maxPushConstantsSize;@@ -374,6 +392,18 @@ FN_MAX_LIMIT_LISTreturn features.descriptor_indexing.shaderSampledImageArrayNonUniformIndexing;}+ bool IsStorageImageArrayNonUniformIndexingSupported() const {+ return features.descriptor_indexing.shaderStorageImageArrayNonUniformIndexing;+ }++ bool IsUniformTexelBufferArrayNonUniformIndexingSupported() const {+ return features.descriptor_indexing.shaderUniformTexelBufferArrayNonUniformIndexing;+ }++ bool IsStorageTexelBufferArrayNonUniformIndexingSupported() const {+ return features.descriptor_indexing.shaderStorageTexelBufferArrayNonUniformIndexing;+ }+/// Returns true if the device supports float64 natively.bool IsFloat64Supported() const {return features.features.shaderFloat64;@@ -513,6 +543,18 @@ FN_MAX_LIMIT_LISTreturn extensions.workgroup_memory_explicit_layout;}+ bool IsWorkgroupMemoryExplicitLayout8BitAccessSupported() const {+ return extensions.workgroup_memory_explicit_layout &&+ features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout8BitAccess &&+ features.shader_float16_int8.shaderInt8;+ }++ bool IsWorkgroupMemoryExplicitLayout16BitAccessSupported() const {+ return extensions.workgroup_memory_explicit_layout &&+ features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout16BitAccess &&+ features.features.shaderInt16;+ }+/// Returns true if the device supports VK_KHR_image_format_list.bool IsKhrImageFormatListSupported() const {return extensions.image_format_list || instance_version >= VK_API_VERSION_1_2;@@ -765,6 +807,11 @@ FN_MAX_LIMIT_LISTreturn extensions.shader_atomic_int64;}+ bool IsSharedInt64AtomicsSupported() const {+ return extensions.shader_atomic_int64 &&+ features.shader_atomic_int64.shaderSharedInt64Atomics;+ }+bool IsExtConditionalRendering() const {return extensions.conditional_rendering;}