Unify both sampler types.

src/video_core/renderer_opengl/gl_shader_decompiler.h

@@ -58,6 +58,7 @@ private:
 struct ShaderEntries {
     std::vector<ConstBufferEntry> const_buffers;
     std::vector<SamplerEntry> samplers;
+    std::vector<SamplerEntry> bindless_samplers;
     std::vector<GlobalMemoryEntry> global_memory_entries;
     std::array<bool, Maxwell::NumClipDistances> clip_distances{};
     std::size_t shader_length{};

src/video_core/renderer_opengl/gl_shader_disk_cache.cpp

@@ -319,16 +319,18 @@ std::optional<ShaderDiskCacheDecompiled> ShaderDiskCacheOpenGL::LoadDecompiledEn
         u32 type{};
         u8 is_array{};
         u8 is_shadow{};
+        u8 is_bindless{};
         if (file.ReadBytes(&offset, sizeof(u64)) != sizeof(u64) ||
             file.ReadBytes(&index, sizeof(u64)) != sizeof(u64) ||
             file.ReadBytes(&type, sizeof(u32)) != sizeof(u32) ||
             file.ReadBytes(&is_array, sizeof(u8)) != sizeof(u8) ||
-            file.ReadBytes(&is_shadow, sizeof(u8)) != sizeof(u8)) {
+            file.ReadBytes(&is_shadow, sizeof(u8)) != sizeof(u8) ||
+            file.ReadBytes(&is_bindless, sizeof(u8)) != sizeof(u8)) {
             return {};
         }
         entry.entries.samplers.emplace_back(
             static_cast<std::size_t>(offset), static_cast<std::size_t>(index),
-            static_cast<Tegra::Shader::TextureType>(type), is_array != 0, is_shadow != 0, false);
+            static_cast<Tegra::Shader::TextureType>(type), is_array != 0, is_shadow != 0, is_bindless != 0);
     }
 
     u32 global_memory_count{};
@@ -388,7 +390,8 @@ bool ShaderDiskCacheOpenGL::SaveDecompiledFile(FileUtil::IOFile& file, u64 uniqu
             file.WriteObject(static_cast<u64>(sampler.GetIndex())) != 1 ||
             file.WriteObject(static_cast<u32>(sampler.GetType())) != 1 ||
             file.WriteObject(static_cast<u8>(sampler.IsArray() ? 1 : 0)) != 1 ||
-            file.WriteObject(static_cast<u8>(sampler.IsShadow() ? 1 : 0)) != 1) {
+            file.WriteObject(static_cast<u8>(sampler.IsShadow() ? 1 : 0)) != 1 ||
+            file.WriteObject(static_cast<u8>(sampler.IsBindless() ? 1 : 0)) != 1) {
             return false;
         }
     }

src/video_core/shader/decode/texture.cpp

@@ -267,7 +267,7 @@ const Sampler& ShaderIR::GetSampler(const Tegra::Shader::Sampler& sampler, Textu
 
     // Otherwise create a new mapping for this sampler
     const std::size_t next_index = used_samplers.size();
-    const Sampler entry{offset, next_index, type, is_array, is_shadow, false};
+    const Sampler entry{offset, next_index, type, is_array, is_shadow};
     return *used_samplers.emplace(entry).first;
 }
 
