went a bit overboard with previous commit, also fix inifinite recursion bug due to bad const resolution

Author: devshgraphicsprogramming

include/nbl/asset/IAsset.h

@@ -169,9 +169,11 @@ class IAsset : virtual public core::IReferenceCounted
 		inline void visitDependents(std::function<bool(IAsset*)> visit)
 		{
 			assert(isMutable());
-			visitDependents([&](const IAsset* dependent) -> bool
+			visitDependents_impl([&](const IAsset* dep) -> bool
 			{
-				return visit(const_cast<IAsset*>(dependent));
+				if (dep)
+					return visit(const_cast<IAsset*>(dep));
+				return true;
 			});
 		}
 

include/nbl/asset/IPreHashed.h

@@ -39,61 +39,61 @@ class IPreHashed : public IAsset
 				discardContent_impl();
 		}
 
-    static inline void discardDependantsContents(const std::span<IAsset* const> roots)
-    {
-      core::vector<IAsset*> stack;
-      core::unordered_set<IAsset*> alreadyVisited; // whether we have push the node to the stack
-      auto push = [&stack,&alreadyVisited](IAsset* node) -> bool
-      {
-        const auto [dummy,inserted] = alreadyVisited.insert(node);
-        if (inserted)
-          stack.push_back(node);
-        return true;
-      };
-      for (const auto& root : roots)
-        push(root);
-      while (!stack.empty())
-      {
-        auto* entry = stack.back();
-        stack.pop_back();
-        entry->visitDependents(push);
-        // pre order traversal does discard
-        auto* isPrehashed = dynamic_cast<IPreHashed*>(entry);
-        if (isPrehashed)
-          isPrehashed->discardContent();
-      }
-    }
-    static inline bool anyDependantDiscardedContents(const IAsset* root)
-    {
-      core::vector<const IAsset*> stack;
-      core::unordered_set<const IAsset*> alreadyVisited; // whether we have push the node to the stack
-      bool result = false;
-      auto push = [&stack,&alreadyVisited,&result](const IAsset* node) -> bool
-      {
-        const auto [dummy,inserted] = alreadyVisited.insert(node);
-        if (inserted)
+        static inline void discardDependantsContents(const std::span<IAsset* const> roots)
         {
-          auto* isPrehashed = dynamic_cast<const IPreHashed*>(node);
-          if (isPrehashed && isPrehashed->missingContent())
-          {
-            stack.clear();
-            result = true;
-            return false;
-          }
-          stack.push_back(node);
+            core::vector<IAsset*> stack;
+            core::unordered_set<IAsset*> alreadyVisited; // whether we have push the node to the stack
+            auto push = [&stack,&alreadyVisited](IAsset* node) -> bool
+            {
+                const auto [dummy,inserted] = alreadyVisited.insert(node);
+                if (inserted)
+                    stack.push_back(node);
+                return true;
+            };
+            for (const auto& root : roots)
+                push(root);
+            while (!stack.empty())
+            {
+                auto* entry = stack.back();
+                stack.pop_back();
+                entry->visitDependents(push);
+                // pre order traversal does discard
+                auto* isPrehashed = dynamic_cast<IPreHashed*>(entry);
+                if (isPrehashed)
+                    isPrehashed->discardContent();
+            }
+        }
+        static inline bool anyDependantDiscardedContents(const IAsset* root)
+        {
+            core::vector<const IAsset*> stack;
+            core::unordered_set<const IAsset*> alreadyVisited; // whether we have push the node to the stack
+            bool result = false;
+            auto push = [&stack,&alreadyVisited,&result](const IAsset* node) -> bool
+            {
+                const auto [dummy,inserted] = alreadyVisited.insert(node);
+                if (inserted)
+                {
+                    auto* isPrehashed = dynamic_cast<const IPreHashed*>(node);
+                    if (isPrehashed && isPrehashed->missingContent())
+                    {
+                        stack.clear();
+                        result = true;
+                        return false;
+                    }
+                    stack.push_back(node);
+                }
+                return true;
+            };
+            if (!push(root))
+                return true;
+            while (!stack.empty())
+            {
+                auto* entry = stack.back();
+                stack.pop_back();
+                entry->visitDependents(push);
+            }
+            return result;
         }
-        return true;
-      };
-      if (!push(root))
-        return true;
-      while (!stack.empty())
-      {
-        auto* entry = stack.back();
-        stack.pop_back();
-        entry->visitDependents(push);
-      }
-      return result;
-    }
 
 	protected:
 		inline IPreHashed() = default;

src/nbl/video/utilities/CAssetConverter.cpp

@@ -4165,7 +4165,7 @@ ISemaphore::future_t<IQueue::RESULT> CAssetConverter::convert_impl(SReserveResul
 	struct SMissingDependent
 	{
 		// This only checks if whether we had to convert and failed, but the dependent might be in readCache of one or more converters, so if in doubt assume its okay
-		explicit inline operator bool() const {return wasInStaging && gotWiped;}
+		inline operator bool() const {return wasInStaging && gotWiped;}
 
 		bool wasInStaging;
 		bool gotWiped;