summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/video_core/renderer_opengl/gl_rasterizer.cpp24
-rw-r--r--src/video_core/renderer_opengl/gl_shader_decompiler.cpp52
-rw-r--r--src/video_core/renderer_opengl/gl_shader_decompiler.h33
-rw-r--r--src/video_core/renderer_vulkan/vk_pipeline_cache.cpp4
-rw-r--r--src/video_core/renderer_vulkan/vk_rasterizer.cpp13
-rw-r--r--src/video_core/renderer_vulkan/vk_shader_decompiler.cpp72
-rw-r--r--src/video_core/shader/decode.cpp18
-rw-r--r--src/video_core/shader/decode/image.cpp18
-rw-r--r--src/video_core/shader/decode/texture.cpp192
-rw-r--r--src/video_core/shader/node.h129
-rw-r--r--src/video_core/shader/shader_ir.h34
-rw-r--r--src/video_core/texture_cache/surface_params.cpp10
-rw-r--r--src/video_core/texture_cache/texture_cache.h4
13 files changed, 263 insertions, 340 deletions
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp
index f33c4a8f9..725b4c32d 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp
@@ -59,14 +59,12 @@ constexpr std::size_t NumSupportedVertexAttributes = 16;
59template <typename Engine, typename Entry> 59template <typename Engine, typename Entry>
60Tegra::Texture::FullTextureInfo GetTextureInfo(const Engine& engine, const Entry& entry, 60Tegra::Texture::FullTextureInfo GetTextureInfo(const Engine& engine, const Entry& entry,
61 ShaderType shader_type, std::size_t index = 0) { 61 ShaderType shader_type, std::size_t index = 0) {
62 if (entry.IsBindless()) { 62 if (entry.is_bindless) {
63 const Tegra::Texture::TextureHandle tex_handle = 63 const auto tex_handle = engine.AccessConstBuffer32(shader_type, entry.buffer, entry.offset);
64 engine.AccessConstBuffer32(shader_type, entry.GetBuffer(), entry.GetOffset());
65 return engine.GetTextureInfo(tex_handle); 64 return engine.GetTextureInfo(tex_handle);
66 } 65 }
67 const auto& gpu_profile = engine.AccessGuestDriverProfile(); 66 const auto& gpu_profile = engine.AccessGuestDriverProfile();
68 const u32 offset = 67 const u32 offset = entry.offset + static_cast<u32>(index * gpu_profile.GetTextureHandlerSize());
69 entry.GetOffset() + static_cast<u32>(index * gpu_profile.GetTextureHandlerSize());
70 if constexpr (std::is_same_v<Engine, Tegra::Engines::Maxwell3D>) { 68 if constexpr (std::is_same_v<Engine, Tegra::Engines::Maxwell3D>) {
71 return engine.GetStageTexture(shader_type, offset); 69 return engine.GetStageTexture(shader_type, offset);
72 } else { 70 } else {
@@ -856,9 +854,9 @@ void RasterizerOpenGL::SetupDrawGlobalMemory(std::size_t stage_index, const Shad
856 854
857 u32 binding = device.GetBaseBindings(stage_index).shader_storage_buffer; 855 u32 binding = device.GetBaseBindings(stage_index).shader_storage_buffer;
858 for (const auto& entry : shader->GetEntries().global_memory_entries) { 856 for (const auto& entry : shader->GetEntries().global_memory_entries) {
859 const auto addr{cbufs.const_buffers[entry.GetCbufIndex()].address + entry.GetCbufOffset()}; 857 const GPUVAddr addr{cbufs.const_buffers[entry.cbuf_index].address + entry.cbuf_offset};
860 const auto gpu_addr{memory_manager.Read<u64>(addr)}; 858 const GPUVAddr gpu_addr{memory_manager.Read<u64>(addr)};
861 const auto size{memory_manager.Read<u32>(addr + 8)}; 859 const u32 size{memory_manager.Read<u32>(addr + 8)};
862 SetupGlobalMemory(binding++, entry, gpu_addr, size); 860 SetupGlobalMemory(binding++, entry, gpu_addr, size);
863 } 861 }
864} 862}
@@ -870,7 +868,7 @@ void RasterizerOpenGL::SetupComputeGlobalMemory(const Shader& kernel) {
870 868
871 u32 binding = 0; 869 u32 binding = 0;
872 for (const auto& entry : kernel->GetEntries().global_memory_entries) { 870 for (const auto& entry : kernel->GetEntries().global_memory_entries) {
873 const auto addr{cbufs[entry.GetCbufIndex()].Address() + entry.GetCbufOffset()}; 871 const auto addr{cbufs[entry.cbuf_index].Address() + entry.cbuf_offset};
874 const auto gpu_addr{memory_manager.Read<u64>(addr)}; 872 const auto gpu_addr{memory_manager.Read<u64>(addr)};
875 const auto size{memory_manager.Read<u32>(addr + 8)}; 873 const auto size{memory_manager.Read<u32>(addr + 8)};
876 SetupGlobalMemory(binding++, entry, gpu_addr, size); 874 SetupGlobalMemory(binding++, entry, gpu_addr, size);
@@ -881,7 +879,7 @@ void RasterizerOpenGL::SetupGlobalMemory(u32 binding, const GlobalMemoryEntry& e
881 GPUVAddr gpu_addr, std::size_t size) { 879 GPUVAddr gpu_addr, std::size_t size) {
882 const auto alignment{device.GetShaderStorageBufferAlignment()}; 880 const auto alignment{device.GetShaderStorageBufferAlignment()};
883 const auto [ssbo, buffer_offset] = 881 const auto [ssbo, buffer_offset] =
884 buffer_cache.UploadMemory(gpu_addr, size, alignment, entry.IsWritten()); 882 buffer_cache.UploadMemory(gpu_addr, size, alignment, entry.is_written);
885 glBindBufferRange(GL_SHADER_STORAGE_BUFFER, binding, ssbo, buffer_offset, 883 glBindBufferRange(GL_SHADER_STORAGE_BUFFER, binding, ssbo, buffer_offset,
886 static_cast<GLsizeiptr>(size)); 884 static_cast<GLsizeiptr>(size));
887} 885}
@@ -892,7 +890,7 @@ void RasterizerOpenGL::SetupDrawTextures(std::size_t stage_index, const Shader&
892 u32 binding = device.GetBaseBindings(stage_index).sampler; 890 u32 binding = device.GetBaseBindings(stage_index).sampler;
893 for (const auto& entry : shader->GetEntries().samplers) { 891 for (const auto& entry : shader->GetEntries().samplers) {
894 const auto shader_type = static_cast<ShaderType>(stage_index); 892 const auto shader_type = static_cast<ShaderType>(stage_index);
895 for (std::size_t i = 0; i < entry.Size(); ++i) { 893 for (std::size_t i = 0; i < entry.size; ++i) {
896 const auto texture = GetTextureInfo(maxwell3d, entry, shader_type, i); 894 const auto texture = GetTextureInfo(maxwell3d, entry, shader_type, i);
897 SetupTexture(binding++, texture, entry); 895 SetupTexture(binding++, texture, entry);
898 } 896 }
@@ -904,7 +902,7 @@ void RasterizerOpenGL::SetupComputeTextures(const Shader& kernel) {
904 const auto& compute = system.GPU().KeplerCompute(); 902 const auto& compute = system.GPU().KeplerCompute();
905 u32 binding = 0; 903 u32 binding = 0;
906 for (const auto& entry : kernel->GetEntries().samplers) { 904 for (const auto& entry : kernel->GetEntries().samplers) {
907 for (std::size_t i = 0; i < entry.Size(); ++i) { 905 for (std::size_t i = 0; i < entry.size; ++i) {
908 const auto texture = GetTextureInfo(compute, entry, ShaderType::Compute, i); 906 const auto texture = GetTextureInfo(compute, entry, ShaderType::Compute, i);
909 SetupTexture(binding++, texture, entry); 907 SetupTexture(binding++, texture, entry);
910 } 908 }
@@ -961,7 +959,7 @@ void RasterizerOpenGL::SetupImage(u32 binding, const Tegra::Texture::TICEntry& t
961 if (!tic.IsBuffer()) { 959 if (!tic.IsBuffer()) {
962 view->ApplySwizzle(tic.x_source, tic.y_source, tic.z_source, tic.w_source); 960 view->ApplySwizzle(tic.x_source, tic.y_source, tic.z_source, tic.w_source);
963 } 961 }
964 if (entry.IsWritten()) { 962 if (entry.is_written) {
965 view->MarkAsModified(texture_cache.Tick()); 963 view->MarkAsModified(texture_cache.Tick());
966 } 964 }
967 glBindImageTexture(binding, view->GetTexture(), 0, GL_TRUE, 0, GL_READ_WRITE, 965 glBindImageTexture(binding, view->GetTexture(), 0, GL_TRUE, 0, GL_READ_WRITE,
diff --git a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
index 3803a6f3a..99fd4ae2c 100644
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
@@ -870,13 +870,13 @@ private:
870 for (const auto& sampler : ir.GetSamplers()) { 870 for (const auto& sampler : ir.GetSamplers()) {
871 const std::string name = GetSampler(sampler); 871 const std::string name = GetSampler(sampler);
872 const std::string description = fmt::format("layout (binding = {}) uniform", binding); 872 const std::string description = fmt::format("layout (binding = {}) uniform", binding);
873 binding += sampler.IsIndexed() ? sampler.Size() : 1; 873 binding += sampler.is_indexed ? sampler.size : 1;
874 874
875 std::string sampler_type = [&]() { 875 std::string sampler_type = [&]() {
876 if (sampler.IsBuffer()) { 876 if (sampler.is_buffer) {
877 return "samplerBuffer"; 877 return "samplerBuffer";
878 } 878 }
879 switch (sampler.GetType()) { 879 switch (sampler.type) {
880 case Tegra::Shader::TextureType::Texture1D: 880 case Tegra::Shader::TextureType::Texture1D:
881 return "sampler1D"; 881 return "sampler1D";
882 case Tegra::Shader::TextureType::Texture2D: 882 case Tegra::Shader::TextureType::Texture2D:
@@ -890,17 +890,17 @@ private:
890 return "sampler2D"; 890 return "sampler2D";
891 } 891 }
892 }(); 892 }();
893 if (sampler.IsArray()) { 893 if (sampler.is_array) {
894 sampler_type += "Array"; 894 sampler_type += "Array";
895 } 895 }
896 if (sampler.IsShadow()) { 896 if (sampler.is_shadow) {
897 sampler_type += "Shadow"; 897 sampler_type += "Shadow";
898 } 898 }
899 899
900 if (!sampler.IsIndexed()) { 900 if (!sampler.is_indexed) {
901 code.AddLine("{} {} {};", description, sampler_type, name); 901 code.AddLine("{} {} {};", description, sampler_type, name);
902 } else { 902 } else {
903 code.AddLine("{} {} {}[{}];", description, sampler_type, name, sampler.Size()); 903 code.AddLine("{} {} {}[{}];", description, sampler_type, name, sampler.size);
904 } 904 }
905 } 905 }
906 if (!ir.GetSamplers().empty()) { 906 if (!ir.GetSamplers().empty()) {
@@ -946,14 +946,14 @@ private:
946 u32 binding = device.GetBaseBindings(stage).image; 946 u32 binding = device.GetBaseBindings(stage).image;
947 for (const auto& image : ir.GetImages()) { 947 for (const auto& image : ir.GetImages()) {
948 std::string qualifier = "coherent volatile"; 948 std::string qualifier = "coherent volatile";
949 if (image.IsRead() && !image.IsWritten()) { 949 if (image.is_read && !image.is_written) {
950 qualifier += " readonly"; 950 qualifier += " readonly";
951 } else if (image.IsWritten() && !image.IsRead()) { 951 } else if (image.is_written && !image.is_read) {
952 qualifier += " writeonly"; 952 qualifier += " writeonly";
953 } 953 }
954 954
955 const char* format = image.IsAtomic() ? "r32ui, " : ""; 955 const char* format = image.is_atomic ? "r32ui, " : "";
956 const char* type_declaration = GetImageTypeDeclaration(image.GetType()); 956 const char* type_declaration = GetImageTypeDeclaration(image.type);
957 code.AddLine("layout ({}binding = {}) {} uniform uimage{} {};", format, binding++, 957 code.AddLine("layout ({}binding = {}) {} uniform uimage{} {};", format, binding++,
958 qualifier, type_declaration, GetImage(image)); 958 qualifier, type_declaration, GetImage(image));
959 } 959 }
@@ -1337,8 +1337,8 @@ private:
1337 ASSERT(meta); 1337 ASSERT(meta);
1338 1338
1339 const std::size_t count = operation.GetOperandsCount(); 1339 const std::size_t count = operation.GetOperandsCount();
1340 const bool has_array = meta->sampler.IsArray(); 1340 const bool has_array = meta->sampler.is_array;
1341 const bool has_shadow = meta->sampler.IsShadow(); 1341 const bool has_shadow = meta->sampler.is_shadow;
1342 1342
1343 std::string expr = "texture" + function_suffix; 1343 std::string expr = "texture" + function_suffix;
1344 if (!meta->aoffi.empty()) { 1344 if (!meta->aoffi.empty()) {
@@ -1346,7 +1346,7 @@ private:
1346 } else if (!meta->ptp.empty()) { 1346 } else if (!meta->ptp.empty()) {
1347 expr += "Offsets"; 1347 expr += "Offsets";
1348 } 1348 }
1349 if (!meta->sampler.IsIndexed()) { 1349 if (!meta->sampler.is_indexed) {
1350 expr += '(' + GetSampler(meta->sampler) + ", "; 1350 expr += '(' + GetSampler(meta->sampler) + ", ";
1351 } else { 1351 } else {
1352 expr += '(' + GetSampler(meta->sampler) + '[' + Visit(meta->index).AsUint() + "], "; 1352 expr += '(' + GetSampler(meta->sampler) + '[' + Visit(meta->index).AsUint() + "], ";
@@ -1982,7 +1982,7 @@ private:
1982 1982
1983 std::string expr = GenerateTexture( 1983 std::string expr = GenerateTexture(
1984 operation, "", {TextureOffset{}, TextureArgument{Type::Float, meta->bias}}); 1984 operation, "", {TextureOffset{}, TextureArgument{Type::Float, meta->bias}});
1985 if (meta->sampler.IsShadow()) { 1985 if (meta->sampler.is_shadow) {
1986 expr = "vec4(" + expr + ')'; 1986 expr = "vec4(" + expr + ')';
1987 } 1987 }
1988 return {expr + GetSwizzle(meta->element), Type::Float}; 1988 return {expr + GetSwizzle(meta->element), Type::Float};
@@ -1994,7 +1994,7 @@ private:
1994 1994
1995 std::string expr = GenerateTexture( 1995 std::string expr = GenerateTexture(
1996 operation, "Lod", {TextureArgument{Type::Float, meta->lod}, TextureOffset{}}); 1996 operation, "Lod", {TextureArgument{Type::Float, meta->lod}, TextureOffset{}});
1997 if (meta->sampler.IsShadow()) { 1997 if (meta->sampler.is_shadow) {
1998 expr = "vec4(" + expr + ')'; 1998 expr = "vec4(" + expr + ')';
1999 } 1999 }
2000 return {expr + GetSwizzle(meta->element), Type::Float}; 2000 return {expr + GetSwizzle(meta->element), Type::Float};
@@ -2003,11 +2003,11 @@ private:
2003 Expression TextureGather(Operation operation) { 2003 Expression TextureGather(Operation operation) {
2004 const auto& meta = std::get<MetaTexture>(operation.GetMeta()); 2004 const auto& meta = std::get<MetaTexture>(operation.GetMeta());
2005 2005
2006 const auto type = meta.sampler.IsShadow() ? Type::Float : Type::Int; 2006 const auto type = meta.sampler.is_shadow ? Type::Float : Type::Int;
2007 const bool separate_dc = meta.sampler.IsShadow(); 2007 const bool separate_dc = meta.sampler.is_shadow;
2008 2008
2009 std::vector<TextureIR> ir; 2009 std::vector<TextureIR> ir;
2010 if (meta.sampler.IsShadow()) { 2010 if (meta.sampler.is_shadow) {
2011 ir = {TextureOffset{}}; 2011 ir = {TextureOffset{}};
2012 } else { 2012 } else {
2013 ir = {TextureOffset{}, TextureArgument{type, meta.component}}; 2013 ir = {TextureOffset{}, TextureArgument{type, meta.component}};
@@ -2052,7 +2052,7 @@ private:
2052 constexpr std::array constructors = {"int", "ivec2", "ivec3", "ivec4"}; 2052 constexpr std::array constructors = {"int", "ivec2", "ivec3", "ivec4"};
2053 const auto meta = std::get_if<MetaTexture>(&operation.GetMeta()); 2053 const auto meta = std::get_if<MetaTexture>(&operation.GetMeta());
2054 ASSERT(meta); 2054 ASSERT(meta);
2055 UNIMPLEMENTED_IF(meta->sampler.IsArray()); 2055 UNIMPLEMENTED_IF(meta->sampler.is_array);
2056 const std::size_t count = operation.GetOperandsCount(); 2056 const std::size_t count = operation.GetOperandsCount();
2057 2057
2058 std::string expr = "texelFetch("; 2058 std::string expr = "texelFetch(";
@@ -2073,7 +2073,7 @@ private:
2073 } 2073 }
2074 expr += ')'; 2074 expr += ')';
2075 2075
2076 if (meta->lod && !meta->sampler.IsBuffer()) { 2076 if (meta->lod && !meta->sampler.is_buffer) {
2077 expr += ", "; 2077 expr += ", ";
2078 expr += Visit(meta->lod).AsInt(); 2078 expr += Visit(meta->lod).AsInt();
2079 } 2079 }
@@ -2084,12 +2084,10 @@ private:
2084 } 2084 }
2085 2085
2086 Expression TextureGradient(Operation operation) { 2086 Expression TextureGradient(Operation operation) {
2087 const auto meta = std::get_if<MetaTexture>(&operation.GetMeta()); 2087 const auto& meta = std::get<MetaTexture>(operation.GetMeta());
2088 ASSERT(meta);
2089
2090 std::string expr = 2088 std::string expr =
2091 GenerateTexture(operation, "Grad", {TextureDerivates{}, TextureOffset{}}); 2089 GenerateTexture(operation, "Grad", {TextureDerivates{}, TextureOffset{}});
2092 return {std::move(expr) + GetSwizzle(meta->element), Type::Float}; 2090 return {std::move(expr) + GetSwizzle(meta.element), Type::Float};
2093 } 2091 }
2094 2092
2095 Expression ImageLoad(Operation operation) { 2093 Expression ImageLoad(Operation operation) {
@@ -2608,11 +2606,11 @@ private:
2608 } 2606 }
2609 2607
2610 std::string GetSampler(const Sampler& sampler) const { 2608 std::string GetSampler(const Sampler& sampler) const {
2611 return AppendSuffix(static_cast<u32>(sampler.GetIndex()), "sampler"); 2609 return AppendSuffix(sampler.index, "sampler");
2612 } 2610 }
2613 2611
2614 std::string GetImage(const Image& image) const { 2612 std::string GetImage(const Image& image) const {
2615 return AppendSuffix(static_cast<u32>(image.GetIndex()), "image"); 2613 return AppendSuffix(image.index, "image");
2616 } 2614 }
2617 2615
2618 std::string AppendSuffix(u32 index, std::string_view name) const { 2616 std::string AppendSuffix(u32 index, std::string_view name) const {
diff --git a/src/video_core/renderer_opengl/gl_shader_decompiler.h b/src/video_core/renderer_opengl/gl_shader_decompiler.h
index e7dbd810c..e8a178764 100644
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.h
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.h
@@ -33,36 +33,19 @@ public:
33 } 33 }
34 34
35private: 35private:
36 u32 index{}; 36 u32 index = 0;
37}; 37};
38 38
39class GlobalMemoryEntry { 39struct GlobalMemoryEntry {
40public: 40 constexpr explicit GlobalMemoryEntry(u32 cbuf_index, u32 cbuf_offset, bool is_read,
41 explicit GlobalMemoryEntry(u32 cbuf_index, u32 cbuf_offset, bool is_read, bool is_written) 41 bool is_written)
42 : cbuf_index{cbuf_index}, cbuf_offset{cbuf_offset}, is_read{is_read}, is_written{ 42 : cbuf_index{cbuf_index}, cbuf_offset{cbuf_offset}, is_read{is_read}, is_written{
43 is_written} {} 43 is_written} {}
44 44
45 u32 GetCbufIndex() const { 45 u32 cbuf_index = 0;
46 return cbuf_index; 46 u32 cbuf_offset = 0;
47 } 47 bool is_read = false;
48 48 bool is_written = false;
49 u32 GetCbufOffset() const {
50 return cbuf_offset;
51 }
52
53 bool IsRead() const {
54 return is_read;
55 }
56
57 bool IsWritten() const {
58 return is_written;
59 }
60
61private:
62 u32 cbuf_index{};
63 u32 cbuf_offset{};
64 bool is_read{};
65 bool is_written{};
66}; 49};
67 50
68struct ShaderEntries { 51struct ShaderEntries {
diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
index 9b703a2f0..8fbd63dbc 100644
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -85,7 +85,7 @@ void AddBindings(std::vector<VkDescriptorSetLayoutBinding>& bindings, u32& bindi
85 u32 count = 1; 85 u32 count = 1;
86 if constexpr (descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) { 86 if constexpr (descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) {
87 // Combined image samplers can be arrayed. 87 // Combined image samplers can be arrayed.
88 count = container[i].Size(); 88 count = container[i].size;
89 } 89 }
90 VkDescriptorSetLayoutBinding& entry = bindings.emplace_back(); 90 VkDescriptorSetLayoutBinding& entry = bindings.emplace_back();
91 entry.binding = binding++; 91 entry.binding = binding++;
@@ -362,7 +362,7 @@ void AddEntry(std::vector<VkDescriptorUpdateTemplateEntry>& template_entries, u3
362 362
363 if constexpr (descriptor_type == COMBINED_IMAGE_SAMPLER) { 363 if constexpr (descriptor_type == COMBINED_IMAGE_SAMPLER) {
364 for (u32 i = 0; i < count; ++i) { 364 for (u32 i = 0; i < count; ++i) {
365 const u32 num_samplers = container[i].Size(); 365 const u32 num_samplers = container[i].size;
366 VkDescriptorUpdateTemplateEntry& entry = template_entries.emplace_back(); 366 VkDescriptorUpdateTemplateEntry& entry = template_entries.emplace_back();
367 entry.dstBinding = binding; 367 entry.dstBinding = binding;
368 entry.dstArrayElement = 0; 368 entry.dstArrayElement = 0;
diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.cpp b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
index 776053de5..ccfd0e670 100644
--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -119,14 +119,13 @@ template <typename Engine, typename Entry>
119Tegra::Texture::FullTextureInfo GetTextureInfo(const Engine& engine, const Entry& entry, 119Tegra::Texture::FullTextureInfo GetTextureInfo(const Engine& engine, const Entry& entry,
120 std::size_t stage, std::size_t index = 0) { 120 std::size_t stage, std::size_t index = 0) {
121 const auto stage_type = static_cast<Tegra::Engines::ShaderType>(stage); 121 const auto stage_type = static_cast<Tegra::Engines::ShaderType>(stage);
122 if (entry.IsBindless()) { 122 if (entry.is_bindless) {
123 const Tegra::Texture::TextureHandle tex_handle = 123 const auto tex_handle = engine.AccessConstBuffer32(stage_type, entry.buffer, entry.offset);
124 engine.AccessConstBuffer32(stage_type, entry.GetBuffer(), entry.GetOffset());
125 return engine.GetTextureInfo(tex_handle); 124 return engine.GetTextureInfo(tex_handle);
126 } 125 }
127 const auto& gpu_profile = engine.AccessGuestDriverProfile(); 126 const auto& gpu_profile = engine.AccessGuestDriverProfile();
128 const u32 entry_offset = static_cast<u32>(index * gpu_profile.GetTextureHandlerSize()); 127 const u32 entry_offset = static_cast<u32>(index * gpu_profile.GetTextureHandlerSize());
129 const u32 offset = entry.GetOffset() + entry_offset; 128 const u32 offset = entry.offset + entry_offset;
130 if constexpr (std::is_same_v<Engine, Tegra::Engines::Maxwell3D>) { 129 if constexpr (std::is_same_v<Engine, Tegra::Engines::Maxwell3D>) {
131 return engine.GetStageTexture(stage_type, offset); 130 return engine.GetStageTexture(stage_type, offset);
132 } else { 131 } else {
@@ -971,7 +970,7 @@ void RasterizerVulkan::SetupGraphicsTextures(const ShaderEntries& entries, std::
971 MICROPROFILE_SCOPE(Vulkan_Textures); 970 MICROPROFILE_SCOPE(Vulkan_Textures);
972 const auto& gpu = system.GPU().Maxwell3D(); 971 const auto& gpu = system.GPU().Maxwell3D();
973 for (const auto& entry : entries.samplers) { 972 for (const auto& entry : entries.samplers) {
974 for (std::size_t i = 0; i < entry.Size(); ++i) { 973 for (std::size_t i = 0; i < entry.size; ++i) {
975 const auto texture = GetTextureInfo(gpu, entry, stage, i); 974 const auto texture = GetTextureInfo(gpu, entry, stage, i);
976 SetupTexture(texture, entry); 975 SetupTexture(texture, entry);
977 } 976 }
@@ -1023,7 +1022,7 @@ void RasterizerVulkan::SetupComputeTextures(const ShaderEntries& entries) {
1023 MICROPROFILE_SCOPE(Vulkan_Textures); 1022 MICROPROFILE_SCOPE(Vulkan_Textures);
1024 const auto& gpu = system.GPU().KeplerCompute(); 1023 const auto& gpu = system.GPU().KeplerCompute();
1025 for (const auto& entry : entries.samplers) { 1024 for (const auto& entry : entries.samplers) {
1026 for (std::size_t i = 0; i < entry.Size(); ++i) { 1025 for (std::size_t i = 0; i < entry.size; ++i) {
1027 const auto texture = GetTextureInfo(gpu, entry, ComputeShaderIndex, i); 1026 const auto texture = GetTextureInfo(gpu, entry, ComputeShaderIndex, i);
1028 SetupTexture(texture, entry); 1027 SetupTexture(texture, entry);
1029 } 1028 }
@@ -1105,7 +1104,7 @@ void RasterizerVulkan::SetupTexture(const Tegra::Texture::FullTextureInfo& textu
1105void RasterizerVulkan::SetupImage(const Tegra::Texture::TICEntry& tic, const ImageEntry& entry) { 1104void RasterizerVulkan::SetupImage(const Tegra::Texture::TICEntry& tic, const ImageEntry& entry) {
1106 auto view = texture_cache.GetImageSurface(tic, entry); 1105 auto view = texture_cache.GetImageSurface(tic, entry);
1107 1106
1108 if (entry.IsWritten()) { 1107 if (entry.is_written) {
1109 view->MarkAsModified(texture_cache.Tick()); 1108 view->MarkAsModified(texture_cache.Tick());
1110 } 1109 }
1111 1110
diff --git a/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp b/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
index 20b6ca0ad..18678968c 100644
--- a/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
+++ b/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
@@ -103,8 +103,8 @@ struct GenericVaryingDescription {
103}; 103};
104 104
105spv::Dim GetSamplerDim(const Sampler& sampler) { 105spv::Dim GetSamplerDim(const Sampler& sampler) {
106 ASSERT(!sampler.IsBuffer()); 106 ASSERT(!sampler.is_buffer);
107 switch (sampler.GetType()) { 107 switch (sampler.type) {
108 case Tegra::Shader::TextureType::Texture1D: 108 case Tegra::Shader::TextureType::Texture1D:
109 return spv::Dim::Dim1D; 109 return spv::Dim::Dim1D;
110 case Tegra::Shader::TextureType::Texture2D: 110 case Tegra::Shader::TextureType::Texture2D:
@@ -114,13 +114,13 @@ spv::Dim GetSamplerDim(const Sampler& sampler) {
114 case Tegra::Shader::TextureType::TextureCube: 114 case Tegra::Shader::TextureType::TextureCube:
115 return spv::Dim::Cube; 115 return spv::Dim::Cube;
116 default: 116 default:
117 UNIMPLEMENTED_MSG("Unimplemented sampler type={}", static_cast<u32>(sampler.GetType())); 117 UNIMPLEMENTED_MSG("Unimplemented sampler type={}", static_cast<int>(sampler.type));
118 return spv::Dim::Dim2D; 118 return spv::Dim::Dim2D;
119 } 119 }
120} 120}
121 121
122std::pair<spv::Dim, bool> GetImageDim(const Image& image) { 122std::pair<spv::Dim, bool> GetImageDim(const Image& image) {
123 switch (image.GetType()) { 123 switch (image.type) {
124 case Tegra::Shader::ImageType::Texture1D: 124 case Tegra::Shader::ImageType::Texture1D:
125 return {spv::Dim::Dim1D, false}; 125 return {spv::Dim::Dim1D, false};
126 case Tegra::Shader::ImageType::TextureBuffer: 126 case Tegra::Shader::ImageType::TextureBuffer:
@@ -134,7 +134,7 @@ std::pair<spv::Dim, bool> GetImageDim(const Image& image) {
134 case Tegra::Shader::ImageType::Texture3D: 134 case Tegra::Shader::ImageType::Texture3D:
135 return {spv::Dim::Dim3D, false}; 135 return {spv::Dim::Dim3D, false};
136 default: 136 default:
137 UNIMPLEMENTED_MSG("Unimplemented image type={}", static_cast<u32>(image.GetType())); 137 UNIMPLEMENTED_MSG("Unimplemented image type={}", static_cast<int>(image.type));
138 return {spv::Dim::Dim2D, false}; 138 return {spv::Dim::Dim2D, false};
139 } 139 }
140} 140}
@@ -879,11 +879,11 @@ private:
879 879
880 u32 DeclareTexelBuffers(u32 binding) { 880 u32 DeclareTexelBuffers(u32 binding) {
881 for (const auto& sampler : ir.GetSamplers()) { 881 for (const auto& sampler : ir.GetSamplers()) {
882 if (!sampler.IsBuffer()) { 882 if (!sampler.is_buffer) {
883 continue; 883 continue;
884 } 884 }
885 ASSERT(!sampler.IsArray()); 885 ASSERT(!sampler.is_array);
886 ASSERT(!sampler.IsShadow()); 886 ASSERT(!sampler.is_shadow);
887 887
888 constexpr auto dim = spv::Dim::Buffer; 888 constexpr auto dim = spv::Dim::Buffer;
889 constexpr int depth = 0; 889 constexpr int depth = 0;
@@ -894,23 +894,23 @@ private:
894 const Id image_type = TypeImage(t_float, dim, depth, arrayed, ms, sampled, format); 894 const Id image_type = TypeImage(t_float, dim, depth, arrayed, ms, sampled, format);
895 const Id pointer_type = TypePointer(spv::StorageClass::UniformConstant, image_type); 895 const Id pointer_type = TypePointer(spv::StorageClass::UniformConstant, image_type);
896 const Id id = OpVariable(pointer_type, spv::StorageClass::UniformConstant); 896 const Id id = OpVariable(pointer_type, spv::StorageClass::UniformConstant);
897 AddGlobalVariable(Name(id, fmt::format("sampler_{}", sampler.GetIndex()))); 897 AddGlobalVariable(Name(id, fmt::format("sampler_{}", sampler.index)));
898 Decorate(id, spv::Decoration::Binding, binding++); 898 Decorate(id, spv::Decoration::Binding, binding++);
899 Decorate(id, spv::Decoration::DescriptorSet, DESCRIPTOR_SET); 899 Decorate(id, spv::Decoration::DescriptorSet, DESCRIPTOR_SET);
900 900
901 texel_buffers.emplace(sampler.GetIndex(), TexelBuffer{image_type, id}); 901 texel_buffers.emplace(sampler.index, TexelBuffer{image_type, id});
902 } 902 }
903 return binding; 903 return binding;
904 } 904 }
905 905
906 u32 DeclareSamplers(u32 binding) { 906 u32 DeclareSamplers(u32 binding) {
907 for (const auto& sampler : ir.GetSamplers()) { 907 for (const auto& sampler : ir.GetSamplers()) {
908 if (sampler.IsBuffer()) { 908 if (sampler.is_buffer) {
909 continue; 909 continue;
910 } 910 }
911 const auto dim = GetSamplerDim(sampler); 911 const auto dim = GetSamplerDim(sampler);
912 const int depth = sampler.IsShadow() ? 1 : 0; 912 const int depth = sampler.is_shadow ? 1 : 0;
913 const int arrayed = sampler.IsArray() ? 1 : 0; 913 const int arrayed = sampler.is_array ? 1 : 0;
914 constexpr bool ms = false; 914 constexpr bool ms = false;
915 constexpr int sampled = 1; 915 constexpr int sampled = 1;
916 constexpr auto format = spv::ImageFormat::Unknown; 916 constexpr auto format = spv::ImageFormat::Unknown;
@@ -918,17 +918,17 @@ private:
918 const Id sampler_type = TypeSampledImage(image_type); 918 const Id sampler_type = TypeSampledImage(image_type);
919 const Id sampler_pointer_type = 919 const Id sampler_pointer_type =
920 TypePointer(spv::StorageClass::UniformConstant, sampler_type); 920 TypePointer(spv::StorageClass::UniformConstant, sampler_type);
921 const Id type = sampler.IsIndexed() 921 const Id type = sampler.is_indexed
922 ? TypeArray(sampler_type, Constant(t_uint, sampler.Size())) 922 ? TypeArray(sampler_type, Constant(t_uint, sampler.size))
923 : sampler_type; 923 : sampler_type;
924 const Id pointer_type = TypePointer(spv::StorageClass::UniformConstant, type); 924 const Id pointer_type = TypePointer(spv::StorageClass::UniformConstant, type);
925 const Id id = OpVariable(pointer_type, spv::StorageClass::UniformConstant); 925 const Id id = OpVariable(pointer_type, spv::StorageClass::UniformConstant);
926 AddGlobalVariable(Name(id, fmt::format("sampler_{}", sampler.GetIndex()))); 926 AddGlobalVariable(Name(id, fmt::format("sampler_{}", sampler.index)));
927 Decorate(id, spv::Decoration::Binding, binding++); 927 Decorate(id, spv::Decoration::Binding, binding++);
928 Decorate(id, spv::Decoration::DescriptorSet, DESCRIPTOR_SET); 928 Decorate(id, spv::Decoration::DescriptorSet, DESCRIPTOR_SET);
929 929
930 sampled_images.emplace(sampler.GetIndex(), SampledImage{image_type, sampler_type, 930 sampled_images.emplace(
931 sampler_pointer_type, id}); 931 sampler.index, SampledImage{image_type, sampler_type, sampler_pointer_type, id});
932 } 932 }
933 return binding; 933 return binding;
934 } 934 }
@@ -943,17 +943,17 @@ private:
943 const Id image_type = TypeImage(t_uint, dim, depth, arrayed, ms, sampled, format, {}); 943 const Id image_type = TypeImage(t_uint, dim, depth, arrayed, ms, sampled, format, {});
944 const Id pointer_type = TypePointer(spv::StorageClass::UniformConstant, image_type); 944 const Id pointer_type = TypePointer(spv::StorageClass::UniformConstant, image_type);
945 const Id id = OpVariable(pointer_type, spv::StorageClass::UniformConstant); 945 const Id id = OpVariable(pointer_type, spv::StorageClass::UniformConstant);
946 AddGlobalVariable(Name(id, fmt::format("image_{}", image.GetIndex()))); 946 AddGlobalVariable(Name(id, fmt::format("image_{}", image.index)));
947 947
948 Decorate(id, spv::Decoration::Binding, binding++); 948 Decorate(id, spv::Decoration::Binding, binding++);
949 Decorate(id, spv::Decoration::DescriptorSet, DESCRIPTOR_SET); 949 Decorate(id, spv::Decoration::DescriptorSet, DESCRIPTOR_SET);
950 if (image.IsRead() && !image.IsWritten()) { 950 if (image.is_read && !image.is_written) {
951 Decorate(id, spv::Decoration::NonWritable); 951 Decorate(id, spv::Decoration::NonWritable);
952 } else if (image.IsWritten() && !image.IsRead()) { 952 } else if (image.is_written && !image.is_read) {
953 Decorate(id, spv::Decoration::NonReadable); 953 Decorate(id, spv::Decoration::NonReadable);
954 } 954 }
955 955
956 images.emplace(static_cast<u32>(image.GetIndex()), StorageImage{image_type, id}); 956 images.emplace(image.index, StorageImage{image_type, id});
957 } 957 }
958 return binding; 958 return binding;
959 } 959 }
@@ -1620,11 +1620,11 @@ private:
1620 1620
1621 Id GetTextureSampler(Operation operation) { 1621 Id GetTextureSampler(Operation operation) {
1622 const auto& meta = std::get<MetaTexture>(operation.GetMeta()); 1622 const auto& meta = std::get<MetaTexture>(operation.GetMeta());
1623 ASSERT(!meta.sampler.IsBuffer()); 1623 ASSERT(!meta.sampler.is_buffer);
1624 1624
1625 const auto& entry = sampled_images.at(meta.sampler.GetIndex()); 1625 const auto& entry = sampled_images.at(meta.sampler.index);
1626 Id sampler = entry.variable; 1626 Id sampler = entry.variable;
1627 if (meta.sampler.IsIndexed()) { 1627 if (meta.sampler.is_indexed) {
1628 const Id index = AsInt(Visit(meta.index)); 1628 const Id index = AsInt(Visit(meta.index));
1629 sampler = OpAccessChain(entry.sampler_pointer_type, sampler, index); 1629 sampler = OpAccessChain(entry.sampler_pointer_type, sampler, index);
1630 } 1630 }
@@ -1633,8 +1633,8 @@ private:
1633 1633
1634 Id GetTextureImage(Operation operation) { 1634 Id GetTextureImage(Operation operation) {
1635 const auto& meta = std::get<MetaTexture>(operation.GetMeta()); 1635 const auto& meta = std::get<MetaTexture>(operation.GetMeta());
1636 const u32 index = meta.sampler.GetIndex(); 1636 const u32 index = meta.sampler.index;
1637 if (meta.sampler.IsBuffer()) { 1637 if (meta.sampler.is_buffer) {
1638 const auto& entry = texel_buffers.at(index); 1638 const auto& entry = texel_buffers.at(index);
1639 return OpLoad(entry.image_type, entry.image); 1639 return OpLoad(entry.image_type, entry.image);
1640 } else { 1640 } else {
@@ -1645,7 +1645,7 @@ private:
1645 1645
1646 Id GetImage(Operation operation) { 1646 Id GetImage(Operation operation) {
1647 const auto& meta = std::get<MetaImage>(operation.GetMeta()); 1647 const auto& meta = std::get<MetaImage>(operation.GetMeta());
1648 const auto entry = images.at(meta.image.GetIndex()); 1648 const auto entry = images.at(meta.image.index);
1649 return OpLoad(entry.image_type, entry.image); 1649 return OpLoad(entry.image_type, entry.image);
1650 } 1650 }
1651 1651
@@ -1661,7 +1661,7 @@ private:
1661 } 1661 }
1662 if (const auto meta = std::get_if<MetaTexture>(&operation.GetMeta())) { 1662 if (const auto meta = std::get_if<MetaTexture>(&operation.GetMeta())) {
1663 // Add array coordinate for textures 1663 // Add array coordinate for textures
1664 if (meta->sampler.IsArray()) { 1664 if (meta->sampler.is_array) {
1665 Id array = AsInt(Visit(meta->array)); 1665 Id array = AsInt(Visit(meta->array));
1666 if (type == Type::Float) { 1666 if (type == Type::Float) {
1667 array = OpConvertSToF(t_float, array); 1667 array = OpConvertSToF(t_float, array);
@@ -1767,7 +1767,7 @@ private:
1767 operands.push_back(GetOffsetCoordinates(operation)); 1767 operands.push_back(GetOffsetCoordinates(operation));
1768 } 1768 }
1769 1769
1770 if (meta.sampler.IsShadow()) { 1770 if (meta.sampler.is_shadow) {
1771 const Id dref = AsFloat(Visit(meta.depth_compare)); 1771 const Id dref = AsFloat(Visit(meta.depth_compare));
1772 return {OpImageSampleDrefExplicitLod(t_float, sampler, coords, dref, mask, operands), 1772 return {OpImageSampleDrefExplicitLod(t_float, sampler, coords, dref, mask, operands),
1773 Type::Float}; 1773 Type::Float};
@@ -1782,7 +1782,7 @@ private:
1782 1782
1783 const Id coords = GetCoordinates(operation, Type::Float); 1783 const Id coords = GetCoordinates(operation, Type::Float);
1784 Id texture{}; 1784 Id texture{};
1785 if (meta.sampler.IsShadow()) { 1785 if (meta.sampler.is_shadow) {
1786 texture = OpImageDrefGather(t_float4, GetTextureSampler(operation), coords, 1786 texture = OpImageDrefGather(t_float4, GetTextureSampler(operation), coords,
1787 AsFloat(Visit(meta.depth_compare))); 1787 AsFloat(Visit(meta.depth_compare)));
1788 } else { 1788 } else {
@@ -1809,8 +1809,8 @@ private:
1809 } 1809 }
1810 1810
1811 const Id lod = AsUint(Visit(operation[0])); 1811 const Id lod = AsUint(Visit(operation[0]));
1812 const std::size_t coords_count = [&]() { 1812 const std::size_t coords_count = [&meta] {
1813 switch (const auto type = meta.sampler.GetType(); type) { 1813 switch (const auto type = meta.sampler.type) {
1814 case Tegra::Shader::TextureType::Texture1D: 1814 case Tegra::Shader::TextureType::Texture1D:
1815 return 1; 1815 return 1;
1816 case Tegra::Shader::TextureType::Texture2D: 1816 case Tegra::Shader::TextureType::Texture2D:
@@ -1819,7 +1819,7 @@ private:
1819 case Tegra::Shader::TextureType::Texture3D: 1819 case Tegra::Shader::TextureType::Texture3D:
1820 return 3; 1820 return 3;
1821 default: 1821 default:
1822 UNREACHABLE_MSG("Invalid texture type={}", static_cast<u32>(type)); 1822 UNREACHABLE_MSG("Invalid texture type={}", static_cast<int>(type));
1823 return 2; 1823 return 2;
1824 } 1824 }
1825 }(); 1825 }();
@@ -1862,7 +1862,7 @@ private:
1862 const Id image = GetTextureImage(operation); 1862 const Id image = GetTextureImage(operation);
1863 const Id coords = GetCoordinates(operation, Type::Int); 1863 const Id coords = GetCoordinates(operation, Type::Int);
1864 Id fetch; 1864 Id fetch;
1865 if (meta.lod && !meta.sampler.IsBuffer()) { 1865 if (meta.lod && !meta.sampler.is_buffer) {
1866 fetch = OpImageFetch(t_float4, image, coords, spv::ImageOperandsMask::Lod, 1866 fetch = OpImageFetch(t_float4, image, coords, spv::ImageOperandsMask::Lod,
1867 AsInt(Visit(meta.lod))); 1867 AsInt(Visit(meta.lod)));
1868 } else { 1868 } else {
@@ -2980,7 +2980,7 @@ ShaderEntries GenerateShaderEntries(const VideoCommon::Shader::ShaderIR& ir) {
2980 entries.global_buffers.emplace_back(base.cbuf_index, base.cbuf_offset, usage.is_written); 2980 entries.global_buffers.emplace_back(base.cbuf_index, base.cbuf_offset, usage.is_written);
2981 } 2981 }
2982 for (const auto& sampler : ir.GetSamplers()) { 2982 for (const auto& sampler : ir.GetSamplers()) {
2983 if (sampler.IsBuffer()) { 2983 if (sampler.is_buffer) {
2984 entries.texel_buffers.emplace_back(sampler); 2984 entries.texel_buffers.emplace_back(sampler);
2985 } else { 2985 } else {
2986 entries.samplers.emplace_back(sampler); 2986 entries.samplers.emplace_back(sampler);
diff --git a/src/video_core/shader/decode.cpp b/src/video_core/shader/decode.cpp
index 1167ff4ec..a75a5cc63 100644
--- a/src/video_core/shader/decode.cpp
+++ b/src/video_core/shader/decode.cpp
@@ -32,11 +32,11 @@ void DeduceTextureHandlerSize(VideoCore::GuestDriverProfile& gpu_driver,
32 u32 count{}; 32 u32 count{};
33 std::vector<u32> bound_offsets; 33 std::vector<u32> bound_offsets;
34 for (const auto& sampler : used_samplers) { 34 for (const auto& sampler : used_samplers) {
35 if (sampler.IsBindless()) { 35 if (sampler.is_bindless) {
36 continue; 36 continue;
37 } 37 }
38 ++count; 38 ++count;
39 bound_offsets.emplace_back(sampler.GetOffset()); 39 bound_offsets.emplace_back(sampler.offset);
40 } 40 }
41 if (count > 1) { 41 if (count > 1) {
42 gpu_driver.DeduceTextureHandlerSize(std::move(bound_offsets)); 42 gpu_driver.DeduceTextureHandlerSize(std::move(bound_offsets));
@@ -46,14 +46,14 @@ void DeduceTextureHandlerSize(VideoCore::GuestDriverProfile& gpu_driver,
46std::optional<u32> TryDeduceSamplerSize(const Sampler& sampler_to_deduce, 46std::optional<u32> TryDeduceSamplerSize(const Sampler& sampler_to_deduce,
47 VideoCore::GuestDriverProfile& gpu_driver, 47 VideoCore::GuestDriverProfile& gpu_driver,
48 const std::list<Sampler>& used_samplers) { 48 const std::list<Sampler>& used_samplers) {
49 const u32 base_offset = sampler_to_deduce.GetOffset(); 49 const u32 base_offset = sampler_to_deduce.offset;
50 u32 max_offset{std::numeric_limits<u32>::max()}; 50 u32 max_offset{std::numeric_limits<u32>::max()};
51 for (const auto& sampler : used_samplers) { 51 for (const auto& sampler : used_samplers) {
52 if (sampler.IsBindless()) { 52 if (sampler.is_bindless) {
53 continue; 53 continue;
54 } 54 }
55 if (sampler.GetOffset() > base_offset) { 55 if (sampler.offset > base_offset) {
56 max_offset = std::min(sampler.GetOffset(), max_offset); 56 max_offset = std::min(sampler.offset, max_offset);
57 } 57 }
58 } 58 }
59 if (max_offset == std::numeric_limits<u32>::max()) { 59 if (max_offset == std::numeric_limits<u32>::max()) {
@@ -353,14 +353,14 @@ void ShaderIR::PostDecode() {
353 return; 353 return;
354 } 354 }
355 for (auto& sampler : used_samplers) { 355 for (auto& sampler : used_samplers) {
356 if (!sampler.IsIndexed()) { 356 if (!sampler.is_indexed) {
357 continue; 357 continue;
358 } 358 }
359 if (const auto size = TryDeduceSamplerSize(sampler, gpu_driver, used_samplers)) { 359 if (const auto size = TryDeduceSamplerSize(sampler, gpu_driver, used_samplers)) {
360 sampler.SetSize(*size); 360 sampler.size = *size;
361 } else { 361 } else {
362 LOG_CRITICAL(HW_GPU, "Failed to deduce size of indexed sampler"); 362 LOG_CRITICAL(HW_GPU, "Failed to deduce size of indexed sampler");
363 sampler.SetSize(1); 363 sampler.size = 1;
364 } 364 }
365 } 365 }
366} 366}
diff --git a/src/video_core/shader/decode/image.cpp b/src/video_core/shader/decode/image.cpp
index 85ee9aa5e..60b6ad72a 100644
--- a/src/video_core/shader/decode/image.cpp
+++ b/src/video_core/shader/decode/image.cpp
@@ -485,11 +485,10 @@ u32 ShaderIR::DecodeImage(NodeBlock& bb, u32 pc) {
485Image& ShaderIR::GetImage(Tegra::Shader::Image image, Tegra::Shader::ImageType type) { 485Image& ShaderIR::GetImage(Tegra::Shader::Image image, Tegra::Shader::ImageType type) {
486 const auto offset = static_cast<u32>(image.index.Value()); 486 const auto offset = static_cast<u32>(image.index.Value());
487 487
488 const auto it = 488 const auto it = std::find_if(std::begin(used_images), std::end(used_images),
489 std::find_if(std::begin(used_images), std::end(used_images), 489 [offset](const Image& entry) { return entry.offset == offset; });
490 [offset](const Image& entry) { return entry.GetOffset() == offset; });
491 if (it != std::end(used_images)) { 490 if (it != std::end(used_images)) {
492 ASSERT(!it->IsBindless() && it->GetType() == it->GetType()); 491 ASSERT(!it->is_bindless && it->type == type);
493 return *it; 492 return *it;
494 } 493 }
495 494
@@ -505,13 +504,12 @@ Image& ShaderIR::GetBindlessImage(Tegra::Shader::Register reg, Tegra::Shader::Im
505 const auto buffer = std::get<1>(result); 504 const auto buffer = std::get<1>(result);
506 const auto offset = std::get<2>(result); 505 const auto offset = std::get<2>(result);
507 506
508 const auto it = 507 const auto it = std::find_if(std::begin(used_images), std::end(used_images),
509 std::find_if(std::begin(used_images), std::end(used_images), 508 [buffer, offset](const Image& entry) {
510 [buffer = buffer, offset = offset](const Image& entry) { 509 return entry.buffer == buffer && entry.offset == offset;
511 return entry.GetBuffer() == buffer && entry.GetOffset() == offset; 510 });
512 });
513 if (it != std::end(used_images)) { 511 if (it != std::end(used_images)) {
514 ASSERT(it->IsBindless() && it->GetType() == it->GetType()); 512 ASSERT(it->is_bindless && it->type == type);
515 return *it; 513 return *it;
516 } 514 }
517 515
diff --git a/src/video_core/shader/decode/texture.cpp b/src/video_core/shader/decode/texture.cpp
index e68f1d305..8f0bb996e 100644
--- a/src/video_core/shader/decode/texture.cpp
+++ b/src/video_core/shader/decode/texture.cpp
@@ -139,15 +139,15 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
139 } 139 }
140 const Node component = Immediate(static_cast<u32>(instr.tld4s.component)); 140 const Node component = Immediate(static_cast<u32>(instr.tld4s.component));
141 141
142 const SamplerInfo info{TextureType::Texture2D, false, is_depth_compare, false}; 142 SamplerInfo info;
143 const Sampler& sampler = *GetSampler(instr.sampler, info); 143 info.is_shadow = is_depth_compare;
144 const std::optional<Sampler> sampler = GetSampler(instr.sampler, info);
144 145
145 Node4 values; 146 Node4 values;
146 for (u32 element = 0; element < values.size(); ++element) { 147 for (u32 element = 0; element < values.size(); ++element) {
147 auto coords_copy = coords; 148 MetaTexture meta{*sampler, {}, depth_compare, aoffi, {}, {},
148 MetaTexture meta{sampler, {}, depth_compare, aoffi, {}, {}, 149 {}, {}, component, element, {}};
149 {}, {}, component, element, {}}; 150 values[element] = Operation(OperationCode::TextureGather, meta, coords);
150 values[element] = Operation(OperationCode::TextureGather, meta, std::move(coords_copy));
151 } 151 }
152 152
153 if (instr.tld4s.fp16_flag) { 153 if (instr.tld4s.fp16_flag) {
@@ -165,18 +165,20 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
165 "AOFFI is not implemented"); 165 "AOFFI is not implemented");
166 166
167 const bool is_array = instr.txd.is_array != 0; 167 const bool is_array = instr.txd.is_array != 0;
168 u64 base_reg = instr.gpr8.Value();
169 const auto derivate_reg = instr.gpr20.Value(); 168 const auto derivate_reg = instr.gpr20.Value();
170 const auto texture_type = instr.txd.texture_type.Value(); 169 const auto texture_type = instr.txd.texture_type.Value();
171 const auto coord_count = GetCoordCount(texture_type); 170 const auto coord_count = GetCoordCount(texture_type);
172 Node index_var{}; 171 u64 base_reg = instr.gpr8.Value();
173 const Sampler* sampler = 172 Node index_var;
174 is_bindless 173 SamplerInfo info;
175 ? GetBindlessSampler(base_reg, index_var, {{texture_type, is_array, false, false}}) 174 info.type = texture_type;
176 : GetSampler(instr.sampler, {{texture_type, is_array, false, false}}); 175 info.is_array = is_array;
176 const std::optional<Sampler> sampler = is_bindless
177 ? GetBindlessSampler(base_reg, info, index_var)
178 : GetSampler(instr.sampler, info);
177 Node4 values; 179 Node4 values;
178 if (sampler == nullptr) { 180 if (!sampler) {
179 std::generate(values.begin(), values.end(), [] { return Immediate(0); }); 181 std::generate(values.begin(), values.end(), [this] { return Immediate(0); });
180 WriteTexInstructionFloat(bb, instr, values); 182 WriteTexInstructionFloat(bb, instr, values);
181 break; 183 break;
182 } 184 }
@@ -214,14 +216,12 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
214 is_bindless = true; 216 is_bindless = true;
215 [[fallthrough]]; 217 [[fallthrough]];
216 case OpCode::Id::TXQ: { 218 case OpCode::Id::TXQ: {
217 // TODO: The new commits on the texture refactor, change the way samplers work. 219 Node index_var;
218 // Sadly, not all texture instructions specify the type of texture their sampler 220 const std::optional<Sampler> sampler = is_bindless
219 // uses. This must be fixed at a later instance. 221 ? GetBindlessSampler(instr.gpr8, {}, index_var)
220 Node index_var{}; 222 : GetSampler(instr.sampler, {});
221 const Sampler* sampler = 223
222 is_bindless ? GetBindlessSampler(instr.gpr8, index_var) : GetSampler(instr.sampler); 224 if (!sampler) {
223
224 if (sampler == nullptr) {
225 u32 indexer = 0; 225 u32 indexer = 0;
226 for (u32 element = 0; element < 4; ++element) { 226 for (u32 element = 0; element < 4; ++element) {
227 if (!instr.txq.IsComponentEnabled(element)) { 227 if (!instr.txq.IsComponentEnabled(element)) {
@@ -267,12 +267,17 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
267 UNIMPLEMENTED_IF_MSG(instr.tmml.UsesMiscMode(Tegra::Shader::TextureMiscMode::NDV), 267 UNIMPLEMENTED_IF_MSG(instr.tmml.UsesMiscMode(Tegra::Shader::TextureMiscMode::NDV),
268 "NDV is not implemented"); 268 "NDV is not implemented");
269 269
270 auto texture_type = instr.tmml.texture_type.Value(); 270 const auto texture_type = instr.tmml.texture_type.Value();
271 Node index_var{}; 271 const bool is_array = instr.tmml.array != 0;
272 const Sampler* sampler = 272 SamplerInfo info;
273 is_bindless ? GetBindlessSampler(instr.gpr20, index_var) : GetSampler(instr.sampler); 273 info.type = texture_type;
274 274 info.is_array = is_array;
275 if (sampler == nullptr) { 275 Node index_var;
276 const std::optional<Sampler> sampler =
277 is_bindless ? GetBindlessSampler(instr.gpr20, info, index_var)
278 : GetSampler(instr.sampler, info);
279
280 if (!sampler) {
276 u32 indexer = 0; 281 u32 indexer = 0;
277 for (u32 element = 0; element < 2; ++element) { 282 for (u32 element = 0; element < 2; ++element) {
278 if (!instr.tmml.IsComponentEnabled(element)) { 283 if (!instr.tmml.IsComponentEnabled(element)) {
@@ -299,12 +304,11 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
299 coords.push_back(GetRegister(instr.gpr8.Value() + 1)); 304 coords.push_back(GetRegister(instr.gpr8.Value() + 1));
300 break; 305 break;
301 default: 306 default:
302 UNIMPLEMENTED_MSG("Unhandled texture type {}", static_cast<u32>(texture_type)); 307 UNIMPLEMENTED_MSG("Unhandled texture type {}", static_cast<int>(texture_type));
303 308
304 // Fallback to interpreting as a 2D texture for now 309 // Fallback to interpreting as a 2D texture for now
305 coords.push_back(GetRegister(instr.gpr8.Value() + 0)); 310 coords.push_back(GetRegister(instr.gpr8.Value() + 0));
306 coords.push_back(GetRegister(instr.gpr8.Value() + 1)); 311 coords.push_back(GetRegister(instr.gpr8.Value() + 1));
307 texture_type = TextureType::Texture2D;
308 } 312 }
309 u32 indexer = 0; 313 u32 indexer = 0;
310 for (u32 element = 0; element < 2; ++element) { 314 for (u32 element = 0; element < 2; ++element) {
@@ -353,98 +357,103 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
353 return pc; 357 return pc;
354} 358}
355 359
356ShaderIR::SamplerInfo ShaderIR::GetSamplerInfo(std::optional<SamplerInfo> sampler_info, u32 offset, 360ShaderIR::SamplerInfo ShaderIR::GetSamplerInfo(SamplerInfo info, u32 offset,
357 std::optional<u32> buffer) { 361 std::optional<u32> buffer) {
358 if (sampler_info) { 362 if (info.IsComplete()) {
359 return *sampler_info; 363 return info;
360 } 364 }
361 const auto sampler = buffer ? registry.ObtainBindlessSampler(*buffer, offset) 365 const auto sampler = buffer ? registry.ObtainBindlessSampler(*buffer, offset)
362 : registry.ObtainBoundSampler(offset); 366 : registry.ObtainBoundSampler(offset);
363 if (!sampler) { 367 if (!sampler) {
364 LOG_WARNING(HW_GPU, "Unknown sampler info"); 368 LOG_WARNING(HW_GPU, "Unknown sampler info");
365 return SamplerInfo{TextureType::Texture2D, false, false, false}; 369 info.type = info.type.value_or(Tegra::Shader::TextureType::Texture2D);
366 } 370 info.is_array = info.is_array.value_or(false);
367 return SamplerInfo{sampler->texture_type, sampler->is_array != 0, sampler->is_shadow != 0, 371 info.is_shadow = info.is_shadow.value_or(false);
368 sampler->is_buffer != 0}; 372 info.is_buffer = info.is_buffer.value_or(false);
373 return info;
374 }
375 info.type = info.type.value_or(sampler->texture_type);
376 info.is_array = info.is_array.value_or(sampler->is_array != 0);
377 info.is_shadow = info.is_shadow.value_or(sampler->is_shadow != 0);
378 info.is_buffer = info.is_buffer.value_or(sampler->is_buffer != 0);
379 return info;
369} 380}
370 381
371const Sampler* ShaderIR::GetSampler(const Tegra::Shader::Sampler& sampler, 382std::optional<Sampler> ShaderIR::GetSampler(Tegra::Shader::Sampler sampler,
372 std::optional<SamplerInfo> sampler_info) { 383 SamplerInfo sampler_info) {
373 const auto offset = static_cast<u32>(sampler.index.Value()); 384 const auto offset = static_cast<u32>(sampler.index.Value());
374 const auto info = GetSamplerInfo(sampler_info, offset); 385 const auto info = GetSamplerInfo(sampler_info, offset);
375 386
376 // If this sampler has already been used, return the existing mapping. 387 // If this sampler has already been used, return the existing mapping.
377 const auto it = 388 const auto it = std::find_if(used_samplers.begin(), used_samplers.end(),
378 std::find_if(used_samplers.begin(), used_samplers.end(), 389 [offset](const Sampler& entry) { return entry.offset == offset; });
379 [offset](const Sampler& entry) { return entry.GetOffset() == offset; });
380 if (it != used_samplers.end()) { 390 if (it != used_samplers.end()) {
381 ASSERT(!it->IsBindless() && it->GetType() == info.type && it->IsArray() == info.is_array && 391 ASSERT(!it->is_bindless && it->type == info.type && it->is_array == info.is_array &&
382 it->IsShadow() == info.is_shadow && it->IsBuffer() == info.is_buffer); 392 it->is_shadow == info.is_shadow && it->is_buffer == info.is_buffer);
383 return &*it; 393 return *it;
384 } 394 }
385 395
386 // Otherwise create a new mapping for this sampler 396 // Otherwise create a new mapping for this sampler
387 const auto next_index = static_cast<u32>(used_samplers.size()); 397 const auto next_index = static_cast<u32>(used_samplers.size());
388 return &used_samplers.emplace_back(next_index, offset, info.type, info.is_array, info.is_shadow, 398 return used_samplers.emplace_back(next_index, offset, *info.type, *info.is_array,
389 info.is_buffer, false); 399 *info.is_shadow, *info.is_buffer, false);
390} 400}
391 401
392const Sampler* ShaderIR::GetBindlessSampler(Tegra::Shader::Register reg, Node& index_var, 402std::optional<Sampler> ShaderIR::GetBindlessSampler(Tegra::Shader::Register reg, SamplerInfo info,
393 std::optional<SamplerInfo> sampler_info) { 403 Node& index_var) {
394 const Node sampler_register = GetRegister(reg); 404 const Node sampler_register = GetRegister(reg);
395 const auto [base_node, tracked_sampler_info] = 405 const auto [base_node, tracked_sampler_info] =
396 TrackBindlessSampler(sampler_register, global_code, static_cast<s64>(global_code.size())); 406 TrackBindlessSampler(sampler_register, global_code, static_cast<s64>(global_code.size()));
397 ASSERT(base_node != nullptr); 407 ASSERT(base_node != nullptr);
398 if (base_node == nullptr) { 408 if (base_node == nullptr) {
399 return nullptr; 409 return std::nullopt;
400 } 410 }
401 411
402 if (const auto bindless_sampler_info = 412 if (const auto bindless_sampler_info =
403 std::get_if<BindlessSamplerNode>(&*tracked_sampler_info)) { 413 std::get_if<BindlessSamplerNode>(&*tracked_sampler_info)) {
404 const u32 buffer = bindless_sampler_info->GetIndex(); 414 const u32 buffer = bindless_sampler_info->GetIndex();
405 const u32 offset = bindless_sampler_info->GetOffset(); 415 const u32 offset = bindless_sampler_info->GetOffset();
406 const auto info = GetSamplerInfo(sampler_info, offset, buffer); 416 info = GetSamplerInfo(info, offset, buffer);
407 417
408 // If this sampler has already been used, return the existing mapping. 418 // If this sampler has already been used, return the existing mapping.
409 const auto it = 419 const auto it = std::find_if(used_samplers.begin(), used_samplers.end(),
410 std::find_if(used_samplers.begin(), used_samplers.end(), 420 [buffer = buffer, offset = offset](const Sampler& entry) {
411 [buffer = buffer, offset = offset](const Sampler& entry) { 421 return entry.buffer == buffer && entry.offset == offset;
412 return entry.GetBuffer() == buffer && entry.GetOffset() == offset; 422 });
413 });
414 if (it != used_samplers.end()) { 423 if (it != used_samplers.end()) {
415 ASSERT(it->IsBindless() && it->GetType() == info.type && 424 ASSERT(it->is_bindless && it->type == info.type && it->is_array == info.is_array &&
416 it->IsArray() == info.is_array && it->IsShadow() == info.is_shadow); 425 it->is_shadow == info.is_shadow);
417 return &*it; 426 return *it;
418 } 427 }
419 428
420 // Otherwise create a new mapping for this sampler 429 // Otherwise create a new mapping for this sampler
421 const auto next_index = static_cast<u32>(used_samplers.size()); 430 const auto next_index = static_cast<u32>(used_samplers.size());
422 return &used_samplers.emplace_back(next_index, offset, buffer, info.type, info.is_array, 431 return used_samplers.emplace_back(next_index, offset, buffer, *info.type, *info.is_array,
423 info.is_shadow, info.is_buffer, false); 432 *info.is_shadow, *info.is_buffer, false);
424 } else if (const auto array_sampler_info = 433 }
425 std::get_if<ArraySamplerNode>(&*tracked_sampler_info)) { 434 if (const auto array_sampler_info = std::get_if<ArraySamplerNode>(&*tracked_sampler_info)) {
426 const u32 base_offset = array_sampler_info->GetBaseOffset() / 4; 435 const u32 base_offset = array_sampler_info->GetBaseOffset() / 4;
427 index_var = GetCustomVariable(array_sampler_info->GetIndexVar()); 436 index_var = GetCustomVariable(array_sampler_info->GetIndexVar());
428 const auto info = GetSamplerInfo(sampler_info, base_offset); 437 info = GetSamplerInfo(info, base_offset);
429 438
430 // If this sampler has already been used, return the existing mapping. 439 // If this sampler has already been used, return the existing mapping.
431 const auto it = std::find_if( 440 const auto it = std::find_if(
432 used_samplers.begin(), used_samplers.end(), 441 used_samplers.begin(), used_samplers.end(),
433 [base_offset](const Sampler& entry) { return entry.GetOffset() == base_offset; }); 442 [base_offset](const Sampler& entry) { return entry.offset == base_offset; });
434 if (it != used_samplers.end()) { 443 if (it != used_samplers.end()) {
435 ASSERT(!it->IsBindless() && it->GetType() == info.type && 444 ASSERT(!it->is_bindless && it->type == info.type && it->is_array == info.is_array &&
436 it->IsArray() == info.is_array && it->IsShadow() == info.is_shadow && 445 it->is_shadow == info.is_shadow && it->is_buffer == info.is_buffer &&
437 it->IsBuffer() == info.is_buffer && it->IsIndexed()); 446 it->is_indexed);
438 return &*it; 447 return *it;
439 } 448 }
440 449
441 uses_indexed_samplers = true; 450 uses_indexed_samplers = true;
442 // Otherwise create a new mapping for this sampler 451 // Otherwise create a new mapping for this sampler
443 const auto next_index = static_cast<u32>(used_samplers.size()); 452 const auto next_index = static_cast<u32>(used_samplers.size());
444 return &used_samplers.emplace_back(next_index, base_offset, info.type, info.is_array, 453 return used_samplers.emplace_back(next_index, base_offset, *info.type, *info.is_array,
445 info.is_shadow, info.is_buffer, true); 454 *info.is_shadow, *info.is_buffer, true);
446 } 455 }
447 return nullptr; 456 return std::nullopt;
448} 457}
449 458
450void ShaderIR::WriteTexInstructionFloat(NodeBlock& bb, Instruction instr, const Node4& components) { 459void ShaderIR::WriteTexInstructionFloat(NodeBlock& bb, Instruction instr, const Node4& components) {
@@ -529,10 +538,16 @@ Node4 ShaderIR::GetTextureCode(Instruction instr, TextureType texture_type,
529 ASSERT_MSG(texture_type != TextureType::Texture3D || !is_array || !is_shadow, 538 ASSERT_MSG(texture_type != TextureType::Texture3D || !is_array || !is_shadow,
530 "Illegal texture type"); 539 "Illegal texture type");
531 540
532 const SamplerInfo info{texture_type, is_array, is_shadow, false}; 541 SamplerInfo info;
542 info.type = texture_type;
543 info.is_array = is_array;
544 info.is_shadow = is_shadow;
545 info.is_buffer = false;
546
533 Node index_var; 547 Node index_var;
534 const Sampler* sampler = is_bindless ? GetBindlessSampler(*bindless_reg, index_var, info) 548 const std::optional<Sampler> sampler = is_bindless
535 : GetSampler(instr.sampler, info); 549 ? GetBindlessSampler(*bindless_reg, info, index_var)
550 : GetSampler(instr.sampler, info);
536 if (!sampler) { 551 if (!sampler) {
537 return {Immediate(0), Immediate(0), Immediate(0), Immediate(0)}; 552 return {Immediate(0), Immediate(0), Immediate(0), Immediate(0)};
538 } 553 }
@@ -683,12 +698,17 @@ Node4 ShaderIR::GetTld4Code(Instruction instr, TextureType texture_type, bool de
683 698
684 u64 parameter_register = instr.gpr20.Value(); 699 u64 parameter_register = instr.gpr20.Value();
685 700
686 const SamplerInfo info{texture_type, is_array, depth_compare, false}; 701 SamplerInfo info;
687 Node index_var{}; 702 info.type = texture_type;
688 const Sampler* sampler = is_bindless ? GetBindlessSampler(parameter_register++, index_var, info) 703 info.is_array = is_array;
689 : GetSampler(instr.sampler, info); 704 info.is_shadow = depth_compare;
705
706 Node index_var;
707 const std::optional<Sampler> sampler =
708 is_bindless ? GetBindlessSampler(parameter_register++, info, index_var)
709 : GetSampler(instr.sampler, info);
690 Node4 values; 710 Node4 values;
691 if (sampler == nullptr) { 711 if (!sampler) {
692 for (u32 element = 0; element < values.size(); ++element) { 712 for (u32 element = 0; element < values.size(); ++element) {
693 values[element] = Immediate(0); 713 values[element] = Immediate(0);
694 } 714 }
@@ -743,12 +763,12 @@ Node4 ShaderIR::GetTldCode(Tegra::Shader::Instruction instr) {
743 // const Node aoffi_register{is_aoffi ? GetRegister(gpr20_cursor++) : nullptr}; 763 // const Node aoffi_register{is_aoffi ? GetRegister(gpr20_cursor++) : nullptr};
744 // const Node multisample{is_multisample ? GetRegister(gpr20_cursor++) : nullptr}; 764 // const Node multisample{is_multisample ? GetRegister(gpr20_cursor++) : nullptr};
745 765
746 const auto& sampler = *GetSampler(instr.sampler); 766 const std::optional<Sampler> sampler = GetSampler(instr.sampler, {});
747 767
748 Node4 values; 768 Node4 values;
749 for (u32 element = 0; element < values.size(); ++element) { 769 for (u32 element = 0; element < values.size(); ++element) {
750 auto coords_copy = coords; 770 auto coords_copy = coords;
751 MetaTexture meta{sampler, array_register, {}, {}, {}, {}, {}, lod, {}, element, {}}; 771 MetaTexture meta{*sampler, array_register, {}, {}, {}, {}, {}, lod, {}, element, {}};
752 values[element] = Operation(OperationCode::TexelFetch, meta, std::move(coords_copy)); 772 values[element] = Operation(OperationCode::TexelFetch, meta, std::move(coords_copy));
753 } 773 }
754 774
@@ -756,7 +776,11 @@ Node4 ShaderIR::GetTldCode(Tegra::Shader::Instruction instr) {
756} 776}
757 777
758Node4 ShaderIR::GetTldsCode(Instruction instr, TextureType texture_type, bool is_array) { 778Node4 ShaderIR::GetTldsCode(Instruction instr, TextureType texture_type, bool is_array) {
759 const Sampler& sampler = *GetSampler(instr.sampler); 779 SamplerInfo info;
780 info.type = texture_type;
781 info.is_array = is_array;
782 info.is_shadow = false;
783 const std::optional<Sampler> sampler = GetSampler(instr.sampler, info);
760 784
761 const std::size_t type_coord_count = GetCoordCount(texture_type); 785 const std::size_t type_coord_count = GetCoordCount(texture_type);
762 const bool lod_enabled = instr.tlds.GetTextureProcessMode() == TextureProcessMode::LL; 786 const bool lod_enabled = instr.tlds.GetTextureProcessMode() == TextureProcessMode::LL;
@@ -784,7 +808,7 @@ Node4 ShaderIR::GetTldsCode(Instruction instr, TextureType texture_type, bool is
784 Node4 values; 808 Node4 values;
785 for (u32 element = 0; element < values.size(); ++element) { 809 for (u32 element = 0; element < values.size(); ++element) {
786 auto coords_copy = coords; 810 auto coords_copy = coords;
787 MetaTexture meta{sampler, array, {}, {}, {}, {}, {}, lod, {}, element, {}}; 811 MetaTexture meta{*sampler, array, {}, {}, {}, {}, {}, lod, {}, element, {}};
788 values[element] = Operation(OperationCode::TexelFetch, meta, std::move(coords_copy)); 812 values[element] = Operation(OperationCode::TexelFetch, meta, std::move(coords_copy));
789 } 813 }
790 return values; 814 return values;
diff --git a/src/video_core/shader/node.h b/src/video_core/shader/node.h
index 3f5a7bc7a..601c822d2 100644
--- a/src/video_core/shader/node.h
+++ b/src/video_core/shader/node.h
@@ -267,76 +267,30 @@ class ArraySamplerNode;
267using TrackSamplerData = std::variant<BindlessSamplerNode, ArraySamplerNode>; 267using TrackSamplerData = std::variant<BindlessSamplerNode, ArraySamplerNode>;
268using TrackSampler = std::shared_ptr<TrackSamplerData>; 268using TrackSampler = std::shared_ptr<TrackSamplerData>;
269 269
270class Sampler { 270struct Sampler {
271public: 271 /// Bound samplers constructor
272 /// This constructor is for bound samplers
273 constexpr explicit Sampler(u32 index, u32 offset, Tegra::Shader::TextureType type, 272 constexpr explicit Sampler(u32 index, u32 offset, Tegra::Shader::TextureType type,
274 bool is_array, bool is_shadow, bool is_buffer, bool is_indexed) 273 bool is_array, bool is_shadow, bool is_buffer, bool is_indexed)
275 : index{index}, offset{offset}, type{type}, is_array{is_array}, is_shadow{is_shadow}, 274 : index{index}, offset{offset}, type{type}, is_array{is_array}, is_shadow{is_shadow},
276 is_buffer{is_buffer}, is_indexed{is_indexed} {} 275 is_buffer{is_buffer}, is_indexed{is_indexed} {}
277 276
278 /// This constructor is for bindless samplers 277 /// Bindless samplers constructor
279 constexpr explicit Sampler(u32 index, u32 offset, u32 buffer, Tegra::Shader::TextureType type, 278 constexpr explicit Sampler(u32 index, u32 offset, u32 buffer, Tegra::Shader::TextureType type,
280 bool is_array, bool is_shadow, bool is_buffer, bool is_indexed) 279 bool is_array, bool is_shadow, bool is_buffer, bool is_indexed)
281 : index{index}, offset{offset}, buffer{buffer}, type{type}, is_array{is_array}, 280 : index{index}, offset{offset}, buffer{buffer}, type{type}, is_array{is_array},
282 is_shadow{is_shadow}, is_buffer{is_buffer}, is_bindless{true}, is_indexed{is_indexed} {} 281 is_shadow{is_shadow}, is_buffer{is_buffer}, is_bindless{true}, is_indexed{is_indexed} {}
283 282
284 constexpr u32 GetIndex() const { 283 u32 index = 0; ///< Emulated index given for the this sampler.
285 return index; 284 u32 offset = 0; ///< Offset in the const buffer from where the sampler is being read.
286 } 285 u32 buffer = 0; ///< Buffer where the bindless sampler is being read (unused on bound samplers).
287 286 u32 size = 1; ///< Size of the sampler.
288 constexpr u32 GetOffset() const {
289 return offset;
290 }
291
292 constexpr u32 GetBuffer() const {
293 return buffer;
294 }
295
296 constexpr Tegra::Shader::TextureType GetType() const {
297 return type;
298 }
299
300 constexpr bool IsArray() const {
301 return is_array;
302 }
303
304 constexpr bool IsShadow() const {
305 return is_shadow;
306 }
307
308 constexpr bool IsBuffer() const {
309 return is_buffer;
310 }
311
312 constexpr bool IsBindless() const {
313 return is_bindless;
314 }
315
316 constexpr bool IsIndexed() const {
317 return is_indexed;
318 }
319
320 constexpr u32 Size() const {
321 return size;
322 }
323
324 constexpr void SetSize(u32 new_size) {
325 size = new_size;
326 }
327
328private:
329 u32 index{}; ///< Emulated index given for the this sampler.
330 u32 offset{}; ///< Offset in the const buffer from where the sampler is being read.
331 u32 buffer{}; ///< Buffer where the bindless sampler is being read (unused on bound samplers).
332 u32 size{1}; ///< Size of the sampler.
333 287
334 Tegra::Shader::TextureType type{}; ///< The type used to sample this texture (Texture2D, etc) 288 Tegra::Shader::TextureType type{}; ///< The type used to sample this texture (Texture2D, etc)
335 bool is_array{}; ///< Whether the texture is being sampled as an array texture or not. 289 bool is_array = false; ///< Whether the texture is being sampled as an array texture or not.
336 bool is_shadow{}; ///< Whether the texture is being sampled as a depth texture or not. 290 bool is_shadow = false; ///< Whether the texture is being sampled as a depth texture or not.
337 bool is_buffer{}; ///< Whether the texture is a texture buffer without sampler. 291 bool is_buffer = false; ///< Whether the texture is a texture buffer without sampler.
338 bool is_bindless{}; ///< Whether this sampler belongs to a bindless texture or not. 292 bool is_bindless = false; ///< Whether this sampler belongs to a bindless texture or not.
339 bool is_indexed{}; ///< Whether this sampler is an indexed array of textures. 293 bool is_indexed = false; ///< Whether this sampler is an indexed array of textures.
340}; 294};
341 295
342/// Represents a tracked bindless sampler into a direct const buffer 296/// Represents a tracked bindless sampler into a direct const buffer
@@ -381,13 +335,13 @@ private:
381 u32 offset; 335 u32 offset;
382}; 336};
383 337
384class Image final { 338struct Image {
385public: 339public:
386 /// This constructor is for bound images 340 /// Bound images constructor
387 constexpr explicit Image(u32 index, u32 offset, Tegra::Shader::ImageType type) 341 constexpr explicit Image(u32 index, u32 offset, Tegra::Shader::ImageType type)
388 : index{index}, offset{offset}, type{type} {} 342 : index{index}, offset{offset}, type{type} {}
389 343
390 /// This constructor is for bindless samplers 344 /// Bindless samplers constructor
391 constexpr explicit Image(u32 index, u32 offset, u32 buffer, Tegra::Shader::ImageType type) 345 constexpr explicit Image(u32 index, u32 offset, u32 buffer, Tegra::Shader::ImageType type)
392 : index{index}, offset{offset}, buffer{buffer}, type{type}, is_bindless{true} {} 346 : index{index}, offset{offset}, buffer{buffer}, type{type}, is_bindless{true} {}
393 347
@@ -405,53 +359,20 @@ public:
405 is_atomic = true; 359 is_atomic = true;
406 } 360 }
407 361
408 constexpr u32 GetIndex() const { 362 u32 index = 0;
409 return index; 363 u32 offset = 0;
410 } 364 u32 buffer = 0;
411
412 constexpr u32 GetOffset() const {
413 return offset;
414 }
415
416 constexpr u32 GetBuffer() const {
417 return buffer;
418 }
419
420 constexpr Tegra::Shader::ImageType GetType() const {
421 return type;
422 }
423
424 constexpr bool IsBindless() const {
425 return is_bindless;
426 }
427
428 constexpr bool IsWritten() const {
429 return is_written;
430 }
431
432 constexpr bool IsRead() const {
433 return is_read;
434 }
435
436 constexpr bool IsAtomic() const {
437 return is_atomic;
438 }
439
440private:
441 u32 index{};
442 u32 offset{};
443 u32 buffer{};
444 365
445 Tegra::Shader::ImageType type{}; 366 Tegra::Shader::ImageType type{};
446 bool is_bindless{}; 367 bool is_bindless = false;
447 bool is_written{}; 368 bool is_written = false;
448 bool is_read{}; 369 bool is_read = false;
449 bool is_atomic{}; 370 bool is_atomic = false;
450}; 371};
451 372
452struct GlobalMemoryBase { 373struct GlobalMemoryBase {
453 u32 cbuf_index{}; 374 u32 cbuf_index = 0;
454 u32 cbuf_offset{}; 375 u32 cbuf_offset = 0;
455 376
456 bool operator<(const GlobalMemoryBase& rhs) const { 377 bool operator<(const GlobalMemoryBase& rhs) const {
457 return std::tie(cbuf_index, cbuf_offset) < std::tie(rhs.cbuf_index, rhs.cbuf_offset); 378 return std::tie(cbuf_index, cbuf_offset) < std::tie(rhs.cbuf_index, rhs.cbuf_offset);
@@ -465,7 +386,7 @@ struct MetaArithmetic {
465 386
466/// Parameters describing a texture sampler 387/// Parameters describing a texture sampler
467struct MetaTexture { 388struct MetaTexture {
468 const Sampler& sampler; 389 Sampler sampler;
469 Node array; 390 Node array;
470 Node depth_compare; 391 Node depth_compare;
471 std::vector<Node> aoffi; 392 std::vector<Node> aoffi;
diff --git a/src/video_core/shader/shader_ir.h b/src/video_core/shader/shader_ir.h
index 69de5e68b..15ae152f2 100644
--- a/src/video_core/shader/shader_ir.h
+++ b/src/video_core/shader/shader_ir.h
@@ -28,12 +28,11 @@ struct ShaderBlock;
28 28
29constexpr u32 MAX_PROGRAM_LENGTH = 0x1000; 29constexpr u32 MAX_PROGRAM_LENGTH = 0x1000;
30 30
31class ConstBuffer { 31struct ConstBuffer {
32public: 32 constexpr explicit ConstBuffer(u32 max_offset, bool is_indirect)
33 explicit ConstBuffer(u32 max_offset, bool is_indirect)
34 : max_offset{max_offset}, is_indirect{is_indirect} {} 33 : max_offset{max_offset}, is_indirect{is_indirect} {}
35 34
36 ConstBuffer() = default; 35 constexpr ConstBuffer() = default;
37 36
38 void MarkAsUsed(u64 offset) { 37 void MarkAsUsed(u64 offset) {
39 max_offset = std::max(max_offset, static_cast<u32>(offset)); 38 max_offset = std::max(max_offset, static_cast<u32>(offset));
@@ -56,8 +55,8 @@ public:
56 } 55 }
57 56
58private: 57private:
59 u32 max_offset{}; 58 u32 max_offset = 0;
60 bool is_indirect{}; 59 bool is_indirect = false;
61}; 60};
62 61
63struct GlobalMemoryUsage { 62struct GlobalMemoryUsage {
@@ -191,10 +190,14 @@ private:
191 friend class ASTDecoder; 190 friend class ASTDecoder;
192 191
193 struct SamplerInfo { 192 struct SamplerInfo {
194 Tegra::Shader::TextureType type; 193 std::optional<Tegra::Shader::TextureType> type;
195 bool is_array; 194 std::optional<bool> is_array;
196 bool is_shadow; 195 std::optional<bool> is_shadow;
197 bool is_buffer; 196 std::optional<bool> is_buffer;
197
198 constexpr bool IsComplete() const noexcept {
199 return type && is_array && is_shadow && is_buffer;
200 }
198 }; 201 };
199 202
200 void Decode(); 203 void Decode();
@@ -327,16 +330,15 @@ private:
327 OperationCode GetPredicateCombiner(Tegra::Shader::PredOperation operation); 330 OperationCode GetPredicateCombiner(Tegra::Shader::PredOperation operation);
328 331
329 /// Queries the missing sampler info from the execution context. 332 /// Queries the missing sampler info from the execution context.
330 SamplerInfo GetSamplerInfo(std::optional<SamplerInfo> sampler_info, u32 offset, 333 SamplerInfo GetSamplerInfo(SamplerInfo info, u32 offset,
331 std::optional<u32> buffer = std::nullopt); 334 std::optional<u32> buffer = std::nullopt);
332 335
333 /// Accesses a texture sampler 336 /// Accesses a texture sampler.
334 const Sampler* GetSampler(const Tegra::Shader::Sampler& sampler, 337 std::optional<Sampler> GetSampler(Tegra::Shader::Sampler sampler, SamplerInfo info);
335 std::optional<SamplerInfo> sampler_info = std::nullopt);
336 338
337 /// Accesses a texture sampler for a bindless texture. 339 /// Accesses a texture sampler for a bindless texture.
338 const Sampler* GetBindlessSampler(Tegra::Shader::Register reg, Node& index_var, 340 std::optional<Sampler> GetBindlessSampler(Tegra::Shader::Register reg, SamplerInfo info,
339 std::optional<SamplerInfo> sampler_info = std::nullopt); 341 Node& index_var);
340 342
341 /// Accesses an image. 343 /// Accesses an image.
342 Image& GetImage(Tegra::Shader::Image image, Tegra::Shader::ImageType type); 344 Image& GetImage(Tegra::Shader::Image image, Tegra::Shader::ImageType type);
diff --git a/src/video_core/texture_cache/surface_params.cpp b/src/video_core/texture_cache/surface_params.cpp
index 0de499946..884fabffe 100644
--- a/src/video_core/texture_cache/surface_params.cpp
+++ b/src/video_core/texture_cache/surface_params.cpp
@@ -81,7 +81,7 @@ SurfaceParams SurfaceParams::CreateForTexture(const FormatLookupTable& lookup_ta
81 params.pixel_format = lookup_table.GetPixelFormat( 81 params.pixel_format = lookup_table.GetPixelFormat(
82 tic.format, params.srgb_conversion, tic.r_type, tic.g_type, tic.b_type, tic.a_type); 82 tic.format, params.srgb_conversion, tic.r_type, tic.g_type, tic.b_type, tic.a_type);
83 params.type = GetFormatType(params.pixel_format); 83 params.type = GetFormatType(params.pixel_format);
84 if (entry.IsShadow() && params.type == SurfaceType::ColorTexture) { 84 if (entry.is_shadow && params.type == SurfaceType::ColorTexture) {
85 switch (params.pixel_format) { 85 switch (params.pixel_format) {
86 case PixelFormat::R16U: 86 case PixelFormat::R16U:
87 case PixelFormat::R16F: 87 case PixelFormat::R16F:
@@ -108,7 +108,7 @@ SurfaceParams SurfaceParams::CreateForTexture(const FormatLookupTable& lookup_ta
108 params.emulated_levels = 1; 108 params.emulated_levels = 1;
109 params.is_layered = false; 109 params.is_layered = false;
110 } else { 110 } else {
111 params.target = TextureTypeToSurfaceTarget(entry.GetType(), entry.IsArray()); 111 params.target = TextureTypeToSurfaceTarget(entry.type, entry.is_array);
112 params.width = tic.Width(); 112 params.width = tic.Width();
113 params.height = tic.Height(); 113 params.height = tic.Height();
114 params.depth = tic.Depth(); 114 params.depth = tic.Depth();
@@ -138,7 +138,7 @@ SurfaceParams SurfaceParams::CreateForImage(const FormatLookupTable& lookup_tabl
138 tic.format, params.srgb_conversion, tic.r_type, tic.g_type, tic.b_type, tic.a_type); 138 tic.format, params.srgb_conversion, tic.r_type, tic.g_type, tic.b_type, tic.a_type);
139 params.type = GetFormatType(params.pixel_format); 139 params.type = GetFormatType(params.pixel_format);
140 params.type = GetFormatType(params.pixel_format); 140 params.type = GetFormatType(params.pixel_format);
141 params.target = ImageTypeToSurfaceTarget(entry.GetType()); 141 params.target = ImageTypeToSurfaceTarget(entry.type);
142 // TODO: on 1DBuffer we should use the tic info. 142 // TODO: on 1DBuffer we should use the tic info.
143 if (tic.IsBuffer()) { 143 if (tic.IsBuffer()) {
144 params.target = SurfaceTarget::TextureBuffer; 144 params.target = SurfaceTarget::TextureBuffer;
@@ -248,12 +248,12 @@ SurfaceParams SurfaceParams::CreateForFermiCopySurface(
248 248
249VideoCore::Surface::SurfaceTarget SurfaceParams::ExpectedTarget( 249VideoCore::Surface::SurfaceTarget SurfaceParams::ExpectedTarget(
250 const VideoCommon::Shader::Sampler& entry) { 250 const VideoCommon::Shader::Sampler& entry) {
251 return TextureTypeToSurfaceTarget(entry.GetType(), entry.IsArray()); 251 return TextureTypeToSurfaceTarget(entry.type, entry.is_array);
252} 252}
253 253
254VideoCore::Surface::SurfaceTarget SurfaceParams::ExpectedTarget( 254VideoCore::Surface::SurfaceTarget SurfaceParams::ExpectedTarget(
255 const VideoCommon::Shader::Image& entry) { 255 const VideoCommon::Shader::Image& entry) {
256 return ImageTypeToSurfaceTarget(entry.GetType()); 256 return ImageTypeToSurfaceTarget(entry.type);
257} 257}
258 258
259bool SurfaceParams::IsLayered() const { 259bool SurfaceParams::IsLayered() const {
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index d2d2846e6..d6efc34b2 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1172,7 +1172,7 @@ private:
1172 /// Returns true the shader sampler entry is compatible with the TIC texture type. 1172 /// Returns true the shader sampler entry is compatible with the TIC texture type.
1173 static bool IsTypeCompatible(Tegra::Texture::TextureType tic_type, 1173 static bool IsTypeCompatible(Tegra::Texture::TextureType tic_type,
1174 const VideoCommon::Shader::Sampler& entry) { 1174 const VideoCommon::Shader::Sampler& entry) {
1175 const auto shader_type = entry.GetType(); 1175 const auto shader_type = entry.type;
1176 switch (tic_type) { 1176 switch (tic_type) {
1177 case Tegra::Texture::TextureType::Texture1D: 1177 case Tegra::Texture::TextureType::Texture1D:
1178 case Tegra::Texture::TextureType::Texture1DArray: 1178 case Tegra::Texture::TextureType::Texture1DArray:
@@ -1193,7 +1193,7 @@ private:
1193 if (shader_type == Tegra::Shader::TextureType::TextureCube) { 1193 if (shader_type == Tegra::Shader::TextureType::TextureCube) {
1194 return true; 1194 return true;
1195 } 1195 }
1196 return shader_type == Tegra::Shader::TextureType::Texture2D && entry.IsArray(); 1196 return shader_type == Tegra::Shader::TextureType::Texture2D && entry.is_array;
1197 } 1197 }
1198 UNREACHABLE(); 1198 UNREACHABLE();
1199 return true; 1199 return true;
HIC SVNT DRACONES