Binding model: EffectContext stub, BindingBlockLayout merge, vector_map optimizations

src/libs/common/hashing/Hash.hpp

@@ -107,4 +107,11 @@ namespace RR::Common
     {
         return ConstexprHash<DefaultHasher>(str, len);
     }
+
+    // Pass-through hasher for values that are already a hash.
+    // Avoids double-hashing when using HashType as a map key.
+    struct PrehashedHasher
+    {
+        size_t operator()(HashType val) const noexcept { return val; }
+    };
 }

src/libs/effect_library/EffectFormat.hpp

@@ -164,7 +164,7 @@ namespace RR::EffectLibrary
         struct Header
         {
             static constexpr uint32_t MAGIC = 0x4C584652;
-            static constexpr uint32_t VERSION = 1;
+            static constexpr uint32_t VERSION = 2;
             uint32_t magic;
             uint32_t version;
             uint32_t stringsSectionSize;
@@ -202,6 +202,7 @@ namespace RR::EffectLibrary
             GAPI::RasterizerDesc rasterizerDesc;
             GAPI::DepthStencilDesc depthStencilDesc;
             GAPI::ShaderStageMask shaderStages;
+            uint32_t rootBindingGroupIndex;
             // List of shader indexes based on shaderStages mask
         };
 

src/libs/effect_library/EffectLibrary.cpp

@@ -315,6 +315,7 @@ namespace RR::EffectLibrary
                 passDesc.rasterizerDesc = assetPassDesc.rasterizerDesc;
                 passDesc.depthStencilDesc = assetPassDesc.depthStencilDesc;
                 passDesc.blendDesc = assetPassDesc.blendDesc;
+                passDesc.rootBindingGroupIndex = assetPassDesc.rootBindingGroupIndex;
 
                 eastl::fixed_vector<GAPI::ShaderStage, eastl::to_underlying(GAPI::ShaderStage::Count), false> shaderStages;
 

src/libs/gapi/BindingGroupLayout.cpp

@@ -0,0 +1,37 @@
+#include "BindingGroupLayout.hpp"
+
+namespace RR::GAPI
+{
+    void BindingGroupLayout::InitReflection(const BindingGroupReflectionDesc& desc)
+    {
+        bindingSpace      = desc.bindingSpace;
+        uniformBufferSize = desc.uniformBufferSize;
+        uniformCbvSlot    = desc.uniformCbvSlot;
+
+        for (const auto& f : desc.fields)
+        {
+            const uint32_t index = static_cast<uint32_t>(fields.size());
+            fields.push_back(f);
+            fieldMap[f.nameHash] = index;
+        }
+
+        for (const auto& r : desc.resources)
+        {
+            const uint32_t index = static_cast<uint32_t>(resourceSlots.size());
+            resourceSlots.push_back(r);
+            resourceMap[r.nameHash] = index;
+        }
+    }
+
+    uint32_t BindingGroupLayout::FindFieldIndex(Common::HashType nameHash) const
+    {
+        const auto it = fieldMap.find(nameHash);
+        return it != fieldMap.end() ? it->second : INVALID_SLOT;
+    }
+
+    uint32_t BindingGroupLayout::FindResourceSlotIndex(Common::HashType nameHash) const
+    {
+        const auto it = resourceMap.find(nameHash);
+        return it != resourceMap.end() ? it->second : INVALID_SLOT;
+    }
+}

src/libs/gapi/BindingGroupLayout.hpp

@@ -5,7 +5,11 @@
 #include "gapi/Shader.hpp"
 #include "gapi/Limits.hpp"
 
+#include "common/hashing/Hash.hpp"
+
+#include <EASTL/fixed_vector.h>
 #include <EASTL/span.h>
+#include <EASTL/vector_map.h>
 
 namespace RR::GAPI
 {
@@ -37,6 +41,32 @@ namespace RR::GAPI
         eastl::span<const BindingLayoutElement> elements;
     };
 
