Moved DynamicData into ResourceHints.

robertosfield · robertosfield · commit bcf5e78cbf31 · 2026-01-08T12:26:47.000Z
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,11 +1,11 @@
 cmake_minimum_required(VERSION 3.10)
 
 project(vsg
-    VERSION 1.1.13
+    VERSION 1.1.14
     DESCRIPTION "VulkanSceneGraph library"
     LANGUAGES CXX
 )
-set(VSG_SOVERSION 15)
+set(VSG_SOVERSION 16)
 SET(VSG_RELEASE_CANDIDATE 0)
 set(Vulkan_MIN_VERSION 1.1.70.0)
 
diff --git a/include/vsg/app/CompileManager.h b/include/vsg/app/CompileManager.h
@@ -30,7 +30,7 @@ namespace vsg
         Slots maxSlots;
         bool containsPagedLOD = false;
         ResourceRequirements::Views views;
-        ResourceRequirements::DynamicData dynamicData;
+        DynamicData dynamicData;
 
         explicit operator bool() const noexcept { return result == VK_SUCCESS; }
 
diff --git a/include/vsg/app/TransferTask.h b/include/vsg/app/TransferTask.h
@@ -51,7 +51,7 @@ namespace vsg
 
         ref_ptr<Device> device;
 
-        void assign(const ResourceRequirements::DynamicData& dynamicData);
+        void assign(const DynamicData& dynamicData);
         void assign(const BufferInfoList& bufferInfoList);
         void assign(const ImageInfoList& imageInfoList);
 
diff --git a/include/vsg/state/ResourceHints.h b/include/vsg/state/ResourceHints.h
@@ -14,6 +14,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #include <vsg/maths/vec2.h>
 #include <vsg/vk/DescriptorPool.h>
+#include <vsg/state/BufferInfo.h>
+#include <vsg/state/ImageInfo.h>
 
 namespace vsg
 {
@@ -30,6 +32,26 @@ namespace vsg
         DYNAMIC_VIEWPORTSTATE = 1 << 1
     };
 
+    struct DynamicData
+    {
+        BufferInfoList bufferInfos;
+        ImageInfoList imageInfos;
+
+        explicit operator bool() const noexcept { return !bufferInfos.empty() || !imageInfos.empty(); }
+
+        void clear()
+        {
+            bufferInfos.clear();
+            imageInfos.clear();
+        }
+
+        void add(const DynamicData& dd)
+        {
+            bufferInfos.insert(bufferInfos.end(), dd.bufferInfos.begin(), dd.bufferInfos.end());
+            imageInfos.insert(imageInfos.end(), dd.imageInfos.begin(), dd.imageInfos.end());
+        }
+    };
+
     /// ResourceHints provides settings that help preallocation of Vulkan resources and memory.
     class VSG_DECLSPEC ResourceHints : public Inherit<Object, ResourceHints>
     {
@@ -56,6 +78,16 @@ namespace vsg
         DataTransferHint dataTransferHint = COMPILE_TRAVERSAL_USE_TRANSFER_TASK;
         uint32_t viewportStateHint = DYNAMIC_VIEWPORTSTATE;
 
+        VkDeviceSize bufferMemoryRequirements = 0;
+        VkDeviceSize imageMemoryRequirements = 0;
+
+        DynamicData dynamicData;
+
+        bool containsPagedLOD = false;
+
+        /// hint whether CollectResourceRequirements visitor should traverse the subgraph below a node that has a "ResourceHints" assignd as meta data.
+        bool noTraverseBelowResourceHints = false;
+
     public:
         void read(Input& input) override;
         void write(Output& output) const override;
diff --git a/include/vsg/vk/ResourceRequirements.h b/include/vsg/vk/ResourceRequirements.h
@@ -60,26 +60,6 @@ namespace vsg
         using Views = std::map<const View*, ViewDetails>;
         using ViewDetailStack = std::stack<ViewDetails>;
 
-        struct DynamicData
-        {
-            BufferInfoList bufferInfos;
-            ImageInfoList imageInfos;
-
-            explicit operator bool() const noexcept { return !bufferInfos.empty() || !imageInfos.empty(); }
-
-            void clear()
-            {
-                bufferInfos.clear();
-                imageInfos.clear();
-            }
-
-            void add(const DynamicData& dd)
-            {
-                bufferInfos.insert(bufferInfos.end(), dd.bufferInfos.begin(), dd.bufferInfos.end());
-                imageInfos.insert(imageInfos.end(), dd.imageInfos.begin(), dd.imageInfos.end());
-            }
-        };
-
         DynamicData dynamicData;
 
         Descriptors descriptors;
@@ -92,6 +72,12 @@ namespace vsg
         uint32_t externalNumDescriptorSets = 0;
         bool containsPagedLOD = false;
 
+        std::set<ref_ptr<BufferInfo>> bufferInfos;
+        std::set<ref_ptr<ImageInfo>> imageInfos;
+
+        VkDeviceSize bufferMemoryRequirements = 0;
+        VkDeviceSize imageMemoryRequirements = 0;
+
         VkDeviceSize minimumBufferSize = 16 * 1024 * 1024;
         VkDeviceSize minimumDeviceMemorySize = 16 * 1024 * 1024;
 
@@ -146,8 +132,6 @@ namespace vsg
         virtual void apply(ref_ptr<ImageInfo> imageInfo);
 
     protected:
-        uint32_t _numResourceHintsAbove = 0;
-
         bool registerDescriptor(const Descriptor& descriptor);
     };
     VSG_type_name(vsg::CollectResourceRequirements);