@@ -281,20 +281,22 @@ const Sampler& ShaderIR::GetBindlessSampler(const Tegra::Shader::Register& reg,
     ASSERT(cbuf_offset_imm != nullptr);
     const auto cbuf_offset = cbuf_offset_imm->GetValue();
     const auto cbuf_index = cbuf->GetIndex();
-    const std::pair<u32, u32> cbuf_pair = {cbuf_index, cbuf_offset};
+    const u64 cbuf_key = (cbuf_index << 32) | cbuf_offset;
 
     // If this sampler has already been used, return the existing mapping.
-    if (used_bindless_samplers.count(cbuf_pair) > 0) {
+    const auto itr =
-        const auto& sampler = used_bindless_samplers[cbuf_pair];
+        std::find_if(used_samplers.begin(), used_samplers.end(),
-        ASSERT(sampler.GetType() == type && sampler.IsArray() == is_array &&
+                     [&](const Sampler& entry) { return entry.GetOffset() == cbuf_key; });
-               sampler.IsShadow() == is_shadow);
+    if (itr != used_samplers.end()) {
-        return sampler;
+        ASSERT(itr->GetType() == type && itr->IsArray() == is_array &&
+               itr->IsShadow() == is_shadow);
+        return *itr;
     }
 
     // Otherwise create a new mapping for this sampler
-    const std::size_t next_index = used_bindless_samplers.size();
+    const std::size_t next_index = used_samplers.size();
-    const Sampler entry{0, next_index, type, is_array, is_shadow, true};
+    const Sampler entry{cbuf_index, cbuf_offset, next_index, type, is_array, is_shadow};
-    return (*used_bindless_samplers.emplace(std::make_pair(cbuf_pair, entry)).first).second;
+    return *used_samplers.emplace(entry).first;
 }
 
 void ShaderIR::WriteTexInstructionFloat(NodeBlock& bb, Instruction instr, const Node4& components) {

src/video_core/shader/shader_ir.h

@@ -196,12 +196,24 @@ enum class ExitMethod {
 
 class Sampler {
 public:
-    Sampler() = default;
+    // Use this constructor for binded Samplers
+    explicit Sampler(std::size_t offset, std::size_t index, Tegra::Shader::TextureType type,
+                     bool is_array, bool is_shadow)
+        : offset{offset}, index{index}, type{type}, is_array{is_array}, is_shadow{is_shadow},
+          is_bindless{false} {}
+
+    // Use this constructor for bindless Samplers
+    explicit Sampler(u32 cbuf_index, u32 cbuf_offset, std::size_t index,
+                     Tegra::Shader::TextureType type, bool is_array, bool is_shadow)
+        : offset{(static_cast<u64>(cbuf_index) << 32) | cbuf_offset}, index{index}, type{type}, is_array{is_array},
+          is_shadow{is_shadow}, is_bindless{true} {}
+
+    // Use this only for serialization/deserialization
     explicit Sampler(std::size_t offset, std::size_t index, Tegra::Shader::TextureType type,
                      bool is_array, bool is_shadow, bool is_bindless)
-        : offset{offset}, index{index}, type{type}, is_array{is_array}, is_shadow{is_shadow}, is_bindless{is_bindless} {}
+        : offset{offset}, index{index}, type{type}, is_array{is_array}, is_shadow{is_shadow},
+          is_bindless{is_bindless} {}
 
-    ~Sampler() = default;
 
     std::size_t GetOffset() const {
         return offset;
@@ -223,6 +235,14 @@ public:
         return is_shadow;
     }
 
+    bool IsBindless() const {
+        return is_bindless;
+    }
+
+    std::pair<u32, u32> GetBindlessCBuf() {
+        return {offset >> 32, offset & 0x00000000FFFFFFFFULL};
+    }
+
     bool operator<(const Sampler& rhs) const {
         return std::tie(offset, index, type, is_array, is_shadow) <
                std::tie(rhs.offset, rhs.index, rhs.type, rhs.is_array, rhs.is_shadow);
@@ -735,8 +755,9 @@ private:
                               Tegra::Shader::TextureType type, bool is_array, bool is_shadow);
 
     // Accesses a texture sampler for a bindless texture.
-    const Sampler& GetBindlessSampler(const Tegra::Shader::Register& reg, Tegra::Shader::TextureType type,
+    const Sampler& GetBindlessSampler(const Tegra::Shader::Register& reg,
-                                      bool is_array, bool is_shadow);
+                                      Tegra::Shader::TextureType type, bool is_array,
+                                      bool is_shadow);
 
     /// Extracts a sequence of bits from a node
     Node BitfieldExtract(Node value, u32 offset, u32 bits);
@@ -845,7 +866,6 @@ private:
     std::set<Tegra::Shader::Attribute::Index> used_output_attributes;
     std::map<u32, ConstBuffer> used_cbufs;
     std::set<Sampler> used_samplers;
-    std::map<std::pair<u32, u32>, Sampler> used_bindless_samplers;
     std::array<bool, Tegra::Engines::Maxwell3D::Regs::NumClipDistances> used_clip_distances{};
     std::set<GlobalMemoryBase> used_global_memory_bases;