+    // Reflection: a single uniform field within a CBV
+    struct FieldDesc
+    {
+        Common::HashType nameHash;
+        uint16_t         offset; // byte offset in uniform buffer
+        uint16_t         size;   // byte size of field
+    };
+
+    // Reflection: a single resource slot (SRV, UAV, sampler)
+    struct ResourceSlotDesc
+    {
+        Common::HashType nameHash;
+        uint16_t         binding;   // binding index in bind group
+        uint16_t         slotIndex; // dense index in EffectContext::resources[]
+        BindingType      type;
+    };
+
+    struct BindingGroupReflectionDesc
+    {
+        uint32_t                            bindingSpace      = 0;
+        eastl::span<const FieldDesc>        fields;
+        eastl::span<const ResourceSlotDesc> resources;
+        uint32_t                            uniformBufferSize = 0;
+        uint32_t                            uniformCbvSlot    = ~0u;
+    };
+
     class IBindingGroupLayout
     {
     public:
@@ -46,12 +76,57 @@ namespace RR::GAPI
     class BindingGroupLayout final : public Resource<IBindingGroupLayout, true>
     {
     public:
+        static constexpr uint32_t INVALID_SLOT = ~0u;
+
         BindingGroupLayout(const std::string& name)
             : Resource(Type::BindingGroupLayout, name)
         {
         }
-    };
 
+        // Populate reflection metadata (call after GPU init).
+        void InitReflection(const BindingGroupReflectionDesc& desc);
 
-}
+        uint32_t GetBindingSpace() const { return bindingSpace; }
+        uint32_t GetUniformBufferSize() const { return uniformBufferSize; }
+        uint32_t GetUniformCbvSlot() const { return uniformCbvSlot; }
 
+        uint32_t GetFieldCount() const { return static_cast<uint32_t>(fields.size()); }
+        const FieldDesc& GetField(uint32_t index) const
+        {
+            ASSERT(index < fields.size());
+            return fields[index];
+        }
+
+        uint32_t GetResourceSlotCount() const { return static_cast<uint32_t>(resourceSlots.size()); }
+        const ResourceSlotDesc& GetResourceSlot(uint32_t index) const
+        {
+            ASSERT(index < resourceSlots.size());
+            return resourceSlots[index];
+        }
+
+        // O(log n) lookup by precomputed name hash. Cache the index for hot paths.
+        uint32_t FindFieldIndex(Common::HashType nameHash) const;
+        uint32_t FindResourceSlotIndex(Common::HashType nameHash) const;
+
+    private:
+        using HashToIndex = eastl::pair<Common::HashType, uint32_t>;
+
+        template <size_t N, bool Overflow = true>
+        using Lookup = eastl::vector_map<
+            Common::HashType, uint32_t,
+            eastl::less<Common::HashType>,
+            EASTLAllocatorType,
+            eastl::fixed_vector<HashToIndex, N, Overflow>>;
+
+        uint32_t bindingSpace      = 0;
+        uint32_t uniformBufferSize = 0;
+        uint32_t uniformCbvSlot    = INVALID_SLOT;
+
+        eastl::fixed_vector<FieldDesc, 16, true>                             fields;
+        eastl::fixed_vector<ResourceSlotDesc, MAX_BINDINGS_PER_GROUP, false> resourceSlots;
+
+        Lookup<16>                    fieldMap;    // nameHash -> field index
+        Lookup<MAX_BINDINGS_PER_GROUP, false> resourceMap; // nameHash -> slot index
+    };
+
+}

src/libs/gapi/CMakeLists.txt

@@ -3,6 +3,7 @@ project (gapi)
 set(SRC
     Buffer.cpp
     Buffer.hpp
+    BindingGroupLayout.cpp
     BindingGroupLayout.hpp
     BindingGroup.hpp
     CommandList.hpp

src/libs/render/CMakeLists.txt

@@ -11,10 +11,9 @@ set(SRC
     RenderTarget.cpp
     Effect.hpp
     Effect.cpp
+    EffectContext.hpp
     EffectManager.cpp
     EffectManager.hpp
-    BindingBlockLayout.cpp
-    BindingBlockLayout.hpp
     Submission.cpp
     Submission.hpp
 )

src/libs/render/CommandEncoder.hpp

@@ -6,6 +6,7 @@
 
 #include "math/ForwardDeclarations.hpp"
 #include "render/Effect.hpp"
+#include "render/EffectContext.hpp"
 #include "common/NonCopyableMovable.hpp"
 
 namespace RR::Render
@@ -18,6 +19,8 @@ namespace RR::Render
     public:
         RenderPassEncoder BeginRenderPass(const GAPI::RenderPassDesc& renderPass);
 
+        EffectContext CreateEffectContext(Effect* effect) { return EffectContext(effect); }
+
         void Finish()
         {
             ASSERT_MSG(state == State::Open, "CommandEncoder was not started");