diff --git a/src/vsg/app/TransferTask.cpp b/src/vsg/app/TransferTask.cpp
@@ -51,7 +51,7 @@ void TransferTask::assignTransferConsumedCompletedSemaphore(TransferMask transfe
     if ((transferMask & TRANSFER_AFTER_RECORD_TRAVERSAL) != 0) _lateDataToCopy.transferConsumerCompletedSemaphore = semaphore;
 }
 
-void TransferTask::assign(const ResourceRequirements::DynamicData& dynamicData)
+void TransferTask::assign(const DynamicData& dynamicData)
 {
     CPU_INSTRUMENTATION_L2(instrumentation);
 
diff --git a/src/vsg/state/ResourceHints.cpp b/src/vsg/state/ResourceHints.cpp
@@ -74,6 +74,19 @@ void ResourceHints::read(Input& input)
     {
         input.read("viewportStateHint", viewportStateHint);
     }
+
+    if (input.version_greater_equal(1, 1, 14))
+    {
+        input.read("bufferMemoryRequirements", bufferMemoryRequirements);
+        input.read("imageMemoryRequirements", imageMemoryRequirements);
+
+        input.readObjects("dynamicData.bufferInfos", dynamicData.bufferInfos);
+        input.readObjects("dynamicData.imageInfos", dynamicData.imageInfos);
+
+        input.read("containsPagedLOD", containsPagedLOD);
+
+        input.read("noTraverseBelowResourceHints", noTraverseBelowResourceHints);
+    }
 }
 
 void ResourceHints::write(Output& output) const
@@ -127,4 +140,17 @@ void ResourceHints::write(Output& output) const
     {
         output.write("viewportStateHint", viewportStateHint);
     }
+
+    if (output.version_greater_equal(1, 1, 14))
+    {
+        output.write("bufferMemoryRequirements", bufferMemoryRequirements);
+        output.write("imageMemoryRequirements", imageMemoryRequirements);
+
+        output.writeObjects("dynamicData.bufferInfos", dynamicData.bufferInfos);
+        output.writeObjects("dynamicData.imageInfos", dynamicData.imageInfos);
+
+        output.write("containsPagedLOD", containsPagedLOD);
+
+        output.write("noTraverseBelowResourceHints", noTraverseBelowResourceHints);
+    }
 }
