Setting pipeline of a material now triggers a reset of all properties for material instances based on the material

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp

@@ -710,6 +710,11 @@ namespace SHADE
     return resourceManager.Create<SHMaterialInstance>(materialInst->GetBaseMaterial());
   }
 
+  std::pair<typename SHResourceHub::dense_iterator<SHMaterialInstance>, typename SHResourceHub::dense_iterator<SHMaterialInstance>> SHGraphicsSystem::GetAllMaterialInstances()
+  {
+    return resourceManager.GetDenseAccess<SHMaterialInstance>();
+  }
+
   void SHGraphicsSystem::RemoveMaterialInstance(Handle<SHMaterialInstance> materialInstance)
   {
     resourceManager.Free(materialInstance);

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h

@@ -156,6 +156,7 @@ namespace SHADE
     Handle<SHMaterialInstance> AddOrGetBaseMaterialInstance();
     Handle<SHMaterialInstance> AddOrGetBaseMaterialInstance(Handle<SHMaterial> material);
     Handle<SHMaterialInstance> AddMaterialInstanceCopy(Handle<SHMaterialInstance> materialInst);
+    std::pair<typename SHResourceHub::dense_iterator<SHMaterialInstance>, typename SHResourceHub::dense_iterator<SHMaterialInstance>> GetAllMaterialInstances();
     void RemoveMaterialInstance(Handle<SHMaterialInstance> materialInstance);
     Handle<SHMaterial> GetDefaultMaterial() { return defaultMaterial; }
     Handle<SHMaterialInstance> GetDefaultMaterialInstance() { return AddOrGetBaseMaterialInstance(defaultMaterial); }

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterial.cpp

@@ -6,6 +6,9 @@
 #include "Graphics/Shaders/BlockInterface/SHShaderBlockInterface.h"
 #include "Math/Vector/SHVec3.h"
 #include "Math/Vector/SHVec4.h"
+#include "ECS_Base/Managers/SHSystemManager.h"
+#include "SHGraphicsSystem.h"
+#include "SHMaterialInstance.h"
 
 namespace SHADE
 {
@@ -14,6 +17,10 @@ namespace SHADE
   /*---------------------------------------------------------------------------------*/
   void SHMaterial::SetPipeline(Handle<SHVkPipeline> _pipeline)
   {
+    // Reassignment, we ignore
+    if (_pipeline == pipeline)
+      return;
+
     pipeline = _pipeline;
 
     // Set up properties based on the pipeline
@@ -36,6 +43,21 @@ namespace SHADE
       propMemory.reset(new char[propMemorySize]);
     }
     ResetProperties();
+
+    // Search all material instances for instances that use this base material
+    // to force a reset of properties
+    auto gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
+    if (gfxSystem)
+    {
+      auto [matInstBegin, matInstEnd] = gfxSystem->GetAllMaterialInstances();
+      for (auto iter = matInstBegin; iter != matInstEnd; ++iter)
+      {
+        if (iter->GetBaseMaterial() == GetHandle())
+        {
+          iter->ResetProperties();
+        }
+      }
+    }
   }
 
   Handle<SHVkPipeline> SHMaterial::GetPipeline() const

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterial.h

@@ -35,7 +35,7 @@ namespace SHADE
 		Describes a Pipeline along with it's associated properties for this instance.
 	*/
 	/***********************************************************************************/
-	class SHMaterial
+	class SHMaterial : public ISelfHandle<SHMaterial>
 	{
 	  public:
 		/*-----------------------------------------------------------------------------*/

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.cpp

@@ -31,7 +31,6 @@ namespace SHADE
   /*-----------------------------------------------------------------------------------*/
   void SHMaterialInstance::ResetProperties() noexcept
   {
-
     // Reset all the properties to default values
     memset(dataStore.get(), 0, dataStoreSize);
     overrideData.clear();

SHADE_Engine/src/Graphics/MiddleEnd/Pipeline/SHPipelineLibrary.cpp

@@ -34,7 +34,7 @@ namespace SHADE
     {
     	colorBlendState.attachments.push_back(vk::PipelineColorBlendAttachmentState
         {
-          .blendEnable = SHVkUtil::IsBlendCompatible (subpass->GetFormatFromAttachmentReference(att.attachment)) ? true : false,
+          .blendEnable = SHVkUtil::IsBlendCompatible(subpass->GetFormatFromAttachmentReference(att.attachment)),
           .srcColorBlendFactor = vk::BlendFactor::eSrcAlpha,
           .dstColorBlendFactor = vk::BlendFactor::eOneMinusSrcAlpha,
           .colorBlendOp = vk::BlendOp::eAdd,

SHADE_Engine/src/Resource/SHResourceLibrary.h

@@ -38,6 +38,11 @@ namespace SHADE
     class SHResourceLibrary : public SHResourceLibraryBase
     {
       public:
+        /*-----------------------------------------------------------------------------*/
+        /* Type Definitions                                                            */
+        /*-----------------------------------------------------------------------------*/
+        using dense_iterator = typename SparseSet<T>::dense_iterator;
+
         /*-----------------------------------------------------------------------------*/
         /* Constructor                                                                 */
         /*-----------------------------------------------------------------------------*/
@@ -74,6 +79,16 @@ namespace SHADE
         /// <returns>Read-only reference to the resource object.</returns>
         const T& Get(Handle<T> handle) const;
 
+        /*-----------------------------------------------------------------------------*/
+        /* Direct Dense Access Functions                                               */
+        /*-----------------------------------------------------------------------------*/
+        /// <summary>
+        /// Provides access to the dense array of the SparseSet.
+        /// These iterators should not be used to manipulate the underlying vector.
+        /// </summary>
+        /// <returns>Pair of begin and end iterators to the dense vector.</returns>
+        std::pair<dense_iterator, dense_iterator> GetDenseAccess();
+
       private:
         /*-----------------------------------------------------------------------------*/
         /* Data Members                                                                */
@@ -96,6 +111,12 @@ namespace SHADE
     class SHResourceHub final
     {
       public:
+        /*-----------------------------------------------------------------------------*/
+        /* Type Definitions                                                            */
+        /*-----------------------------------------------------------------------------*/
+        template<typename T>
+        using dense_iterator = typename SHResourceLibrary<T>::dense_iterator;
+
         /*-----------------------------------------------------------------------------*/
         /* Constructors/Destructors                                                    */
         /*-----------------------------------------------------------------------------*/
@@ -138,6 +159,18 @@ namespace SHADE
         template<typename T>
         const T& Get(Handle<T>  handle) const;
 
+        /*-----------------------------------------------------------------------------*/
+        /* Direct Dense Access Functions                                               */
+        /*-----------------------------------------------------------------------------*/
+        /// <summary>
+        /// Provides access to the dense array of the SparseSet.
+        /// These iterators should not be used to manipulate the underlying vector.
+        /// </summary>
+        /// <typeparam name="T">Type of resource to access.</typeparam>
+        /// <returns>Pair of begin and end iterators to the dense vector.</returns>
+        template <typename T>
+        std::pair<dense_iterator<T>, dense_iterator<T>> GetDenseAccess();
+
       private:
         /*-----------------------------------------------------------------------------*/
         /* Type Definition                                                             */

SHADE_Engine/src/Resource/SHResourceLibrary.hpp

@@ -79,6 +79,15 @@ namespace SHADE
         return objects[handle.GetId().Data.Index];
     }
 
+    /*---------------------------------------------------------------------------------*/
+    /* ResourceLibrary - Direct Dense Access Functions                                 */
+    /*---------------------------------------------------------------------------------*/
+    template<typename T>
+    std::pair<typename SHResourceLibrary<T>::dense_iterator, typename SHResourceLibrary<T>::dense_iterator> SHResourceLibrary<T>::GetDenseAccess()
+    {
+      return objects.GetDenseAccess();
+    }
+
     /*---------------------------------------------------------------------------------*/
     /* ResourceLibrary - Helper Functions                                              */
     /*---------------------------------------------------------------------------------*/
@@ -105,7 +114,7 @@ namespace SHADE
     }
 
     /*---------------------------------------------------------------------------------*/
-    /* ResourceManager - Usage Functions                                               */
+    /* ResourceHub - Usage Functions                                                   */
     /*---------------------------------------------------------------------------------*/
     template <typename T, typename ... Args>
     Handle<T> SHResourceHub::Create(Args&&... args)
@@ -132,7 +141,7 @@ namespace SHADE
     }
 
     /*-----------------------------------------------------------------------------*/
-    /* ResourceManager - Helper Functions                                          */
+    /* ResourceHub - Helper Functions                                              */
     /*-----------------------------------------------------------------------------*/
     template <typename T>
     SHResourceLibrary<T>& SHResourceHub::getLibrary()
@@ -161,4 +170,13 @@ namespace SHADE
     {
         return const_cast<SHResourceHub*>(this).getLibrary<T>();
     }
+
+    /*---------------------------------------------------------------------------------*/
+    /* ResourceHub - Direct Dense Access Functions                                     */
+    /*---------------------------------------------------------------------------------*/
+    template <typename T>
+    std::pair<typename SHResourceHub::dense_iterator<T>, typename SHResourceHub::dense_iterator<T>> SHResourceHub::GetDenseAccess()
+    {
+      return getLibrary<T>().GetDenseAccess();
+    }
 }

SHADE_Engine/src/Resource/SHResourceManager.h

@@ -13,8 +13,6 @@ of DigiPen Institute of Technology is prohibited.
 
 // STL Includes
 #include <unordered_map>
-
-namespace SHADE { class SHMaterial; }
 // Project Includes
 #include "SH_API.h"
 #include "SHResourceLibrary.h"
@@ -31,6 +29,14 @@ namespace SHADE { class SHMaterial; }
 
 namespace SHADE
 {
+  /*-----------------------------------------------------------------------------------*/
+  /* Forward Declarations                                                              */
+  /*-----------------------------------------------------------------------------------*/
+  class SHMaterial;
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Type Definitions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
   /// <summary>
   /// Template structs that maps a resource to their loaded asset representation type.
   /// </summary>
@@ -41,6 +47,7 @@ namespace SHADE
   template<> struct SHResourceLoader<SHVkShaderModule> { using AssetType = SHShaderAsset;   };
   template<> struct SHResourceLoader<SHMaterialSpec>   { using AssetType = SHMaterialAsset; };
   template<> struct SHResourceLoader<SHMaterial>       { using AssetType = SHMaterialSpec;  };
+
   /// <summary>
   /// Static class responsible for loading and caching runtime resources from their
   /// serialised Asset IDs.

SHADE_Engine/src/Resource/SparseSet.h

@@ -49,6 +49,7 @@ namespace SHADE
         using const_pointer   = const T*;
         using reference       = T&;
         using const_reference = const T&;
+        using dense_iterator  = typename std::vector<T>::iterator;
 
         /*-----------------------------------------------------------------------------*/
         /* Constructors/Destructors                                                    */
@@ -59,10 +60,6 @@ namespace SHADE
         SparseSet();
         ~SparseSet() = default;
 
-        //// Disallow moving or copying
-        //SparseSet(const SparseSet&) = delete;
-        //SparseSet(SparseSet&&) = delete;
-
         /*-----------------------------------------------------------------------------*/
         /* Usage Functions                                                             */
         /*-----------------------------------------------------------------------------*/
@@ -192,6 +189,16 @@ namespace SHADE
         /// </exception>
         const T& operator[](index_type idx) const;
 
+        /*-----------------------------------------------------------------------------*/
+        /* Direct Dense Access Functions                                               */
+        /*-----------------------------------------------------------------------------*/
+        /// <summary>
+        /// Provides access to the dense array of the SparseSet.
+        /// These iterators should not be used to manipulate the underlying vector.
+        /// </summary>
+        /// <returns>Pair of begin and end iterators to the dense vector.</returns>
+        std::pair<dense_iterator, dense_iterator> GetDenseAccess();
+
       protected:
         /*-----------------------------------------------------------------------------*/
         /* Constants                                                                   */

SHADE_Engine/src/Resource/SparseSet.hpp

@@ -143,4 +143,13 @@ namespace SHADE
     {
         return at(idx);
     }
+
+    /*---------------------------------------------------------------------------------*/
+    /* Direct Dense Access Functions                                                   */
+    /*---------------------------------------------------------------------------------*/
+    template<typename T>
+    std::pair<typename SparseSet<T>::dense_iterator, typename SparseSet<T>::dense_iterator> SparseSet<T>::GetDenseAccess()
+    {
+      return { denseArray.begin(), denseArray.end() };
+    }
 }