Added dedicated maxStateSlot and maxViewSlot numbers to enable individual sizing of the State::stateStacks and viewStateStacks.

robertosfield · robertosfield · commit d86f2563de45 · 2025-03-07T14:39:07.000Z
diff --git a/include/vsg/app/CommandGraph.h b/include/vsg/app/CommandGraph.h
@@ -39,7 +39,8 @@ namespace vsg
 
         int queueFamily = -1;
         int presentFamily = -1;
-        uint32_t maxSlot = 2;
+        uint32_t maxStateSlot = 0;
+        uint32_t maxViewSlot = 0;
         int submitOrder = 0;
 
         ref_ptr<RecordTraversal> getOrCreateRecordTraversal();
diff --git a/include/vsg/app/CompileManager.h b/include/vsg/app/CompileManager.h
@@ -27,7 +27,8 @@ namespace vsg
     {
         int result = VK_INCOMPLETE;
         std::string message;
-        uint32_t maxSlot = 0;
+        uint32_t maxStateSlot = 0;
+        uint32_t maxViewSlot = 0;
         bool containsPagedLOD = false;
         ResourceRequirements::Views views;
         ResourceRequirements::DynamicData dynamicData;
diff --git a/include/vsg/app/RecordTraversal.h b/include/vsg/app/RecordTraversal.h
@@ -69,7 +69,7 @@ namespace vsg
     class VSG_DECLSPEC RecordTraversal : public Object
     {
     public:
-        explicit RecordTraversal(uint32_t in_maxSlot = 2, const std::set<Bin*>& in_bins = {});
+        explicit RecordTraversal(uint32_t in_maxStateSlot = 2, uint32_t in_maxViewSlot = 8, const std::set<Bin*>& in_bins = {}); // TODO
 
         RecordTraversal(const RecordTraversal&) = delete;
         RecordTraversal& operator=(const RecordTraversal& rhs) = delete;
diff --git a/include/vsg/state/ResourceHints.h b/include/vsg/state/ResourceHints.h
@@ -30,9 +30,10 @@ namespace vsg
     public:
         ResourceHints();
 
-        bool empty() const noexcept { return maxSlot == 0 && numDescriptorSets == 0 && descriptorPoolSizes.empty(); }
+        bool empty() const noexcept { return maxStateSlot == 0 && maxViewSlot == 0 && numDescriptorSets == 0 && descriptorPoolSizes.empty(); }
 
-        uint32_t maxSlot = 0;
+        uint32_t maxStateSlot = 0;
+        uint32_t maxViewSlot = 0;
         uint32_t numDescriptorSets = 0;
         DescriptorPoolSizes descriptorPoolSizes;
 
diff --git a/include/vsg/vk/ResourceRequirements.h b/include/vsg/vk/ResourceRequirements.h
@@ -88,7 +88,8 @@ namespace vsg
         Views views;
         ViewDetailStack viewDetailsStack;
 
-        uint32_t maxSlot = 0;
+        uint32_t maxStateSlot = 0;
+        uint32_t maxViewSlot = 0;
         uint32_t externalNumDescriptorSets = 0;
         bool containsPagedLOD = false;
 
diff --git a/include/vsg/vk/State.h b/include/vsg/vk/State.h
@@ -228,7 +228,7 @@ namespace vsg
     class State : public Inherit<Object, State>
     {
     public:
-        explicit State(uint32_t maxSlot);
+        explicit State(uint32_t maxStateSlot, uint32_t maxViewSlot);
 
         using StateCommandStack = StateStack<StateCommand>;
         using StateStacks = std::vector<StateCommandStack>;
@@ -254,7 +254,7 @@ namespace vsg
         MatrixStack projectionMatrixStack{0};
         MatrixStack modelviewMatrixStack{64};
 
-        void reserve(uint32_t maxSlot);
+        void reserve(uint32_t maxStateSlot, uint32_t maxViewSlot);
 
         void setInhertiedViewProjectionAndViewMatrix(const dmat4& projMatrix, const dmat4& viewMatrix)
         {
diff --git a/src/vsg/app/CommandGraph.cpp b/src/vsg/app/CommandGraph.cpp
@@ -66,9 +66,9 @@ ref_ptr<RecordTraversal> CommandGraph::getOrCreateRecordTraversal()
 {
     //CPU_INSTRUMENTATION_L1(instrumentation);
     if (!recordTraversal)
-        recordTraversal = RecordTraversal::create(maxSlot);
+        recordTraversal = RecordTraversal::create(maxStateSlot, maxViewSlot);
     else
-        recordTraversal->getState()->reserve(maxSlot);
+        recordTraversal->getState()->reserve(maxStateSlot, maxViewSlot);
 
     return recordTraversal;
 }
diff --git a/src/vsg/app/CompileManager.cpp b/src/vsg/app/CompileManager.cpp
@@ -24,7 +24,8 @@ using namespace vsg;
 void CompileResult::reset()
 {
     result = VK_INCOMPLETE;
-    maxSlot = 0;
+    maxStateSlot = 0;
+    maxViewSlot = 0;
     containsPagedLOD = false;
     views.clear();
     dynamicData.clear();
@@ -37,7 +38,8 @@ void CompileResult::add(const CompileResult& cr)
         result = cr.result;
     }
 
-    if (cr.maxSlot > maxSlot) maxSlot = cr.maxSlot;
+    if (cr.maxStateSlot > maxStateSlot) maxStateSlot = cr.maxStateSlot;
+    if (cr.maxViewSlot > maxViewSlot) maxViewSlot = cr.maxViewSlot;
     if (!containsPagedLOD) containsPagedLOD = cr.containsPagedLOD;
 
     for (auto& [src_view, src_binDetails] : cr.views)
@@ -175,7 +177,8 @@ CompileResult CompileManager::compile(ref_ptr<Object> object, ContextSelectionFu
     auto& viewDetailsStack = requirements.viewDetailsStack;
 
     CompileResult result;
-    result.maxSlot = requirements.maxSlot;
+    result.maxStateSlot = requirements.maxStateSlot;
+    result.maxViewSlot = requirements.maxViewSlot;
     result.containsPagedLOD = requirements.containsPagedLOD;
     result.views = requirements.views;
     result.dynamicData = requirements.dynamicData;
diff --git a/src/vsg/app/CompileTraversal.cpp b/src/vsg/app/CompileTraversal.cpp
@@ -323,10 +323,8 @@ void CompileTraversal::apply(CommandGraph& commandGraph)
 
     for (const auto& context : contexts)
     {
-        if (context->resourceRequirements.maxSlot > commandGraph.maxSlot)
-        {
-            commandGraph.maxSlot = context->resourceRequirements.maxSlot;
-        }
+        if (context->resourceRequirements.maxStateSlot > commandGraph.maxStateSlot) commandGraph.maxStateSlot = context->resourceRequirements.maxStateSlot;
+        if (context->resourceRequirements.maxViewSlot > commandGraph.maxViewSlot) commandGraph.maxViewSlot = context->resourceRequirements.maxViewSlot;
     }
 
     commandGraph.traverse(*this);
@@ -340,10 +338,8 @@ void CompileTraversal::apply(SecondaryCommandGraph& secondaryCommandGraph)
 
     for (auto& context : contexts)
     {
-        if (context->resourceRequirements.maxSlot > secondaryCommandGraph.maxSlot)
-        {
-            secondaryCommandGraph.maxSlot = context->resourceRequirements.maxSlot;
-        }
+        if (context->resourceRequirements.maxStateSlot > secondaryCommandGraph.maxStateSlot) secondaryCommandGraph.maxStateSlot = context->resourceRequirements.maxStateSlot;
+        if (context->resourceRequirements.maxViewSlot > secondaryCommandGraph.maxViewSlot) secondaryCommandGraph.maxViewSlot = context->resourceRequirements.maxViewSlot;
 
         // save previous states to be restored after traversal
         auto previousRenderPass = context->renderPass;
diff --git a/src/vsg/app/RecordAndSubmitTask.cpp b/src/vsg/app/RecordAndSubmitTask.cpp
@@ -298,10 +298,8 @@ void vsg::updateTasks(RecordAndSubmitTasks& tasks, ref_ptr<CompileManager> compi
     {
         for (const auto& commandGraph : task->commandGraphs)
         {
-            if (compileResult.maxSlot > commandGraph->maxSlot)
-            {
-                commandGraph->maxSlot = compileResult.maxSlot;
-            }
+            if (compileResult.maxStateSlot > commandGraph->maxStateSlot) commandGraph->maxStateSlot = compileResult.maxStateSlot;
+            if (compileResult.maxViewSlot > commandGraph->maxViewSlot) commandGraph->maxViewSlot = compileResult.maxViewSlot;
         }
     }
 
diff --git a/src/vsg/app/RecordTraversal.cpp b/src/vsg/app/RecordTraversal.cpp
@@ -56,8 +56,8 @@ using namespace vsg;
 
 #define INLINE_TRAVERSE 0
 
-RecordTraversal::RecordTraversal(uint32_t in_maxSlot, const std::set<Bin*>& in_bins) :
-    _state(new State(in_maxSlot))
+RecordTraversal::RecordTraversal(uint32_t in_maxStateSlot, uint32_t in_maxViewSlot, const std::set<Bin*>& in_bins) :
+    _state(new State(in_maxStateSlot, in_maxViewSlot))
 {
     CPU_INSTRUMENTATION_L1_C(instrumentation, COLOR_RECORD);
 
diff --git a/src/vsg/app/SecondaryCommandGraph.cpp b/src/vsg/app/SecondaryCommandGraph.cpp
@@ -81,10 +81,8 @@ void SecondaryCommandGraph::record(ref_ptr<RecordedCommandBuffers> recordedComma
         return;
     }
 
-    if (!recordTraversal)
-        recordTraversal = RecordTraversal::create(maxSlot);
-    else
-        recordTraversal->getState()->reserve(maxSlot);
+    // create the RecordTraversal if it isn't already created
+    getOrCreateRecordTraversal();
 
     recordTraversal->recordedCommandBuffers = recordedCommandBuffers;
     recordTraversal->setFrameStamp(frameStamp);
diff --git a/src/vsg/app/Viewer.cpp b/src/vsg/app/Viewer.cpp
@@ -361,7 +361,8 @@ void Viewer::compile(ref_ptr<ResourceHints> hints)
 
         for (const auto& commandGraph : task->commandGraphs)
         {
-            commandGraph->maxSlot = resourceRequirements.maxSlot;
+            commandGraph->maxStateSlot = resourceRequirements.maxStateSlot;
+            commandGraph->maxViewSlot = resourceRequirements.maxViewSlot;
             if (resourceRequirements.containsPagedLOD) task_containsPagedLOD = true;
         }
 
diff --git a/src/vsg/state/ResourceHints.cpp b/src/vsg/state/ResourceHints.cpp
@@ -26,7 +26,16 @@ void ResourceHints::read(Input& input)
 {
     Object::read(input);
 
-    input.read("maxSlot", maxSlot);
+    if (input.version_greater_equal(1, 1, 11))
+    {
+        input.read("maxStateSlot", maxStateSlot);
+        input.read("maxViewSlot", maxViewSlot);
+    }
+    else
+    {
+        input.read("maxSlot", maxStateSlot);
+    }
+
     input.read("numDescriptorSets", numDescriptorSets);
 
     if (input.version_greater_equal(0, 7, 3))
@@ -66,7 +75,16 @@ void ResourceHints::write(Output& output) const
 {
     Object::write(output);
 
-    output.write("maxSlot", maxSlot);
+    if (output.version_greater_equal(1, 1, 11))
+    {
+        output.write("maxStateSlot", maxStateSlot);
+        output.write("maxViewSlot", maxViewSlot);
+    }
+    else
+    {
+        output.write("maxSlot", maxStateSlot);
+    }
+
     output.write("numDescriptorSets", numDescriptorSets);
 
     if (output.version_greater_equal(0, 7, 3))
diff --git a/src/vsg/state/ViewDependentState.cpp b/src/vsg/state/ViewDependentState.cpp
@@ -423,9 +423,10 @@ void ViewDependentState::init(ResourceRequirements& requirements)
 
 void ViewDependentState::update(ResourceRequirements& requirements)
 {
-    if (preRenderCommandGraph && requirements.maxSlot > preRenderCommandGraph->maxSlot)
+    if (preRenderCommandGraph)
     {
-        preRenderCommandGraph->maxSlot = requirements.maxSlot;
+        if (requirements.maxStateSlot > preRenderCommandGraph->maxStateSlot) preRenderCommandGraph->maxStateSlot = requirements.maxStateSlot;
+        if (requirements.maxViewSlot > preRenderCommandGraph->maxViewSlot) preRenderCommandGraph->maxViewSlot = requirements.maxViewSlot;
     }
 }
 
diff --git a/src/vsg/state/ViewportState.cpp b/src/vsg/state/ViewportState.cpp
@@ -18,7 +18,7 @@ using namespace vsg;
 
 ViewportState::ViewportState()
 {
-    slot = 8;
+    slot = 6;
 }
 
 ViewportState::ViewportState(const ViewportState& vs) :
diff --git a/src/vsg/vk/Context.cpp b/src/vsg/vk/Context.cpp
@@ -194,10 +194,8 @@ void Context::reserve(const ResourceRequirements& requirements)
 {
     CPU_INSTRUMENTATION_L2_NC(instrumentation, "Context reserve", COLOR_COMPILE)
 
-    if (requirements.maxSlot > resourceRequirements.maxSlot)
-    {
-        resourceRequirements.maxSlot = requirements.maxSlot;
-    }
+    if (requirements.maxStateSlot > resourceRequirements.maxStateSlot) resourceRequirements.maxStateSlot = requirements.maxStateSlot;
+    if (requirements.maxViewSlot > resourceRequirements.maxViewSlot) resourceRequirements.maxViewSlot = requirements.maxViewSlot;
 
     descriptorPools->reserve(requirements);
 }
diff --git a/src/vsg/vk/ResourceRequirements.cpp b/src/vsg/vk/ResourceRequirements.cpp
@@ -64,7 +64,8 @@ DescriptorPoolSizes ResourceRequirements::computeDescriptorPoolSizes() const
 
 void ResourceRequirements::apply(const ResourceHints& resourceHints)
 {
-    if (resourceHints.maxSlot > maxSlot) maxSlot = resourceHints.maxSlot;
+    if (resourceHints.maxStateSlot > maxStateSlot) maxStateSlot = resourceHints.maxStateSlot;
+    if (resourceHints.maxViewSlot > maxViewSlot) maxViewSlot = resourceHints.maxViewSlot;
 
     if (!resourceHints.descriptorPoolSizes.empty() || resourceHints.numDescriptorSets > 0)
     {
@@ -95,7 +96,8 @@ ref_ptr<ResourceHints> CollectResourceRequirements::createResourceHints(uint32_t
 {
     auto resourceHints = vsg::ResourceHints::create();
 
-    resourceHints->maxSlot = requirements.maxSlot;
+    resourceHints->maxStateSlot = requirements.maxStateSlot;
+    resourceHints->maxViewSlot = requirements.maxViewSlot;
     resourceHints->numDescriptorSets = static_cast<uint32_t>(requirements.computeNumDescriptorSets() * tileMultiplier);
     resourceHints->descriptorPoolSizes = requirements.computeDescriptorPoolSizes();
 
@@ -154,7 +156,7 @@ void CollectResourceRequirements::apply(const PagedLOD& plod)
 
 void CollectResourceRequirements::apply(const StateCommand& stateCommand)
 {
-    if (stateCommand.slot > requirements.maxSlot) requirements.maxSlot = stateCommand.slot;
+    if (stateCommand.slot > requirements.maxStateSlot) requirements.maxStateSlot = stateCommand.slot;
     stateCommand.traverse(*this);
 }
 
@@ -213,13 +215,16 @@ void CollectResourceRequirements::apply(const Light& light)
 
 void CollectResourceRequirements::apply(const RenderGraph& rg)
 {
-    if (rg.viewportState) rg.viewportState->accept(*this);
+    if (rg.viewportState) requirements.maxViewSlot = std::max(requirements.maxViewSlot, rg.viewportState->slot);
     rg.traverse(*this);
 }
 
 void CollectResourceRequirements::apply(const View& view)
 {
-    if (view.camera && view.camera->viewportState) view.camera->viewportState->accept(*this);
+    if (view.camera && view.camera->viewportState)
+    {
+        requirements.maxViewSlot = std::max(requirements.maxViewSlot, view.camera->viewportState->slot);
+    }
 
     if (auto itr = requirements.views.find(&view); itr != requirements.views.end())
     {
@@ -243,7 +248,7 @@ void CollectResourceRequirements::apply(const View& view)
 
     if (view.viewDependentState)
     {
-        if (requirements.maxSlot < 2) requirements.maxSlot = 2;
+        if (requirements.maxStateSlot < 2) requirements.maxStateSlot = 2; // TODO change to maxViewSlot?
 
         view.viewDependentState->init(requirements);
 
diff --git a/src/vsg/vk/State.cpp b/src/vsg/vk/State.cpp
@@ -15,20 +15,21 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 using namespace vsg;
 
-State::State(uint32_t maxSlot) :
+State::State(uint32_t maxStateSlot, uint32_t maxViewSlot) :
     dirty(false)
 {
-    reserve(maxSlot);
+    reserve(maxStateSlot, maxViewSlot);
 }
 
-void State::reserve(uint32_t maxSlot)
+void State::reserve(uint32_t maxStateSlot, uint32_t maxViewSlot)
 {
-    size_t required_size = static_cast<size_t>(maxSlot) + 1;
+    //info("State::reserve(", maxStateSlot, ", ", maxViewSlot, ")");
+
+    size_t required_size = static_cast<size_t>(maxStateSlot) + 1;
     if (required_size > stateStacks.size()) stateStacks.resize(required_size);
 
+    required_size = static_cast<size_t>(maxViewSlot) + 1;
     if (required_size > viewStateStacks.size()) viewStateStacks.resize(required_size);
-
-    //info("State::reserve(", maxSlot, ")");
 }
 
 

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ namespace vsg`
`69`	`69`	`class VSG_DECLSPEC RecordTraversal : public Object`
`70`	`70`	`{`
`71`	`71`	`public:`
`72`		`- explicit RecordTraversal(uint32_t in_maxSlot = 2, const std::set<Bin*>& in_bins = {});`
	`72`	`+ explicit RecordTraversal(uint32_t in_maxStateSlot = 2, uint32_t in_maxViewSlot = 8, const std::set<Bin*>& in_bins = {}); // TODO`
`73`	`73`
`74`	`74`	`RecordTraversal(const RecordTraversal&) = delete;`
`75`	`75`	`RecordTraversal& operator=(const RecordTraversal& rhs) = delete;`
Original file line number	Diff line number	Diff line change
`@@ -228,7 +228,7 @@ namespace vsg`
`228`	`228`	`class State : public Inherit<Object, State>`
`229`	`229`	`{`
`230`	`230`	`public:`
`231`		`- explicit State(uint32_t maxSlot);`
	`231`	`+ explicit State(uint32_t maxStateSlot, uint32_t maxViewSlot);`
`232`	`232`
`233`	`233`	`using StateCommandStack = StateStack<StateCommand>;`
`234`	`234`	`using StateStacks = std::vector<StateCommandStack>;`
`@@ -254,7 +254,7 @@ namespace vsg`
`254`	`254`	`MatrixStack projectionMatrixStack{0};`
`255`	`255`	`MatrixStack modelviewMatrixStack{64};`
`256`	`256`
`257`		`- void reserve(uint32_t maxSlot);`
	`257`	`+ void reserve(uint32_t maxStateSlot, uint32_t maxViewSlot);`
`258`	`258`
`259`	`259`	`void setInhertiedViewProjectionAndViewMatrix(const dmat4& projMatrix, const dmat4& viewMatrix)`
`260`	`260`	`{`
Original file line number	Diff line number	Diff line change
`@@ -66,9 +66,9 @@ ref_ptr<RecordTraversal> CommandGraph::getOrCreateRecordTraversal()`
`66`	`66`	`{`
`67`	`67`	`//CPU_INSTRUMENTATION_L1(instrumentation);`
`68`	`68`	`if (!recordTraversal)`
`69`		`- recordTraversal = RecordTraversal::create(maxSlot);`
	`69`	`+ recordTraversal = RecordTraversal::create(maxStateSlot, maxViewSlot);`
`70`	`70`	`else`
`71`		`- recordTraversal->getState()->reserve(maxSlot);`
	`71`	`+ recordTraversal->getState()->reserve(maxStateSlot, maxViewSlot);`
`72`	`72`
`73`	`73`	`return recordTraversal;`
`74`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -298,10 +298,8 @@ void vsg::updateTasks(RecordAndSubmitTasks& tasks, ref_ptr<CompileManager> compi`
`298`	`298`	`{`
`299`	`299`	`for (const auto& commandGraph : task->commandGraphs)`
`300`	`300`	`{`
`301`		`- if (compileResult.maxSlot > commandGraph->maxSlot)`
`302`		`- {`
`303`		`- commandGraph->maxSlot = compileResult.maxSlot;`
`304`		`- }`
	`301`	`+ if (compileResult.maxStateSlot > commandGraph->maxStateSlot) commandGraph->maxStateSlot = compileResult.maxStateSlot;`
	`302`	`+ if (compileResult.maxViewSlot > commandGraph->maxViewSlot) commandGraph->maxViewSlot = compileResult.maxViewSlot;`
`305`	`303`	`}`
`306`	`304`	`}`
`307`	`305`