diff --git a/src/vsg/vk/ResourceRequirements.cpp b/src/vsg/vk/ResourceRequirements.cpp
@@ -85,6 +85,11 @@ void ResourceRequirements::apply(const ResourceHints& resourceHints)
 
     dataTransferHint = resourceHints.dataTransferHint;
     viewportStateHint = resourceHints.viewportStateHint;
+
+    bufferMemoryRequirements += resourceHints.bufferMemoryRequirements;
+    imageMemoryRequirements += resourceHints.imageMemoryRequirements;
+    dynamicData.add(resourceHints.dynamicData);
+    containsPagedLOD = containsPagedLOD | resourceHints.containsPagedLOD;
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -104,6 +109,13 @@ ref_ptr<ResourceHints> CollectResourceRequirements::createResourceHints(uint32_t
         poolSize.descriptorCount = poolSize.descriptorCount * tileMultiplier;
     }
 
+    resourceHints->bufferMemoryRequirements = requirements.bufferMemoryRequirements;
+    resourceHints->imageMemoryRequirements = requirements.imageMemoryRequirements;
+    resourceHints->dynamicData = requirements.dynamicData;
+    resourceHints->containsPagedLOD = requirements.containsPagedLOD;
+
+    resourceHints->noTraverseBelowResourceHints = true;
+
     return resourceHints;
 }
 
@@ -118,7 +130,7 @@ bool CollectResourceRequirements::checkForResourceHints(const Object& object)
     if (resourceHints)
     {
         apply(*resourceHints);
-        return true;
+        return resourceHints->noTraverseBelowResourceHints;
     }
     else
     {
@@ -133,23 +145,24 @@ void CollectResourceRequirements::apply(const ResourceHints& resourceHints)
 
 void CollectResourceRequirements::apply(const Node& node)
 {
-    bool hasResourceHints = checkForResourceHints(node);
-    if (hasResourceHints) ++_numResourceHintsAbove;
+    if (checkForResourceHints(node))
+    {
+        return;
+    }
 
     node.traverse(*this);
-
-    if (hasResourceHints) --_numResourceHintsAbove;
 }
 
 void CollectResourceRequirements::apply(const PagedLOD& plod)
 {
-    bool hasResourceHints = checkForResourceHints(plod);
-    if (hasResourceHints) ++_numResourceHintsAbove;
-
     requirements.containsPagedLOD = true;
-    plod.traverse(*this);
 
-    if (hasResourceHints) --_numResourceHintsAbove;
+    if (checkForResourceHints(plod))
+    {
+        return;
+    }
+
+    plod.traverse(*this);
 }
 
 void CollectResourceRequirements::apply(const StateCommand& stateCommand)
@@ -302,21 +315,41 @@ void CollectResourceRequirements::apply(const BindIndexBuffer& bib)
 
 void CollectResourceRequirements::apply(ref_ptr<BufferInfo> bufferInfo)
 {
-    if (bufferInfo && bufferInfo->data && bufferInfo->data->dynamic())
+    if (bufferInfo && requirements.bufferInfos.count(bufferInfo)==0)
     {
-        requirements.dynamicData.bufferInfos.push_back(bufferInfo);
+        requirements.bufferInfos.insert(bufferInfo);
+
+        if (bufferInfo->data)
+        {
+            if (bufferInfo->data->dynamic())
+            {
+                requirements.dynamicData.bufferInfos.push_back(bufferInfo);
+            }
+
+            requirements.bufferMemoryRequirements += bufferInfo->data->dataSize();
+        }
     }
 }
 
 void CollectResourceRequirements::apply(ref_ptr<ImageInfo> imageInfo)
 {
-    if (imageInfo && imageInfo->imageView && imageInfo->imageView->image)
+    if (imageInfo && requirements.imageInfos.count(imageInfo)==0)
     {
-        // check for dynamic data
-        auto& data = imageInfo->imageView->image->data;
-        if (data && data->dynamic())
+        if (imageInfo->imageView && imageInfo->imageView->image)
         {
-            requirements.dynamicData.imageInfos.push_back(imageInfo);
+            requirements.imageInfos.insert(imageInfo);
+
+            // check for dynamic data
+            auto& data = imageInfo->imageView->image->data;
+            if (data)
+            {
+                if (data->dynamic())
+                {
+                    requirements.dynamicData.imageInfos.push_back(imageInfo);
+                }
+
+                requirements.imageMemoryRequirements += data->dataSize();
+            }
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ void TransferTask::assignTransferConsumedCompletedSemaphore(TransferMask transfe`
`51`	`51`	`if ((transferMask & TRANSFER_AFTER_RECORD_TRAVERSAL) != 0) _lateDataToCopy.transferConsumerCompletedSemaphore = semaphore;`
`52`	`52`	`}`
`53`	`53`
`54`		`-void TransferTask::assign(const ResourceRequirements::DynamicData& dynamicData)`
	`54`	`+void TransferTask::assign(const DynamicData& dynamicData)`
`55`	`55`	`{`
`56`	`56`	`CPU_INSTRUMENTATION_L2(instrumentation);`
`57`	`57`
Original file line number	Diff line number	Diff line change
`@@ -85,6 +85,11 @@ void ResourceRequirements::apply(const ResourceHints& resourceHints)`
`85`	`85`
`86`	`86`	`dataTransferHint = resourceHints.dataTransferHint;`
`87`	`87`	`viewportStateHint = resourceHints.viewportStateHint;`
	`88`	`+`
	`89`	`+ bufferMemoryRequirements += resourceHints.bufferMemoryRequirements;`
	`90`	`+ imageMemoryRequirements += resourceHints.imageMemoryRequirements;`
	`91`	`+ dynamicData.add(resourceHints.dynamicData);`
	`92`	`+ containsPagedLOD = containsPagedLOD \| resourceHints.containsPagedLOD;`
`88`	`93`	`}`
`89`	`94`
`90`	`95`	`//////////////////////////////////////////////////////////////////////`
`@@ -104,6 +109,13 @@ ref_ptr<ResourceHints> CollectResourceRequirements::createResourceHints(uint32_t`
`104`	`109`	`poolSize.descriptorCount = poolSize.descriptorCount * tileMultiplier;`
`105`	`110`	`}`
`106`	`111`
	`112`	`+ resourceHints->bufferMemoryRequirements = requirements.bufferMemoryRequirements;`
	`113`	`+ resourceHints->imageMemoryRequirements = requirements.imageMemoryRequirements;`
	`114`	`+ resourceHints->dynamicData = requirements.dynamicData;`
	`115`	`+ resourceHints->containsPagedLOD = requirements.containsPagedLOD;`
	`116`	`+`
	`117`	`+ resourceHints->noTraverseBelowResourceHints = true;`
	`118`	`+`
`107`	`119`	`return resourceHints;`
`108`	`120`	`}`
`109`	`121`
`@@ -118,7 +130,7 @@ bool CollectResourceRequirements::checkForResourceHints(const Object& object)`
`118`	`130`	`if (resourceHints)`
`119`	`131`	`{`
`120`	`132`	`apply(*resourceHints);`
`121`		`- return true;`
	`133`	`+ return resourceHints->noTraverseBelowResourceHints;`
`122`	`134`	`}`
`123`	`135`	`else`
`124`	`136`	`{`
`@@ -133,23 +145,24 @@ void CollectResourceRequirements::apply(const ResourceHints& resourceHints)`
`133`	`145`
`134`	`146`	`void CollectResourceRequirements::apply(const Node& node)`
`135`	`147`	`{`
`136`		`- bool hasResourceHints = checkForResourceHints(node);`
`137`		`- if (hasResourceHints) ++_numResourceHintsAbove;`
	`148`	`+ if (checkForResourceHints(node))`
	`149`	`+ {`
	`150`	`+ return;`
	`151`	`+ }`
`138`	`152`
`139`	`153`	`node.traverse(*this);`
`140`		`-`
`141`		`- if (hasResourceHints) --_numResourceHintsAbove;`
`142`	`154`	`}`
`143`	`155`
`144`	`156`	`void CollectResourceRequirements::apply(const PagedLOD& plod)`
`145`	`157`	`{`
`146`		`- bool hasResourceHints = checkForResourceHints(plod);`
`147`		`- if (hasResourceHints) ++_numResourceHintsAbove;`
`148`		`-`
`149`	`158`	`requirements.containsPagedLOD = true;`
`150`		`- plod.traverse(*this);`
`151`	`159`
`152`		`- if (hasResourceHints) --_numResourceHintsAbove;`
	`160`	`+ if (checkForResourceHints(plod))`
	`161`	`+ {`
	`162`	`+ return;`
	`163`	`+ }`
	`164`	`+`
	`165`	`+ plod.traverse(*this);`
`153`	`166`	`}`
`154`	`167`
`155`	`168`	`void CollectResourceRequirements::apply(const StateCommand& stateCommand)`
`@@ -302,21 +315,41 @@ void CollectResourceRequirements::apply(const BindIndexBuffer& bib)`
`302`	`315`
`303`	`316`	`void CollectResourceRequirements::apply(ref_ptr<BufferInfo> bufferInfo)`
`304`	`317`	`{`
`305`		`- if (bufferInfo && bufferInfo->data && bufferInfo->data->dynamic())`
	`318`	`+ if (bufferInfo && requirements.bufferInfos.count(bufferInfo)==0)`
`306`	`319`	`{`
`307`		`- requirements.dynamicData.bufferInfos.push_back(bufferInfo);`
	`320`	`+ requirements.bufferInfos.insert(bufferInfo);`
	`321`	`+`
	`322`	`+ if (bufferInfo->data)`
	`323`	`+ {`
	`324`	`+ if (bufferInfo->data->dynamic())`
	`325`	`+ {`
	`326`	`+ requirements.dynamicData.bufferInfos.push_back(bufferInfo);`
	`327`	`+ }`
	`328`	`+`
	`329`	`+ requirements.bufferMemoryRequirements += bufferInfo->data->dataSize();`
	`330`	`+ }`
`308`	`331`	`}`
`309`	`332`	`}`
`310`	`333`
`311`	`334`	`void CollectResourceRequirements::apply(ref_ptr<ImageInfo> imageInfo)`
`312`	`335`	`{`
`313`		`- if (imageInfo && imageInfo->imageView && imageInfo->imageView->image)`
	`336`	`+ if (imageInfo && requirements.imageInfos.count(imageInfo)==0)`
`314`	`337`	`{`
`315`		`- // check for dynamic data`
`316`		`- auto& data = imageInfo->imageView->image->data;`
`317`		`- if (data && data->dynamic())`
	`338`	`+ if (imageInfo->imageView && imageInfo->imageView->image)`
`318`	`339`	`{`
`319`		`- requirements.dynamicData.imageInfos.push_back(imageInfo);`
	`340`	`+ requirements.imageInfos.insert(imageInfo);`
	`341`	`+`
	`342`	`+ // check for dynamic data`
	`343`	`+ auto& data = imageInfo->imageView->image->data;`
	`344`	`+ if (data)`
	`345`	`+ {`
	`346`	`+ if (data->dynamic())`
	`347`	`+ {`
	`348`	`+ requirements.dynamicData.imageInfos.push_back(imageInfo);`
	`349`	`+ }`
	`350`	`+`
	`351`	`+ requirements.imageMemoryRequirements += data->dataSize();`
	`352`	`+ }`
`320`	`353`	`}`
`321`	`354`	`}`
`322`	`355`	`}`