Merge remote-tracking branch 'origin/main' into SP3-16-Math

SHADE_Application/src/Application/SBApplication.cpp

@@ -23,8 +23,10 @@
 #include "Graphics/MiddleEnd/Interface/SHRenderable.h"
 #include "Scene/SHSceneManager.h"
 #include "Math/Transform/SHTransformSystem.h"
+#include "Input/SHInputManagerSystem.h"
 
 #include "Scenes/SBTestScene.h"
+#include "Math/Transform/SHTransformComponent.h"
 
 using namespace SHADE;
 
@@ -51,6 +53,7 @@ namespace Sandbox
     SHADE::SHSystemManager::CreateSystem<SHADE::SHTransformSystem>();
     SHADE::SHSystemManager::CreateSystem<SHADE::SHGraphicsSystem>();
     SHADE::SHGraphicsSystem* graphicsSystem = static_cast<SHADE::SHGraphicsSystem*>(SHADE::SHSystemManager::GetSystem<SHADE::SHGraphicsSystem>());
+    SHADE::SHSystemManager::CreateSystem<SHADE::SHInputManagerSystem>();
     
     // Create Routines
     SHADE::SHSystemManager::RegisterRoutine<SHADE::SHScriptEngine, SHADE::SHScriptEngine::FrameSetUpRoutine>();
@@ -67,7 +70,11 @@ namespace Sandbox
     SHADE::SHSystemManager::RegisterRoutine<SHADE::SHGraphicsSystem, SHADE::SHGraphicsSystem::BeginRoutine>();
     SHADE::SHSystemManager::RegisterRoutine<SHADE::SHGraphicsSystem, SHADE::SHGraphicsSystem::RenderRoutine>();
     SHADE::SHSystemManager::RegisterRoutine<SHADE::SHGraphicsSystem, SHADE::SHGraphicsSystem::EndRoutine>();
+
     SHADE::SHComponentManager::CreateComponentSparseSet<SHADE::SHRenderable>();
+    SHADE::SHComponentManager::CreateComponentSparseSet<SHADE::SHTransformComponent>();
+
+    SHADE::SHSystemManager::RegisterRoutine<SHADE::SHInputManagerSystem, SHADE::SHInputManagerSystem::InputManagerRoutine>();
     
     // Set up graphics system and windows
     graphicsSystem->SetWindow(&window);

SHADE_Application/src/Scenes/SBTestScene.cpp

@@ -36,26 +36,58 @@ namespace Sandbox
     graphicsSystem->BuildMeshBuffers();
 
     // Create Materials
-    auto matInst = graphicsSystem->AddMaterialInstance();
+    auto matInst = graphicsSystem->AddOrGetBaseMaterialInstance();
+
+    // Create Stress Test Objects
+    static const SHVec3 TEST_OBJ_SCALE = { 0.2f, 0.2f, 0.2f };
+    constexpr int NUM_ROWS = 1;
+    constexpr int NUM_COLS = 1;
+    static const SHVec3 TEST_OBJ_SPACING = { 1.0f, 1.0f, 1.0f };
+    static const SHVec3 TEST_OBJ_START_POS = { - (NUM_COLS / 2 * TEST_OBJ_SPACING.x ), 0.0f, 0.0f };
+    for (int z = 0; z < NUM_ROWS; ++z)
+    for (int x = 0; x < NUM_COLS; ++x)
+    {
+        auto entity      = SHEntityManager::CreateEntity<SHRenderable, SHTransformComponent>();
+        auto& renderable = *SHComponentManager::GetComponent_s<SHRenderable>(entity);
+        auto& transform  = *SHComponentManager::GetComponent_s<SHTransformComponent>(entity);
 
-    // Create entity and add mesh
-    testObj = SHADE::SHEntityManager::CreateEntity<SHADE::SHRenderable, SHADE::SHTransformComponent>();
-    auto& renderable = *SHADE::SHComponentManager::GetComponent_s<SHADE::SHRenderable>(testObj);
         renderable.Mesh = CUBE_MESH;
         renderable.SetMaterial(matInst);
-    // Create transform
-    auto& transform = *SHADE::SHComponentManager::GetComponent_s<SHADE::SHTransformComponent>(testObj);
-    transform.SetLocalPosition(SHVec3{ 0.0f, 0.0f, 2.0f });
 
-    renderable.TransformMatrix = SHMatrix::Translate(0.0f, 0.0f, 2.0f);
+        // Set initial positions
-    SHADE::SHScriptEngine* scriptEngine = static_cast<SHADE::SHScriptEngine*>(SHADE::SHSystemManager::GetSystem<SHADE::SHScriptEngine>());
+        transform.SetWorldPosition(TEST_OBJ_START_POS + SHVec3{ x * TEST_OBJ_SPACING.x, 0.0f, z * TEST_OBJ_SPACING.z });
-    scriptEngine->AddScript(*SHADE::SHEntityManager::GetEntityByID(testObj), "TestScript");
+        //transform.SetLocalScale(TEST_OBJ_SCALE);
+
+        stressTestObjects.emplace_back(entity);
     }
+
+    // Create blank entity with a script
+    testObj = SHADE::SHEntityManager::CreateEntity();
+    SHADE::SHScriptEngine* scriptEngine = static_cast<SHADE::SHScriptEngine*>(SHADE::SHSystemManager::GetSystem<SHADE::SHScriptEngine>());
+    scriptEngine->AddScript(testObj, "TestScript");
+  }
+
   void SBTestScene::Update(float dt)
   {
-    (void)dt;
+      /*static float rotation = 0.0f;
+
+      auto& transform = *SHADE::SHComponentManager::GetComponent_s<SHADE::SHTransformComponent>(testObj);
+
+      transform.SetLocalRotation(rotation, 0.0f, 0.0f);
+      rotation += dt * 10.0f;*/
+      /*static float rotation = 0.0f;
+
+      auto& transform = *SHADE::SHComponentManager::GetComponent_s<SHADE::SHTransformComponent>(stressTestObjects[0]);
+
+      transform.SetWorldPosition({rotation, 0.0f, 0.0f});
+      rotation += dt * 10.0f;*/
+    
+    // Destroy entity if space is pressed
     if (GetKeyState(VK_SPACE) & 0x8000)
-        SHADE::SHEntityManager::DestroyEntity(testObj);
+    {
+        SHADE::SHScriptEngine* scriptEngine = static_cast<SHADE::SHScriptEngine*>(SHADE::SHSystemManager::GetSystem<SHADE::SHScriptEngine>());
+        scriptEngine->RemoveAllScripts(testObj);
+    }
   }
 
   void SBTestScene::Render()

SHADE_Application/src/Scenes/SBTestScene.h

@@ -10,7 +10,7 @@ namespace Sandbox
   private:
     EntityID camera;
     EntityID testObj;
-
+    std::vector<EntityID> stressTestObjects;
 
   public:
     virtual void Load();

SHADE_Engine/NatvisFile.natvis

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?> 
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+  <Type Name="SHADE::Handle&lt;*&gt;">
+    <DisplayString Condition="library==nullptr">NULL</DisplayString>
+    <DisplayString>ID = {id.Data.Index} Version = {id.Data.Version} Type = {"$T1"} </DisplayString>    
+    <Expand>
+      <ExpandedItem>(*library).objects.denseArray[(*library).objects.sparseArray[id.Data.Index]]</ExpandedItem>
+    </Expand>
+  </Type>
+</AutoVisualizer>

SHADE_Engine/premake5.lua

@@ -15,7 +15,8 @@ project "SHADE_Engine"
     "%{prj.location}/src/**.hpp",
     "%{prj.location}/src/**.c",
     "%{prj.location}/src/**.cpp",
-    "%{prj.location}/src/**.glsl"
+    "%{prj.location}/src/**.glsl",
+    "%{prj.location}/**.natvis"
   }
   
   includedirs

SHADE_Engine/src/Graphics/Buffers/SHVkBuffer.cpp

@@ -49,6 +49,11 @@ namespace SHADE
     Init(newSize, data, srcSize, bufferUsageFlags, allocCreateInfo.usage, allocCreateInfo.flags);
   }
 
+  void SHVkBuffer::FlushAllocation(uint32_t srcOffset, uint32_t dstOffset) noexcept
+  {
+    vmaFlushAllocation(vmaAllocator, alloc, srcOffset, dstOffset);
+  }
+
   vk::Buffer SHVkBuffer::GetVkBuffer(void) const noexcept
   {
     return vkBuffer;
@@ -72,7 +77,6 @@ namespace SHADE
   /***************************************************************************/
   void SHVkBuffer::Map(void) noexcept
   {
-    if (!boundToCoherent)
     vmaMapMemory(vmaAllocator, alloc, &mappedPtr);
   }
 
@@ -89,13 +93,10 @@ namespace SHADE
   */
   /***************************************************************************/
   void SHVkBuffer::Unmap(void) noexcept
-  {
-    if (!boundToCoherent)
   {
     vmaUnmapMemory(vmaAllocator, alloc);
     mappedPtr = nullptr;
   }
-  }
 
   /***************************************************************************/
   /*!
@@ -132,9 +133,7 @@ namespace SHADE
       Otherwise, only the copying is carried out. 
       
       In the instance where memory  is non-coherent but HOST_VISIBLE, we want to
-      write to data and then unmap and flush it immediately. If you want to write
+      write to data and then unmap and flush it immediately. 
-      to memory in random-access fashion, consider, mapping, writing a few 
-      things, unmapping then flushing.
     
     \param vmaAllocator
       The VMA allocator object.
@@ -154,19 +153,12 @@ namespace SHADE
   */
   /***************************************************************************/
   void SHVkBuffer::MapWriteUnmap(void* data, uint32_t sizeToWrite, uint32_t srcOffset, uint32_t dstOffset) noexcept
-  {
-    if (!boundToCoherent)
   {
     // map from host visible memory to pointer, do a DMA, and then unmap
     Map();
     WriteToMemory(data, sizeToWrite, srcOffset, dstOffset);
     Unmap();
-    }
+    FlushAllocation(srcOffset, dstOffset);
-    else
-    {
-      if (mappedPtr)
-        std::memcpy(static_cast<uint8_t*>(mappedPtr) + dstOffset, static_cast<uint8_t*>(data) + srcOffset, sizeToWrite);
-    }
   }
 
   /***************************************************************************/
@@ -279,7 +271,6 @@ namespace SHADE
   , mappedPtr{ nullptr }
   , alloc {nullptr}
   , randomAccessOptimized{false}
-  , boundToCoherent {false}
   , vmaAllocator{allocator}
   {}
 
@@ -304,7 +295,6 @@ namespace SHADE
     , mappedPtr{ std::move(rhs.mappedPtr) }
     , alloc{ std::move (rhs.alloc) }
     , randomAccessOptimized{ rhs.randomAccessOptimized }
-    , boundToCoherent{ rhs.boundToCoherent}
     , vmaAllocator{ rhs.vmaAllocator }
     , bufferUsageFlags {rhs.bufferUsageFlags}
     , bufferCreateInfo { rhs.bufferCreateInfo }
@@ -325,7 +315,6 @@ namespace SHADE
     mappedPtr = std::move(rhs.mappedPtr);
     alloc = std::move(rhs.alloc);
     randomAccessOptimized = rhs.randomAccessOptimized;
-    boundToCoherent = rhs.boundToCoherent;
     vmaAllocator = std::move (rhs.vmaAllocator);
     rhs.vkBuffer = VK_NULL_HANDLE;
     bufferCreateInfo = rhs.bufferCreateInfo;
@@ -430,19 +419,21 @@ namespace SHADE
     // mainly host visible. Can be cached (need to flush/invalidate), uncached (always coherent) and coherent (virtual). 
     if(memPropFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
     {
-      // If memory is marked to be coherent between CPU and GPU (no need flush/invalidate) (TODO: Verify if VMA_ALLOCATION_CREATE_MAPPED_BIT is used when VMA_MEMORY_USAGE_AUTO is set)
+      const bool CREATE_MAPPED = allocFlags & VMA_ALLOCATION_CREATE_MAPPED_BIT;
-      // TODO: also verify that coherent bit = pointer is already mapped
+
-      if (memPropFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
+      if (CREATE_MAPPED)
-      {
-        boundToCoherent = true;
         mappedPtr = allocInfo.pMappedData;
-      }
       else
         mappedPtr = nullptr;
 
       if (data)
+      {
+        if (CREATE_MAPPED)
+          WriteToMemory(data, srcSize, 0, 0);
+        else
           MapWriteUnmap(data, srcSize, 0, 0);
       }
+    }
     else
     {
       // We can prep first so that we can do transfers later via 1 cmd buffer recording

SHADE_Engine/src/Graphics/Buffers/SHVkBuffer.h

@@ -41,9 +41,6 @@ namespace SHADE
     //! If initialized with vma random access flag, this is true
     bool randomAccessOptimized;
 
-    //! Whether or not this buffer is bound to coherent memory
-    bool boundToCoherent;
-
     //! buffer usage info flags
     vk::BufferUsageFlags bufferUsageFlags;
 
@@ -100,6 +97,7 @@ namespace SHADE
     void TransferToDeviceResource(Handle<SHVkCommandBuffer> const& cmdBufferHdl) noexcept;
     void ResizeNoCopy            (uint32_t newSize);
     void ResizeReplace           (uint32_t newSize, void* data, uint32_t srcSize);
+    void FlushAllocation         (uint32_t srcOffset, uint32_t dstOffset) noexcept;
     
     /*-----------------------------------------------------------------------*/
     /* SETTERS AND GETTERS                                                   */

SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp

@@ -8,6 +8,7 @@
 #include "Graphics/Framebuffer/SHVkFramebuffer.h"
 #include "Graphics/Pipeline/SHVkPipeline.h"
 #include "Graphics/Buffers/SHVkBuffer.h"
+#include "Graphics/Images/SHVkImage.h"
 #include "Graphics/Descriptors/SHVkDescriptorSetGroup.h"
 
 
@@ -323,11 +324,14 @@ namespace SHADE
   void SHVkCommandBuffer::BindVertexBuffer(uint32_t bindingPoint, Handle<SHVkBuffer> const& buffer, vk::DeviceSize offset) noexcept
   {
     if (cmdBufferState == SH_CMD_BUFFER_STATE::RECORDING)
+    {
+      if (buffer)
       {
         auto bufferHandle = buffer->GetVkBuffer();
         vkCommandBuffer.bindVertexBuffers(bindingPoint, 1, &bufferHandle, &offset);
       }
     }
+  }
 
   /***************************************************************************/
   /*!
@@ -422,6 +426,40 @@ namespace SHADE
 
   }
 
+  /***************************************************************************/
+  /*!
+
+   \brief
+     Issues a multi indirect draw call.
+
+   \param indirectDrawData
+     SHVkBuffer containing the data for the multi indirect draw call.
+   \param drawCount
+     Number of multi indirect draw sub-calls stored in indirectDrawData.
+
+  */
+  /***************************************************************************/
+
+  void SHVkCommandBuffer::DrawMultiIndirect(Handle<SHVkBuffer> indirectDrawData, uint32_t drawCount)
+  {
+    if (cmdBufferState != SH_CMD_BUFFER_STATE::RECORDING)
+    {
+      SHLOG_ERROR("Command buffer must have started recording before a pipeline can be bound.");
+      return;
+    }
+
+    if (indirectDrawData)
+      vkCommandBuffer.drawIndexedIndirect(indirectDrawData->GetVkBuffer(), 0, drawCount, sizeof(vk::DrawIndexedIndirectCommand));
+  }
+
+  void SHVkCommandBuffer::CopyBufferToImage(const vk::Buffer& src, const vk::Image& dst, const std::vector<vk::BufferImageCopy>& copyInfo)
+  {
+    vkCommandBuffer.copyBufferToImage
+    (
+      src, dst, vk::ImageLayout::eTransferDstOptimal,
+      static_cast<uint32_t>(copyInfo.size()), copyInfo.data()
+    );
+  }
 
   void SHVkCommandBuffer::PipelineBarrier(
     vk::PipelineStageFlags srcStage,
@@ -457,33 +495,11 @@ namespace SHADE
   //  //vkCommandBuffer.pipelineBarrier()
   //}
 
-  /***************************************************************************/
+  void SHVkCommandBuffer::ForceSetPipelineLayout(Handle<SHVkPipelineLayout> pipelineLayout) noexcept
-  /*!
-
-   \brief
-     Issues a multi indirect draw call.
-
-   \param indirectDrawData
-     SHVkBuffer containing the data for the multi indirect draw call.
-   \param drawCount
-     Number of multi indirect draw sub-calls stored in indirectDrawData.
-
-  */
-  /***************************************************************************/
-
-  void SHVkCommandBuffer::DrawMultiIndirect(Handle<SHVkBuffer> indirectDrawData, uint32_t drawCount)
   {
-    if (cmdBufferState != SH_CMD_BUFFER_STATE::RECORDING)
+    boundPipelineLayoutHdl = pipelineLayout;
-    {
-      SHLOG_ERROR("Command buffer must have started recording before a pipeline can be bound.");
-      return;
   }
 
-    vkCommandBuffer.drawIndexedIndirect(indirectDrawData->GetVkBuffer(), 0, drawCount, sizeof(vk::DrawIndexedIndirectCommand));
-  }
-
-
-
   /***************************************************************************/
   /*!
 

SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.h

@@ -15,6 +15,7 @@ namespace SHADE
   class SHVkFramebuffer;
   class SHVkPipeline;
   class SHVkBuffer;
+  class SHVkImage;
   class SHVkDescriptorSetGroup;
 
   enum class SH_CMD_BUFFER_TYPE
@@ -116,6 +117,10 @@ namespace SHADE
     // Draw Commands
     void DrawArrays         (uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const noexcept;
     void DrawIndexed        (uint32_t indexCount, uint32_t firstIndex, uint32_t vertexOffset) const noexcept;
+    void DrawMultiIndirect  (Handle<SHVkBuffer> indirectDrawData, uint32_t drawCount);
+
+    // Buffer Copy
+    void CopyBufferToImage  (const vk::Buffer& src, const vk::Image& dst, const std::vector<vk::BufferImageCopy>& copyInfo);
 
     // memory barriers
     void PipelineBarrier    (
@@ -129,7 +134,6 @@ namespace SHADE
 
     bool IsReadyToSubmit    (void) const noexcept;
     void HandlePostSubmit   (void) noexcept;
-    void DrawMultiIndirect  (Handle<SHVkBuffer> indirectDrawData, uint32_t drawCount);
 
     // Push Constant variable setting
     template <typename T>
@@ -137,6 +141,7 @@ namespace SHADE
     {
       memcpy (static_cast<uint8_t*>(pushConstantData) + boundPipelineLayoutHdl->GetPushConstantInterface().GetOffset(variableName), &data, sizeof (T));
     };
+    void ForceSetPipelineLayout (Handle<SHVkPipelineLayout> pipelineLayout) noexcept;
 
     void SubmitPushConstants (void) const noexcept;
 

SHADE_Engine/src/Graphics/Descriptors/SHDescriptorSetUpdater.cpp

@@ -20,23 +20,6 @@ namespace SHADE
     
   }
 
-  /***************************************************************************/
-  /*! 
-   
-    \brief
-      Links the write infos to the vulkan write descriptor sets.
-    
-  */ 
-  /***************************************************************************/
-  void SHDescriptorSetUpdater::LinkInfoToWriteDescSet(void) noexcept
-  {
-    for (uint32_t i = 0; i < writeInfos.size(); ++i)
-    {
-      writeDescSets[i].pImageInfo = writeInfos[i].descImageInfos.data();
-      writeDescSets[i].pBufferInfo = writeInfos[i].descBufferInfos.data();
-      writeDescSets[i].pTexelBufferView = writeInfos[i].descTexelBufferInfos.data();
-    }
-  }
 
   SHDescriptorWriteInfo& SHDescriptorWriteInfo::operator=(SHDescriptorWriteInfo&& rhs) noexcept
   {
@@ -65,11 +48,6 @@ namespace SHADE
 
   }
 
-  std::vector<vk::WriteDescriptorSet> const& SHDescriptorSetUpdater::GetWriteDescriptorSets(void) const noexcept
-  {
-    return writeDescSets;
-  }
-
   SHDescriptorSetUpdater& SHDescriptorSetUpdater::operator=(SHDescriptorSetUpdater&& rhs) noexcept
   {
     if (&rhs == this)

SHADE_Engine/src/Graphics/Descriptors/SHDescriptorSetUpdater.h

@@ -41,10 +41,6 @@ namespace SHADE
     //! When we want to update a write, we need to use this to identify the index of the write.
     std::unordered_map<BindingAndSetHash, uint32_t> writeHashMap;
 
-    //! We keep this here because we want this to be immediately passable to vkUpdateDescriptorSets
-    std::vector<vk::WriteDescriptorSet> writeDescSets;
-
-    void LinkInfoToWriteDescSet(void) noexcept;
 
   public:
     SHDescriptorSetUpdater (void) noexcept;
@@ -52,8 +48,6 @@ namespace SHADE
     SHDescriptorSetUpdater& operator= (SHDescriptorSetUpdater&& rhs) noexcept;
 
   public:
-    std::vector<vk::WriteDescriptorSet> const& GetWriteDescriptorSets (void) const noexcept;
-
     friend class SHVkDescriptorSetGroup;
   };
 }

SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorPool.cpp

@@ -50,9 +50,8 @@ namespace SHADE
     return *this;
   }
 
-  std::vector<Handle<SHVkDescriptorSetGroup>> SHVkDescriptorPool::Allocate(const std::vector<Handle<SHVkDescriptorSetLayout>>& layouts, std::vector<uint32_t> const& variableDescCounts)
+  Handle<SHVkDescriptorSetGroup> SHVkDescriptorPool::Allocate(const std::vector<Handle<SHVkDescriptorSetLayout>>& layouts, std::vector<uint32_t> const& variableDescCounts)
   {
-    SHVkInstance::GetResourceManager().Create<SHVkDescriptorSetGroup>(device, GetHandle(), layouts, variableDescCounts);
+    return SHVkInstance::GetResourceManager().Create<SHVkDescriptorSetGroup>(device, GetHandle(), layouts, variableDescCounts);
-    return {};
   }
 }

SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorPool.h

@@ -39,7 +39,8 @@ namespace SHADE
             std::vector<vk::DescriptorPoolSize> Limits =
             {
                 { vk::DescriptorType::eCombinedImageSampler, 100 },
-                { vk::DescriptorType::eUniformBuffer, 100 }
+				{ vk::DescriptorType::eUniformBuffer, 100 },
+				{ vk::DescriptorType::eUniformBufferDynamic, 100 }
             };
             /// <summary>
             /// Maximum number of descriptor sets allowed
@@ -101,7 +102,7 @@ namespace SHADE
         /// Handles to the created Descriptor Sets. If this DescriptorPool has run out of
         /// space, lesser number of Handles will be returned.
         /// </returns>
-        std::vector<Handle<SHVkDescriptorSetGroup>> Allocate(const std::vector<Handle<SHVkDescriptorSetLayout>>& layouts, std::vector<uint32_t> const& variableDescCounts);
+        Handle<SHVkDescriptorSetGroup> Allocate(const std::vector<Handle<SHVkDescriptorSetLayout>>& layouts, std::vector<uint32_t> const& variableDescCounts);
 
       private:
         /*-----------------------------------------------------------------------------*/

SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetGroup.cpp

@@ -7,6 +7,11 @@
 #include "Graphics/Devices/SHVkLogicalDevice.h"
 #include "Graphics/Descriptors/SHVkDescriptorSetLayout.h"
 #include "Tools/SHLogger.h"
+#include "Graphics/Images/SHVkImage.h"
+#include "Graphics/Images/SHVkImageView.h"
+#include "Graphics/Images/SHVkSampler.h"
+#include "Graphics/Buffers/SHVkBuffer.h"
+#include "Graphics/SHVkUtil.h"
 
 namespace SHADE
 {
@@ -39,6 +44,7 @@ namespace SHADE
     : device{deviceHdl}
     , descPool {pool}
     , descSets{}
+    , layoutsUsed {layouts}
 	{
 		// Create the layout for each concurrent frame
     std::vector<vk::DescriptorSetLayout> vkLayouts{ layouts.size() };
@@ -47,6 +53,7 @@ namespace SHADE
     for (uint32_t i = 0; i < layouts.size(); ++i)
     {
       vkLayouts[i] = layouts[i]->GetVkHandle();
+      setIndexing.emplace(layouts[i]->GetSetIndex(), i);
     }
 
     // Check for variable descriptor count
@@ -73,34 +80,22 @@ namespace SHADE
     // allocate descriptor sets
     descSets = device->GetVkLogicalDevice().allocateDescriptorSets(DESC_SET_LAYOUT_CREATE_INFO);
 
-
+    // Now we want to prepare the write descriptor sets info for writing later.
-
-    // Now we want to prepare the write descriptor sets for writing later.
     for (uint32_t i = 0; i < layouts.size(); ++i)
     {
       auto const& bindings = layouts[i]->GetBindings();
       for (auto& binding : bindings)
       {
         BindingAndSetHash writeHash = binding.BindPoint;
-        writeHash |= static_cast<uint64_t>(i) << 32;
+        writeHash |= static_cast<uint64_t>(layouts[i]->GetSetIndex()) << 32;
 
         // new write for the binding
         updater.writeInfos.emplace_back();
         updater.writeHashMap.try_emplace(writeHash, updater.writeInfos.size() - 1);
         auto& writeInfo = updater.writeInfos.back();
 
-        updater.writeDescSets.emplace_back();
-        auto& writeDescSet = updater.writeDescSets.back();
-
-        // Initialize info for write
-        writeDescSet.descriptorType = binding.Type;
-        writeDescSet.dstArrayElement = 0;
-        writeDescSet.dstSet = descSets[i];
-        writeDescSet.dstBinding = binding.BindPoint;
-
         // Descriptor count for the write descriptor set. Usually this is set to 1, but if binding is variable sized, set to info passed in
         uint32_t descriptorCount = (binding.flags & vk::DescriptorBindingFlagBits::eVariableDescriptorCount) ? variableDescCounts[i] : 1;
-        writeDescSet.descriptorCount = descriptorCount;
 
         switch (binding.Type)
         {
@@ -114,8 +109,10 @@ namespace SHADE
         case vk::DescriptorType::eUniformTexelBuffer:
         case vk::DescriptorType::eStorageTexelBuffer:
         case vk::DescriptorType::eUniformBuffer:
+        case vk::DescriptorType::eUniformBufferDynamic:
         case vk::DescriptorType::eStorageBuffer:
-          writeInfo.descImageInfos.resize (descriptorCount);
+        case vk::DescriptorType::eStorageBufferDynamic:
+          writeInfo.descBufferInfos.resize (descriptorCount);
           break;
           //case vk::DescriptorType::eUniformBufferDynamic:
           //  break;
@@ -130,8 +127,6 @@ namespace SHADE
         }
       }
     }
-    // Link all the writeDescSet data for vkUpdateDescriptorSets to write to the linked descriptors
-    updater.LinkInfoToWriteDescSet();
 	}
 
   /***************************************************************************/
@@ -160,7 +155,7 @@ namespace SHADE
    
   */ 
   /***************************************************************************/
-  void SHVkDescriptorSetGroup::ModifyWriteDescImage(uint32_t set, uint32_t binding, std::vector<std::pair<vk::ImageView, vk::Sampler>> const& imageViewsAndSamplers) noexcept
+  void SHVkDescriptorSetGroup::ModifyWriteDescImage(uint32_t set, uint32_t binding, std::span<std::pair<Handle<SHVkImageView>, Handle<SHVkSampler>>> const& imageViewsAndSamplers) noexcept
   {
     // Find the target writeDescSet
     BindingAndSetHash writeHash = binding;
@@ -176,32 +171,83 @@ namespace SHADE
     {
       // write sampler and image view
       auto& ivs = imageViewsAndSamplers[i];
-      writeInfo.descImageInfos[i].imageView = ivs.first;
+      writeInfo.descImageInfos[i].imageView = ivs.first->GetImageView();
-      writeInfo.descImageInfos[i].sampler = ivs.second;
+      writeInfo.descImageInfos[i].sampler = ivs.second->GetVkSampler();
     }
   }
 
-
+  void SHVkDescriptorSetGroup::ModifyWriteDescBuffer(uint32_t set, uint32_t binding, std::span<Handle<SHVkBuffer>> const& buffers, uint32_t offset, uint32_t range) noexcept
-  void SHVkDescriptorSetGroup::UpdateDescriptorSet(void) noexcept
   {
-    device->UpdateDescriptorSets(updater.GetWriteDescriptorSets());
+    // Find the target writeDescSet
+    BindingAndSetHash writeHash = binding;
+    writeHash |= static_cast<uint64_t>(set) << 32;
+    auto& writeInfo = updater.writeInfos[updater.writeHashMap.at(writeHash)];
+
+    if (buffers.size() > writeInfo.descBufferInfos.size())
+    {
+      SHLOG_ERROR("Attempting write too many descriptors into descriptor set. Failed to write to vk::WriteDescriptorSet. ");
     }
 
+    for (uint32_t i = 0; i < buffers.size(); ++i)
+    {
+      // write sampler and image view
+      auto& buffer = buffers[i];
+      writeInfo.descBufferInfos[i].buffer = buffer->GetVkBuffer();
+      writeInfo.descBufferInfos[i].offset = offset;
+      writeInfo.descBufferInfos[i].range = range;
+    }
 
-  void SHVkDescriptorSetGroup::UpdateSingleDescriptorSetImages(uint32_t set, uint32_t binding) noexcept
+  }
+
+  void SHVkDescriptorSetGroup::UpdateDescriptorSetImages(uint32_t set, uint32_t binding) noexcept
   {
     vk::WriteDescriptorSet writeDescSet{};
 
+    // Get binding + set hash
+    BindingAndSetHash bsHash = SHVkUtil::GenBindingSetHash(set, binding);
+
+    // to index a set
+    uint32_t setIndex = setIndexing[bsHash];
+
+    // to index a write for a binding
+    uint32_t writeInfoIndex = updater.writeHashMap[bsHash];
+
     // Initialize info for write
-    writeDescSet.descriptorType = vk::DescriptorType::eCombinedImageSampler;
+    writeDescSet.descriptorType = layoutsUsed[setIndex]->GetBindings()[binding].Type;
     writeDescSet.dstArrayElement = 0;
-    writeDescSet.dstSet = descSets[set];
+    writeDescSet.dstSet = descSets[setIndex];
     writeDescSet.dstBinding = binding;
 
-    writeDescSet.pImageInfo = updater.writeInfos[set].descImageInfos.data();
+    writeDescSet.pImageInfo = updater.writeInfos[writeInfoIndex].descImageInfos.data();
-    writeDescSet.descriptorCount = static_cast<uint32_t>(updater.writeInfos[set].descImageInfos.size());
+    writeDescSet.descriptorCount = static_cast<uint32_t>(updater.writeInfos[writeInfoIndex].descImageInfos.size());
 
     device->UpdateDescriptorSet(writeDescSet);
   }
 
+  void SHVkDescriptorSetGroup::UpdateDescriptorSetBuffer(uint32_t set, uint32_t binding) noexcept
+  {
+    vk::WriteDescriptorSet writeDescSet{};
+
+    // Get binding + set hash
+    BindingAndSetHash bsHash = SHVkUtil::GenBindingSetHash(set, binding);
+
+    // to index a set
+    uint32_t setIndex = setIndexing[bsHash];
+
+    // to index a write for a binding
+    uint32_t writeInfoIndex = updater.writeHashMap[bsHash];
+
+    // Initialize info for write
+    writeDescSet.descriptorType = layoutsUsed[setIndex]->GetBindings()[binding].Type;
+    writeDescSet.dstArrayElement = 0;
+    writeDescSet.dstSet = descSets[setIndex];
+    writeDescSet.dstBinding = binding;
+
+    writeDescSet.pBufferInfo = updater.writeInfos[writeInfoIndex].descBufferInfos.data();
+    writeDescSet.descriptorCount = static_cast<uint32_t>(updater.writeInfos[writeInfoIndex].descBufferInfos.size());
+
+    device->UpdateDescriptorSet(writeDescSet);
+
+  }
+
 }

SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetGroup.h

@@ -14,6 +14,10 @@ namespace SHADE
   class SHVkLogicalDevice;
   class SHVkDescriptorPool;
   class SHVkDescriptorSetLayout;
+  class SHVkSampler;
+  class SHVkImage;
+  class SHVkImageView;
+  class SHVkBuffer;
 
 
   /*---------------------------------------------------------------------------------*/
@@ -54,12 +58,14 @@ namespace SHADE
     SHVkDescriptorSetGroup& operator=(SHVkDescriptorSetGroup&& rhs) noexcept = default;
 
     /*-----------------------------------------------------------------------------*/
-    /* Descriptor set writing                                                      */
+    /* Public member functions                                                     */
     /*-----------------------------------------------------------------------------*/
-    void ModifyWriteDescImage(uint32_t set, uint32_t binding, std::vector<std::pair<vk::ImageView, vk::Sampler>> const& imageViewsAndSamplers) noexcept;
+    void UpdateDescriptorSetImages(uint32_t set, uint32_t binding) noexcept;
-    void UpdateDescriptorSet(void) noexcept;
+    void UpdateDescriptorSetBuffer(uint32_t set, uint32_t binding) noexcept;
+
+    void ModifyWriteDescImage(uint32_t set, uint32_t binding, std::span<std::pair<Handle<SHVkImageView>, Handle<SHVkSampler>>> const& imageViewsAndSamplers) noexcept;
+    void ModifyWriteDescBuffer (uint32_t set, uint32_t binding, std::span<Handle<SHVkBuffer>> const& buffers, uint32_t offset, uint32_t range) noexcept;
 
-    void UpdateSingleDescriptorSetImages(uint32_t set, uint32_t binding) noexcept;
 
     /*-----------------------------------------------------------------------------*/
     /* Getter Functions                                                            */
@@ -81,9 +87,17 @@ namespace SHADE
     //! Descriptor pool to allocate descriptor sets 
     Handle<SHVkDescriptorPool> descPool;
 
+    //! Sometimes when we pass in a layout, the set of the layout used in the
+    //! shader cannot be used to index into descSets. This is to mitigate that issue
+    //! when we update descriptor sets.
+    std::unordered_map<SetIndex, uint32_t> setIndexing;
+
     //! Descriptor sets
     std::vector<vk::DescriptorSet> descSets;
 
+    //! Layouts used to create this descriptor set group
+    std::vector<Handle<SHVkDescriptorSetLayout>> layoutsUsed;
+
     //! for updating descriptor sets. We want to cache this so that we don't create the
     //! write structs at runtime.
     SHDescriptorSetUpdater updater;

SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.cpp

@@ -7,9 +7,10 @@ namespace SHADE
     /*---------------------------------------------------------------------------------*/
     /* Constructor/Destructor                                                          */
     /*---------------------------------------------------------------------------------*/
-    SHVkDescriptorSetLayout::SHVkDescriptorSetLayout(Handle<SHVkLogicalDevice> device, const std::vector<Binding>& bindings)
+    SHVkDescriptorSetLayout::SHVkDescriptorSetLayout(Handle<SHVkLogicalDevice> device, SetIndex set, const std::vector<Binding>& bindings)
     : device     { device }
     , layoutDesc { bindings }
+    , setIndex {set}
     {
         // Check if auto-binding point calculation configuration is valid
         bool autoCalc = false;
@@ -74,6 +75,7 @@ namespace SHADE
       : device {rhs.device}
       , setLayout {rhs.setLayout}
       , layoutDesc{std::move (rhs.layoutDesc)}
+      , setIndex {rhs.setIndex}
     {
       rhs.setLayout = VK_NULL_HANDLE;
     }
@@ -90,6 +92,11 @@ namespace SHADE
       return layoutDesc;
     }
 
+    SetIndex SHVkDescriptorSetLayout::GetSetIndex(void) const noexcept
+    {
+      return setIndex;
+    }
+
     SHVkDescriptorSetLayout& SHVkDescriptorSetLayout::operator=(SHVkDescriptorSetLayout&& rhs) noexcept
     {
       if (&rhs == this)
@@ -98,6 +105,7 @@ namespace SHADE
       device = rhs.device;
       setLayout = rhs.setLayout;
       layoutDesc = std::move(rhs.layoutDesc);
+      setIndex = rhs.setIndex;
 
       rhs.setLayout = VK_NULL_HANDLE;
 

SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.h

@@ -74,7 +74,7 @@ namespace SHADE
         /// </summary>
         /// <param name="device"></param>
         /// <param name="bindings"></param>
-        SHVkDescriptorSetLayout(Handle<SHVkLogicalDevice> device, const std::vector<Binding>& bindings);
+        SHVkDescriptorSetLayout(Handle<SHVkLogicalDevice> device, SetIndex setIndex, const std::vector<Binding>& bindings);
         SHVkDescriptorSetLayout(const SHVkDescriptorSetLayout&) = delete;
         SHVkDescriptorSetLayout(SHVkDescriptorSetLayout&& rhs) noexcept;
         /// <summary>
@@ -97,6 +97,7 @@ namespace SHADE
         /// <returns>Handle to the Vulkan Descriptor Set Layout handle.</returns>
         inline const vk::DescriptorSetLayout& GetVkHandle() const { return setLayout; }
         std::vector<Binding> const&           GetBindings (void) const noexcept;
+        SetIndex                              GetSetIndex (void) const noexcept;
 
       private:
         /*-----------------------------------------------------------------------------*/
@@ -105,5 +106,6 @@ namespace SHADE
         Handle<SHVkLogicalDevice> device;
         vk::DescriptorSetLayout   setLayout;
         std::vector<Binding>      layoutDesc; // Stores description of the layout
+        SetIndex                  setIndex;   // Index of the set
     };
 }

SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp

@@ -467,7 +467,12 @@ namespace SHADE
   
   */
   /***************************************************************************/
-  Handle<SHVkPipelineLayout> SHVkLogicalDevice::CreatePipelineLayout(SHPipelineLayoutParams& pipelineLayoutParams) noexcept
+  Handle<SHVkPipelineLayout> SHVkLogicalDevice::CreatePipelineLayout(SHPipelineLayoutParams const& pipelineLayoutParams) noexcept
+  {
+    return SHVkInstance::GetResourceManager().Create <SHVkPipelineLayout>(GetHandle(), pipelineLayoutParams);
+  }
+
+  Handle<SHVkPipelineLayout> SHVkLogicalDevice::CreatePipelineLayoutDummy(SHPipelineLayoutParamsDummy const& pipelineLayoutParams) noexcept
   {
     return SHVkInstance::GetResourceManager().Create <SHVkPipelineLayout>(GetHandle(), pipelineLayoutParams);
   }
@@ -488,9 +493,9 @@ namespace SHADE
   
   */
   /***************************************************************************/
-  Handle<SHVkPipeline> SHVkLogicalDevice::CreatePipeline(Handle<SHVkPipelineLayout> const& pipelineLayoutHdl, SHVkPipelineState const* const state, Handle<SHVkRenderpass> const& renderpassHdl, Handle<SHSubpass> subpass, SH_PIPELINE_TYPE type) noexcept
+  Handle<SHVkPipeline> SHVkLogicalDevice::CreateGraphicsPipeline(Handle<SHVkPipelineLayout> const& pipelineLayoutHdl, SHVkPipelineState const* const state, Handle<SHVkRenderpass> const& renderpassHdl, Handle<SHSubpass> subpass) noexcept
   {
-    return SHVkInstance::GetResourceManager().Create <SHVkPipeline>(GetHandle(), pipelineLayoutHdl, state, renderpassHdl, subpass, type);
+    return SHVkInstance::GetResourceManager().Create <SHVkPipeline>(GetHandle(), pipelineLayoutHdl, state, renderpassHdl, subpass);
 
   }
 
@@ -510,9 +515,9 @@ namespace SHADE
 
   }
 
-  Handle<SHVkDescriptorSetLayout> SHVkLogicalDevice::CreateDescriptorSetLayout(std::vector<SHVkDescriptorSetLayout::Binding> const& bindings) noexcept
+  Handle<SHVkDescriptorSetLayout> SHVkLogicalDevice::CreateDescriptorSetLayout(SetIndex setIndex, std::vector<SHVkDescriptorSetLayout::Binding> const& bindings) noexcept
   {
-    return SHVkInstance::GetResourceManager().Create <SHVkDescriptorSetLayout>(GetHandle(), bindings);
+    return SHVkInstance::GetResourceManager().Create <SHVkDescriptorSetLayout>(GetHandle(), setIndex,  bindings);
 
   }
 

SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.h

@@ -21,6 +21,7 @@
 #include "Graphics/Descriptors/SHVkDescriptorSetLayout.h"
 #include "Graphics/Images/SHVkImage.h"
 
+
 namespace SHADE
 {
   /*-----------------------------------------------------------------------*/
@@ -171,23 +172,23 @@ namespace SHADE
                                                                std::string const&               shaderName
                                                               ) noexcept;
                                     
-    Handle<SHVkPipeline>            CreatePipeline            (
+    Handle<SHVkPipeline>            CreateGraphicsPipeline            (
                                                                Handle<SHVkPipelineLayout> const& pipelineLayoutHdl, 
                                                                SHVkPipelineState const* const    state, 
                                                                Handle<SHVkRenderpass> const&     renderpassHdl,
-                                                               Handle<SHSubpass>                 subpass,
+                                                               Handle<SHSubpass>                 subpass
-                                                               SH_PIPELINE_TYPE                  type
                                                               ) noexcept;
                                     
     Handle<SHVkRenderpass>          CreateRenderpass          (std::span<vk::AttachmentDescription> const vkDescriptions, std::vector<SHVkSubpassParams> const& subpasses) noexcept;
     Handle<SHVkRenderpass>          CreateRenderpass          (std::span<vk::AttachmentDescription> const vkDescriptions, std::span<vk::SubpassDescription> const spDescs, std::span<vk::SubpassDependency> const spDeps) noexcept;
     Handle<SHVkFramebuffer>         CreateFramebuffer         (Handle<SHVkRenderpass> const& renderpassHdl, std::vector<Handle<SHVkImageView>> const& attachments, uint32_t inWidth, uint32_t inHeight) noexcept;
-    Handle<SHVkDescriptorSetLayout> CreateDescriptorSetLayout (std::vector<SHVkDescriptorSetLayout::Binding> const& bindings) noexcept;
+    Handle<SHVkDescriptorSetLayout> CreateDescriptorSetLayout (SetIndex setIndex, std::vector<SHVkDescriptorSetLayout::Binding> const& bindings) noexcept;
     Handle<SHVkDescriptorPool>      CreateDescriptorPools     (const SHVkDescriptorPool::Config& config = {}) noexcept;
     Handle<SHVkDescriptorSetGroup>  CreateDescriptorSetGroup(Handle<SHVkDescriptorPool> pool,
       std::vector<Handle<SHVkDescriptorSetLayout>> const& layouts,
       std::vector<uint32_t> const& variableDescCounts) noexcept;
-    Handle<SHVkPipelineLayout>      CreatePipelineLayout      (SHPipelineLayoutParams& pipelineLayoutParams) noexcept;
+    Handle<SHVkPipelineLayout>      CreatePipelineLayout(SHPipelineLayoutParams const& pipelineLayoutParams) noexcept;
+    Handle<SHVkPipelineLayout>      CreatePipelineLayoutDummy(SHPipelineLayoutParamsDummy const& pipelineLayoutParams) noexcept;
     Handle<SHVkFence>               CreateFence               (void) const noexcept;
     Handle<SHVkSemaphore>           CreateSemaphore           (void) const noexcept;
 

SHADE_Engine/src/Graphics/Images/SHVkImage.cpp

@@ -234,7 +234,7 @@ namespace SHADE
     return SHVkInstance::GetResourceManager().Create<SHVkImageView>(inLogicalDeviceHdl, parent, createParams);
   }
 
-  void SHVkImage::TransferToDeviceResource(void) noexcept
+  void SHVkImage::TransferToDeviceResource(Handle<SHVkCommandBuffer> cmdBufferHdl) noexcept
   {
     // prepare copy regions
     std::vector<vk::BufferImageCopy> copyRegions{mipOffsets.size()};
@@ -252,7 +252,7 @@ namespace SHADE
       copyRegions[i].imageExtent = vk::Extent3D{ width >> i, height >> i, 1 };
     }
 
-    //PrepareImageTransition();
+    cmdBufferHdl->CopyBufferToImage(stagingBuffer, vkImage, copyRegions);
   }
 
   /***************************************************************************/
@@ -274,7 +274,7 @@ namespace SHADE
    
   */ 
   /***************************************************************************/
-  void SHVkImage::PrepareImageTransition(vk::ImageLayout oldLayout, vk::ImageLayout newLayout, vk::ImageMemoryBarrier& barrier) noexcept
+  void SHVkImage::PrepareImageTransitionInfo(vk::ImageLayout oldLayout, vk::ImageLayout newLayout, vk::ImageMemoryBarrier& barrier) noexcept
   {
     barrier.oldLayout = oldLayout;
     barrier.newLayout = newLayout;
@@ -286,33 +286,6 @@ namespace SHADE
     barrier.subresourceRange.levelCount = mipLevelCount;
     barrier.subresourceRange.baseArrayLayer = 0;
     barrier.subresourceRange.layerCount = layerCount;
-
-    vk::PipelineStageFlagBits srcStage = vk::PipelineStageFlagBits::eTopOfPipe;
-    vk::PipelineStageFlagBits dstStage = vk::PipelineStageFlagBits::eTopOfPipe;
-
-    if (oldLayout == vk::ImageLayout::eUndefined && newLayout == vk::ImageLayout::eTransferDstOptimal)
-    {
-      srcStage = vk::PipelineStageFlagBits::eTopOfPipe;
-      dstStage = vk::PipelineStageFlagBits::eTransfer;
-
-      barrier.srcAccessMask = vk::AccessFlagBits::eNone;
-      barrier.dstAccessMask = vk::AccessFlagBits::eTransferWrite;
-    }
-    else if (oldLayout == vk::ImageLayout::eTransferDstOptimal && newLayout == vk::ImageLayout::eShaderReadOnlyOptimal)
-    {
-      srcStage = vk::PipelineStageFlagBits::eTransfer;
-
-      // TODO, what if we want to access in compute shader
-      dstStage = vk::PipelineStageFlagBits::eFragmentShader;
-
-      barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
-      barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
-    }
-    else
-    {
-      SHLOG_ERROR("Image layouts are invalid. ");
-    }
-
   }
 
   void SHVkImage::LinkWithExteriorImage(vk::Image inVkImage, vk::ImageType type, uint32_t inWidth, uint32_t inHeight, uint32_t inDepth, uint32_t layers, uint8_t levels, vk::Format format, vk::ImageUsageFlags flags) noexcept

SHADE_Engine/src/Graphics/Images/SHVkImage.h

@@ -135,8 +135,8 @@ namespace SHADE
     /* PUBLIC MEMBER FUNCTIONS                                               */
     /*-----------------------------------------------------------------------*/
     Handle<SHVkImageView> CreateImageView          (Handle<SHVkLogicalDevice> const& inLogicalDeviceHdl, Handle<SHVkImage> const& parent, SHImageViewDetails const& createParams) const noexcept;
-    void                  TransferToDeviceResource (void) noexcept;
+    void                  TransferToDeviceResource (Handle<SHVkCommandBuffer> cmdBufferHdl) noexcept;
-    void                  PrepareImageTransition   (vk::ImageLayout oldLayout, vk::ImageLayout newLayout, vk::ImageMemoryBarrier& barrier) noexcept;
+    void                  PrepareImageTransitionInfo   (vk::ImageLayout oldLayout, vk::ImageLayout newLayout, vk::ImageMemoryBarrier& barrier) noexcept;
 
     /*-----------------------------------------------------------------------*/
     /* GETTERS AND SETTERS                                                   */

SHADE_Engine/src/Graphics/Images/SHVkSampler.cpp

@@ -4,4 +4,9 @@
 namespace SHADE
 {
   
+  vk::Sampler SHVkSampler::GetVkSampler(void) const noexcept
+  {
+    return vkSampler;
+  }
+
 }

SHADE_Engine/src/Graphics/Images/SHVkSampler.h

@@ -22,6 +22,7 @@ namespace SHADE
     SHVkSampler   (SHVkSampler&& rhs) noexcept;
     SHVkSampler&& operator=(SHVkSampler&& rhs) noexcept;
 
+    vk::Sampler GetVkSampler (void) const noexcept;
   };
 }
 

SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.cpp

@@ -22,6 +22,8 @@ of DigiPen Institute of Technology is prohibited.
 #include "Graphics/Pipeline/SHVkPipeline.h"
 #include "Graphics/MiddleEnd/Interface/SHGraphicsConstants.h"
 #include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h"
+#include "ECS_Base/Managers/SHComponentManager.h"
+#include "Math/Transform/SHTransformComponent.h"
 
 namespace SHADE
 {
@@ -33,6 +35,9 @@ namespace SHADE
     {
         if (!pipeline)
             throw std::invalid_argument("Attempted to create a SHBatch with an invalid SHPipeline!");
+
+        // Mark all as dirty
+        setAllDirtyFlags();
     }
 
     void SHBatch::Add(const SHRenderable* renderable)
@@ -52,6 +57,12 @@ namespace SHADE
 
         // Add renderable in
         subBatch->Renderables.insert(renderable);
+
+        // Also add material instance in
+        referencedMatInstances.insert(renderable->GetMaterial());
+
+        // Mark all as dirty
+        setAllDirtyFlags();
     }
 
     void SHBatch::Remove(const SHRenderable* renderable)
@@ -67,6 +78,26 @@ namespace SHADE
             return;
 
         subBatch->Renderables.erase(renderable);
+
+        // Check if other renderables in subBatches contain the same material instance
+        bool matUnused = true;
+        for (const auto& sb : subBatches)
+        for (const auto& rend : sb.Renderables)
+        {
+            if (rend->GetMaterial() == renderable->GetMaterial())
+            {
+                matUnused = false;
+                break;
+            }
+        }
+
+        // Material is no longer in this library, so we remove it
+        if (matUnused)
+            referencedMatInstances.erase(renderable->GetMaterial());
+
+        // Mark all as dirty
+        for (bool& dirt : isDirty)
+            dirt = true;
     }
 
     void SHBatch::Clear()
@@ -81,15 +112,111 @@ namespace SHADE
 
 
         // Clear GPU buffers
-        drawDataBuffer.Free();
+        for (int i = 0; i < SHGraphicsConstants::NUM_FRAME_BUFFERS; ++i)
-        transformDataBuffer.Free();
+        {
-        matPropsBuffer.Free();
+            drawDataBuffer[i].Free();
+            transformDataBuffer[i].Free();
+            matPropsBuffer[i].Free();
+        }
     }
 
-    void SHBatch::Build(Handle<SHVkLogicalDevice> device)
+	void SHBatch::UpdateMaterialBuffer(uint32_t frameIndex)
 	{
+		if (frameIndex >= SHGraphicsConstants::NUM_FRAME_BUFFERS)
+		{
+			SHLOG_WARNING("[SHBatch] Attempted to update transform buffers with an invalid frame index.");
+			return;
+		}
+
+        // Check if there are even material properties to update
+        if (!matPropsData)
+            return;
+
+        // Check if any materials have changed
+        bool hasChanged = false;
+        for (const auto& material : referencedMatInstances)
+        {
+            if (material->HasChanged())
+            {
+                hasChanged = true;
+                break;
+            }
+        }
+
+        // We need to update all the material buffers if the materials have changed
+        if (hasChanged)
+        {
+            for (auto& dirt : matBufferDirty)
+			    dirt = true;
+        }
+
+        // Check if this frame's buffer is dirty
+        if (!matBufferDirty[frameIndex])
+            return;
+
+		// Build CPI Buffer
+		char* propsCurrPtr = matPropsData.get();
+		for (auto& subBatch : subBatches)
+		for (const SHRenderable* renderable : subBatch.Renderables)
+		{
+			renderable->GetMaterial()->ExportProperties(propsCurrPtr);
+			propsCurrPtr += singleMatPropSize;
+		}
+        
+        // Transfer to GPU
+		SHVkUtil::EnsureBufferAndCopyHostVisibleData
+		(
+			device, matPropsBuffer[frameIndex], matPropsData.get(), static_cast<uint32_t>(matPropsDataSize),
+			vk::BufferUsageFlagBits::eStorageBuffer
+		);
+
+        // This frame is updated
+        matBufferDirty[frameIndex] = false;
+	}
+
+	void SHBatch::UpdateTransformBuffer(uint32_t frameIndex)
+    {
+        if (frameIndex >= SHGraphicsConstants::NUM_FRAME_BUFFERS)
+        {
+            SHLOG_WARNING("[SHBatch] Attempted to update transform buffers with an invalid frame index.");
+            return;
+        }
+
+        // Reset Transform Data
+        transformData.clear();
+
+        // Populate on the CPU
+        for (auto& subBatch : subBatches)
+        for (const SHRenderable* renderable : subBatch.Renderables)
+        {
+            // Transform
+            auto transform = SHComponentManager::GetComponent<SHTransformComponent>(renderable->GetEID());
+            if (!transform)
+            {
+                SHLOG_WARNING("[SHBatch] Entity contianing a SHRenderable with no SHTransformComponent found!");
+                transformData.emplace_back();
+            }
+            else
+            {
+                transformData.emplace_back(transform->GetTRS());
+            }
+        }
+
+        // Transfer to GPU
+        if (transformDataBuffer[frameIndex])
+          transformDataBuffer[frameIndex]->WriteToMemory(transformData.data(), static_cast<uint32_t>(transformData.size() * sizeof(SHMatrix)), 0, 0);
+    }
+
+    void SHBatch::Build(Handle<SHVkLogicalDevice> _device, uint32_t frameIndex)
+    {
+        if (frameIndex >= SHGraphicsConstants::NUM_FRAME_BUFFERS)
+        {
+            SHLOG_WARNING("[SHBatch] Attempted to update build batch buffers with an invalid frame index.");
+            return;
+        }
+
         // No need to build as there are no changes
-        if (!isDirty)
+        if (!isDirty[frameIndex])
             return;
 
         // Count number of elements
@@ -99,7 +226,9 @@ namespace SHADE
             numTotalElements += subBatch.Renderables.size();
         }
 
-        // Generate CPU buffers
+        // Generate CPU buffers if there are changes
+        if (isCPUBuffersDirty)
+        {
             // - Draw data
             drawData.reserve(subBatches.size());
             drawData.clear();
@@ -114,7 +243,6 @@ namespace SHADE
 			    vk::ShaderStageFlagBits::eFragment
 		    );
             const bool EMPTY_MAT_PROPS = !SHADER_INFO;
-        Byte singleMatPropSize = 0;
             Byte matPropTotalBytes = 0;
             if (!EMPTY_MAT_PROPS)
             {
@@ -146,7 +274,17 @@ namespace SHADE
                 for (const SHRenderable* renderable : subBatch.Renderables)
                 {
                     // Transform
-                transformData.emplace_back(renderable->TransformMatrix);
+                    auto transform = SHComponentManager::GetComponent_s<SHTransformComponent>(renderable->GetEID());
+                    if (!transform)
+                    {
+                        SHLOG_WARNING("[SHBatch] Entity contianing a SHRenderable with no SHTransformComponent found!");
+                        transformData.emplace_back();
+                    }
+                    else
+                    {
+                        transformData.emplace_back(transform->GetTRS());
+                    }
+                   
                     // Material Properties
                     if (!EMPTY_MAT_PROPS)
                     {
@@ -156,51 +294,65 @@ namespace SHADE
                 }
             }
 
+            // Successfully update CPU buffers
+            isCPUBuffersDirty = false;
+        }
+
         // Send all buffered data to the GPU buffers
         using BuffUsage = vk::BufferUsageFlagBits;
         // - Draw Data
-        if (drawDataBuffer)
-            drawDataBuffer->Unmap();
         const uint32_t DRAW_DATA_BYTES = static_cast<uint32_t>(drawData.size() * sizeof(vk::DrawIndexedIndirectCommand));
         SHVkUtil::EnsureBufferAndCopyHostVisibleData
         (
-            device, drawDataBuffer, drawData.data(), DRAW_DATA_BYTES,
+            _device, drawDataBuffer[frameIndex], drawData.data(), DRAW_DATA_BYTES,
             BuffUsage::eIndirectBuffer
         );
-        drawDataBuffer->Map();
         // - Transform Buffer
-        if (transformDataBuffer)
-            transformDataBuffer->Unmap();
         const uint32_t TF_DATA_BYTES = static_cast<uint32_t>(transformData.size() * sizeof(SHMatrix));
         SHVkUtil::EnsureBufferAndCopyHostVisibleData
         (
-            device, transformDataBuffer, transformData.data(), TF_DATA_BYTES,
+            _device, transformDataBuffer[frameIndex], transformData.data(), TF_DATA_BYTES,
             BuffUsage::eVertexBuffer
         );
-        transformDataBuffer->Map();
         // - Material Properties Buffer
-        if (!EMPTY_MAT_PROPS)
+        if (matPropsData)
         {
-            if (matPropsBuffer)
-                matPropsBuffer->Unmap();
             SHVkUtil::EnsureBufferAndCopyHostVisibleData
             (
-                device, matPropsBuffer, matPropsData.get(), static_cast<uint32_t>(matPropTotalBytes),
+                _device, matPropsBuffer[frameIndex], matPropsData.get(), static_cast<uint32_t>(matPropsDataSize),
                 BuffUsage::eStorageBuffer
             );
-            matPropsBuffer->Map();
         }
 
-        isDirty = false;
+        isDirty[frameIndex] = false;
+
+        // Save logical device
+        this->device = _device;
     }
 
     /*---------------------------------------------------------------------------------*/
     /* SHBatch - Usage Functions                                                       */
     /*---------------------------------------------------------------------------------*/
-    void SHBatch::Draw(Handle<SHVkCommandBuffer> cmdBuffer)
+    void SHBatch::Draw(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex)
     {
+        if (frameIndex >= SHGraphicsConstants::NUM_FRAME_BUFFERS)
+        {
+            SHLOG_WARNING("[SHBatch] Attempted to draw a batch with an invalid frame index.");
+            return;
+        }
+
         cmdBuffer->BindPipeline(pipeline);
-        cmdBuffer->BindVertexBuffer(SHGraphicsConstants::VertexBufferBindings::TRANSFORM, transformDataBuffer, 0);
+        cmdBuffer->BindVertexBuffer(SHGraphicsConstants::VertexBufferBindings::TRANSFORM, transformDataBuffer[frameIndex], 0);
-        cmdBuffer->DrawMultiIndirect(drawDataBuffer, static_cast<uint32_t>(drawData.size()));
+        cmdBuffer->DrawMultiIndirect(drawDataBuffer[frameIndex], static_cast<uint32_t>(drawData.size()));
+    }
+
+    /*---------------------------------------------------------------------------------*/
+    /* SHBatch - Helper Functions                                                      */
+    /*---------------------------------------------------------------------------------*/
+    void SHBatch::setAllDirtyFlags()
+    {
+        for (bool& dirt : isDirty)
+            dirt = true;
+        isCPUBuffersDirty = true;
     }
 }

SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.h

@@ -14,12 +14,14 @@ of DigiPen Institute of Technology is prohibited.
 
 // STL Includes
 #include <unordered_set>
+#include <array>
 // External Dependencies
 #include "Graphics/SHVulkanIncludes.h"
 // Project Includes
 #include "Resource/Handle.h"
 #include "Graphics/MiddleEnd/Interface/SHMaterial.h"
 #include "Math/SHMatrix.h"
+#include "Graphics/MiddleEnd/Interface/SHGraphicsConstants.h"
 
 namespace SHADE
 {
@@ -32,6 +34,7 @@ namespace SHADE
     class SHMesh;
     class SHRenderable;
     class SHVkLogicalDevice;
+    class SHMaterialInstance;
 
     /*---------------------------------------------------------------------------------*/
     /* Type Definitions                                                                */
@@ -71,8 +74,10 @@ namespace SHADE
         void Add(const SHRenderable* renderable);
         void Remove(const SHRenderable* renderable);
         void Clear();
-        void Build(Handle<SHVkLogicalDevice> device);
+        void UpdateMaterialBuffer(uint32_t frameIndex);
-        void Draw(Handle<SHVkCommandBuffer> cmdBuffer);
+        void UpdateTransformBuffer(uint32_t frameIndex);
+        void Build(Handle<SHVkLogicalDevice> device, uint32_t frameIndex);
+        void Draw(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex);
 
         /*-----------------------------------------------------------------------------*/
         /* Getter Functions                                                            */
@@ -83,19 +88,30 @@ namespace SHADE
         /*-----------------------------------------------------------------------------*/
         /* Data Members                                                                */
         /*-----------------------------------------------------------------------------*/
+        // Resources
+        Handle<SHVkLogicalDevice> device;
         // Batch Properties
         Handle<SHVkPipeline> pipeline;
+        std::unordered_set<Handle<SHMaterialInstance>> referencedMatInstances;
+        std::array<bool, SHGraphicsConstants::NUM_FRAME_BUFFERS> matBufferDirty;
         // Batch Tree
         std::vector<SHSubBatch> subBatches;
-        bool isDirty = true;
+        std::array<bool, SHGraphicsConstants::NUM_FRAME_BUFFERS> isDirty;
         // CPU Buffers
         std::vector<vk::DrawIndexedIndirectCommand> drawData;
         std::vector<SHMatrix>                       transformData;
         std::unique_ptr<char>                       matPropsData;
         Byte                                        matPropsDataSize = 0;
+		Byte                                        singleMatPropSize = 0;
+        bool isCPUBuffersDirty                                       = true;
         // GPU Buffers
-        Handle<SHVkBuffer> drawDataBuffer;
+        std::array<Handle<SHVkBuffer>, SHGraphicsConstants::NUM_FRAME_BUFFERS> drawDataBuffer;
-        Handle<SHVkBuffer> transformDataBuffer;
+        std::array<Handle<SHVkBuffer>, SHGraphicsConstants::NUM_FRAME_BUFFERS> transformDataBuffer;
-        Handle<SHVkBuffer> matPropsBuffer;
+        std::array<Handle<SHVkBuffer>, SHGraphicsConstants::NUM_FRAME_BUFFERS> matPropsBuffer;
+
+        /*-----------------------------------------------------------------------------*/
+        /* Helper Functions                                                            */
+        /*-----------------------------------------------------------------------------*/
+        void setAllDirtyFlags();
     };
 }

SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatcher.cpp

@@ -91,12 +91,12 @@ namespace SHADE
         (*superBatch)->Remove(renderable);
     }
 
-    void SHBatcher::FinaliseBatches(Handle<SHVkLogicalDevice> device)
+    void SHBatcher::FinaliseBatches(Handle<SHVkLogicalDevice> device, uint32_t frameIndex)
     {
         // Build SuperBatches
         for (auto& batch : superBatches)
         {
-            batch->Build(device);
+            batch->Build(device, frameIndex);
         }
     }
 
@@ -109,6 +109,14 @@ namespace SHADE
         superBatches.clear();
     }
 
+	void SHBatcher::UpdateBuffers(uint32_t frameIndex)
+    {
+        for (auto& batch : superBatches)
+        {
+            batch->UpdateBuffers(frameIndex);
+        }
+    }
+
     void SHBatcher::RegisterSuperBatch(Handle<SHSuperBatch> superBatch)
     {
         superBatches.emplace_back(superBatch);

SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatcher.h

@@ -51,8 +51,9 @@ namespace SHADE
         void PrepareBatches();
         void AddToBatch(SHRenderable const* renderable);
         void RemoveFromBatch(SHRenderable const* renderable);
-        void FinaliseBatches(Handle<SHVkLogicalDevice> device);
+        void FinaliseBatches(Handle<SHVkLogicalDevice> device, uint32_t frameIndex);
         void ClearBatches();
+        void UpdateBuffers(uint32_t frameIndex);
         void RegisterSuperBatch(Handle<SHSuperBatch> superBatch);
         void DeregisterSuperBatch(Handle<SHSuperBatch> superBatch);
 

SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHSuperBatch.cpp

@@ -78,21 +78,30 @@ namespace SHADE
         batches.clear();
     }
 
-    void SHSuperBatch::Build(Handle<SHVkLogicalDevice> device) noexcept
+	void SHSuperBatch::UpdateBuffers(uint32_t frameIndex)
+    {
+        for (auto& batch : batches)
+        {
+			batch.UpdateMaterialBuffer(frameIndex);
+            batch.UpdateTransformBuffer(frameIndex);
+        }
+    }
+
+    void SHSuperBatch::Build(Handle<SHVkLogicalDevice> device, uint32_t frameIndex) noexcept
     {
         // Build all batches
         for (auto& batch : batches)
         {
-            batch.Build(device);
+            batch.Build(device, frameIndex);
         }
     }
 
-    void SHSuperBatch::Draw(Handle<SHVkCommandBuffer> cmdBuffer) noexcept
+    void SHSuperBatch::Draw(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex) noexcept
     {
         // Build all batches
         for (auto& batch : batches)
         {
-            batch.Draw(cmdBuffer);
+            batch.Draw(cmdBuffer, frameIndex);
         }
     }
 

SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHSuperBatch.h

@@ -55,8 +55,9 @@ namespace SHADE
         void Add(const SHRenderable* renderable) noexcept;
         void Remove(const SHRenderable* renderable) noexcept;
 		void Clear() noexcept;
-        void Build(Handle<SHVkLogicalDevice> device) noexcept;
+        void UpdateBuffers(uint32_t frameIndex);
-        void Draw(Handle<SHVkCommandBuffer> cmdBuffer) noexcept;
+        void Build(Handle<SHVkLogicalDevice> device, uint32_t frameIndex) noexcept;
+        void Draw(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex) noexcept;
 
         /*-----------------------------------------------------------------------------*/
         /* Getter Functions                                                            */

SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.cpp

@@ -2,6 +2,7 @@
 #include "SHGraphicsGlobalData.h"
 #include "Graphics/Devices/SHVkLogicalDevice.h"
 #include "Graphics/Pipeline/SHPipelineState.h"
+#include "Graphics/Pipeline/SHVkPipelineLayout.h"
 #include "Graphics/Descriptors/SHVkDescriptorSetLayout.h"
 
 namespace SHADE
@@ -27,7 +28,7 @@ namespace SHADE
     };
 
     // For global data (generic data and textures)
-    Handle<SHVkDescriptorSetLayout> staticGlobalLayout = logicalDevice->CreateDescriptorSetLayout({ genericDataBinding, texturesBinding });
+    Handle<SHVkDescriptorSetLayout> staticGlobalLayout = logicalDevice->CreateDescriptorSetLayout(SHGraphicsConstants::DescriptorSetIndex::STATIC_GLOBALS,{ genericDataBinding, texturesBinding });
 
     SHVkDescriptorSetLayout::Binding lightBinding
     {
@@ -38,7 +39,7 @@ namespace SHADE
     };
 
     // For Dynamic global data (lights)
-    Handle<SHVkDescriptorSetLayout> dynamicGlobalLayout = logicalDevice->CreateDescriptorSetLayout({ lightBinding });
+    Handle<SHVkDescriptorSetLayout> dynamicGlobalLayout = logicalDevice->CreateDescriptorSetLayout(SHGraphicsConstants::DescriptorSetIndex::DYNAMIC_GLOBALS, { lightBinding });
 
     SHVkDescriptorSetLayout::Binding cameraDataBinding
     {
@@ -49,7 +50,7 @@ namespace SHADE
     };
 
     // For High frequency global data (camera)
-    Handle<SHVkDescriptorSetLayout> cameraDataGlobalLayout = logicalDevice->CreateDescriptorSetLayout({ cameraDataBinding });
+    Handle<SHVkDescriptorSetLayout> cameraDataGlobalLayout = logicalDevice->CreateDescriptorSetLayout(SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS, { cameraDataBinding });
 
     SHVkDescriptorSetLayout::Binding materialDataBinding
     {
@@ -60,12 +61,15 @@ namespace SHADE
     };
 
     // For High frequency global data (camera)
-    Handle<SHVkDescriptorSetLayout> materialDataPerInstanceLayout = logicalDevice->CreateDescriptorSetLayout({ materialDataBinding });
+    Handle<SHVkDescriptorSetLayout> materialDataPerInstanceLayout = logicalDevice->CreateDescriptorSetLayout(SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE, { materialDataBinding });
 
     globalDescSetLayouts.push_back(staticGlobalLayout);
     globalDescSetLayouts.push_back(dynamicGlobalLayout);
     globalDescSetLayouts.push_back(cameraDataGlobalLayout);
     globalDescSetLayouts.push_back(materialDataPerInstanceLayout);
+
+
+    dummyPipelineLayout = logicalDevice->CreatePipelineLayoutDummy(SHPipelineLayoutParamsDummy{globalDescSetLayouts});
   }
 
   void SHGraphicsGlobalData::InitDefaultVertexInputState(void) noexcept
@@ -94,4 +98,9 @@ namespace SHADE
     return defaultVertexInputState;
   }
 
+  Handle<SHVkPipelineLayout> SHGraphicsGlobalData::GetDummyPipelineLayout(void) const noexcept
+  {
+    return dummyPipelineLayout;
+  }
+
 }

SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.h

@@ -9,6 +9,7 @@ namespace SHADE
   class SHVkLogicalDevice;
   class SHVkDescriptorSetLayout;
   class SHVkDescriptorSetGroup;
+  class SHVkPipelineLayout;
 
   class SH_API SHGraphicsGlobalData
   {
@@ -22,6 +23,10 @@ namespace SHADE
     //! Default vertex input state (used by everything).
     SHVertexInputState                           defaultVertexInputState;
 
+    //! Since we want to bind global data but can't do so without a pipeline layout,
+    //! we create a dummy pipeline layout to use it for binding.
+    Handle<SHVkPipelineLayout>                   dummyPipelineLayout;
+
     void InitDescSetLayouts         (Handle<SHVkLogicalDevice> logicalDevice) noexcept;
     void InitDefaultVertexInputState(void) noexcept;
   public:
@@ -35,5 +40,6 @@ namespace SHADE
     /*-----------------------------------------------------------------------*/
     std::vector<Handle<SHVkDescriptorSetLayout>> const& GetDescSetLayouts (void) const noexcept;
     SHVertexInputState const&                           GetDefaultViState (void) const noexcept;
+    Handle<SHVkPipelineLayout>                          GetDummyPipelineLayout (void) const noexcept;
   };
 }

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

@@ -26,18 +26,18 @@ namespace SHADE
         const SHVec3 UP = SHVec3::Cross(right, view);
 	    
         viewMatrix = SHMatrix::Identity;
-		viewMatrix(0, 0) =  right[0];
+        viewMatrix(0, 0) =  UP[0];
-		viewMatrix(1, 0) =  right[1];
+        viewMatrix(1, 0) =  UP[1];
-		viewMatrix(2, 0) =  right[2];
+        viewMatrix(2, 0) =  UP[2];
-		viewMatrix(0, 1) =  UP[0];
+        viewMatrix(0, 1) =  right[0];
-		viewMatrix(1, 1) =  UP[1];
+        viewMatrix(1, 1) =  right[1];
-		viewMatrix(2, 1) =  UP[2];
+        viewMatrix(2, 1) =  right[2];
-		viewMatrix(0, 2) = -view[0];
+        viewMatrix(0, 2) =  view[0];
-		viewMatrix(1, 2) = -view[1];
+        viewMatrix(1, 2) =  view[1];
-		viewMatrix(2, 2) = -view[2];
+        viewMatrix(2, 2) =  view[2];
-		viewMatrix(3, 0) = -right.Dot(pos);
+        viewMatrix(3, 0) = -UP.Dot(pos);
-		viewMatrix(3, 1) = -UP.Dot(pos);
+        viewMatrix(3, 1) = -right.Dot(pos);
-		viewMatrix(3, 2) =  view.Dot(pos);
+        viewMatrix(3, 2) = -view.Dot(pos);
         
         isDirty = true;
 	}

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

@@ -29,6 +29,7 @@ of DigiPen Institute of Technology is prohibited.
 #include "Graphics/MiddleEnd/Batching/SHSuperBatch.h"
 #include "SHGraphicsConstants.h"
 #include "Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.h"
+#include "Graphics/Buffers/SHVkBuffer.h"
 
 namespace SHADE
 {
@@ -113,7 +114,8 @@ namespace SHADE
     screenCamera->SetLookAt(SHVec3(0.0f, 0.0f, -1.0f), SHVec3(0.0f, 0.0f, 1.0f), SHVec3(0.0f, 1.0f, 0.0f));
     screenCamera->SetOrthographic(static_cast<float>(windowDims.first), static_cast<float>(windowDims.second), 0.01f, 100.0f);
     worldCamera = resourceManager.Create<SHCamera>();
-    worldCamera->SetLookAt(SHVec3(0.0f, 0.0f, -1.0f), SHVec3(0.0f, 0.0f, 1.0f), SHVec3(0.0f, 1.0f, 0.0f));
+    //worldCamera->SetLookAt(SHVec3(1.0f, 0.0f, -1.0f), SHVec3(0.0f, 0.0f, 2.0f), SHVec3(0.0f, 1.0f, 0.0f));
+    worldCamera->SetLookAt(SHVec3(0.0f, 5.0f, -1.0f), SHVec3(0.0f, 0.0f, 2.0f), SHVec3(0.0f, 1.0f, 0.0f));
     worldCamera->SetPerspective(90.0f, static_cast<float>(windowDims.first), static_cast<float>(windowDims.second), 0.0f, 100.0f);
 
     // Create Default Viewport
@@ -129,7 +131,7 @@ namespace SHADE
     }
 
     // Initialize world render graph
-    worldRenderGraph->Init(device, swapchain, renderContextCmdPools, globalData);
+    worldRenderGraph->Init(device, swapchain, globalData);
     //worldRenderGraph->AddResource("Position", SH_ATT_DESC_TYPE::COLOR, windowDims.first, windowDims.second, vk::Format::eR16G16B16A16Sfloat);
     //worldRenderGraph->AddResource("Normals", SH_ATT_DESC_TYPE::COLOR, windowDims.first, windowDims.second, vk::Format::eR16G16B16A16Sfloat);
     //worldRenderGraph->AddResource("Composite", SH_ATT_DESC_TYPE::COLOR, windowDims.first, windowDims.second, vk::Format::eR16G16B16A16Sfloat);
@@ -148,9 +150,9 @@ namespace SHADE
     //compositeSubpass->AddInput("Position");
 
     // TODO: Use macro to add this node when SH_EDITOR is enabled
-    //auto imguiNode = worldRenderGraph->AddNode("ImGui Node", { "Present" }, {}); 
+    auto imguiNode = worldRenderGraph->AddNode("ImGui Node", { "Present" }, {"G-Buffer"});
-    //auto imguiSubpass = imguiNode->AddSubpass("ImGui Draw");
+    auto imguiSubpass = imguiNode->AddSubpass("ImGui Draw");
-    //imguiSubpass->AddColorOutput("Present");
+    imguiSubpass->AddColorOutput("Present");
 
     worldRenderGraph->Generate();
 
@@ -167,7 +169,7 @@ namespace SHADE
     debugWorldRenderer->SetCamera(worldCamera);*/
 
     // Add world renderer to default viewport
-    worldRenderer = defaultViewport->AddRenderer(resourceManager, swapchain->GetNumImages(), descPool, globalData->GetDescSetLayouts()[SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS], worldRenderGraph);
+    worldRenderer = defaultViewport->AddRenderer(resourceManager, swapchain->GetNumImages(), renderContextCmdPools, descPool, globalData->GetDescSetLayouts()[SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS], worldRenderGraph);
     worldRenderer->SetCamera(worldCamera);
 
 
@@ -203,6 +205,7 @@ namespace SHADE
   {
     // Frame data for the current frame
     auto const& frameData = renderContext.GetCurrentFrameData();
+    uint32_t frameIndex = renderContext.GetCurrentFrame();
 
     // semaphore index. This is for render graphs to have semaphores to signal that the next render graph will use to wait on. 
     bool semIndex = 0;
@@ -219,7 +222,6 @@ namespace SHADE
 
     renderContext.ResetFence();
 
-
     // For every viewport 
     for (int vpIndex = 0; vpIndex < static_cast<int>(viewports.size()); ++vpIndex)
     {
@@ -228,16 +230,42 @@ namespace SHADE
       // For every renderer
       for (int renIndex = 0; renIndex < static_cast<int>(renderers.size()); ++renIndex)
       {
-        // Draw first
+        /*-----------------------------------------------------------------------*/
-        renderers[renIndex]->Draw(renderContext.GetCurrentFrame(), MESH_DATA);
+        /* Renderer start                                                        */
+        /*-----------------------------------------------------------------------*/
+        // get command buffer of the renderer in the current frame 
+        auto currentCmdBuffer = renderers[renIndex]->GetCommandBuffer(frameIndex);
 
-        // get render graph 
+        // Begin recording the command buffer
-        auto rg = renderers[renIndex]->GetRenderGraph();
+        currentCmdBuffer->BeginRecording();
+
+        currentCmdBuffer->ForceSetPipelineLayout(globalData->GetDummyPipelineLayout());
+
+        // Bind all the buffers required for meshes
+        for (auto& [buffer, bindingPoint] : MESH_DATA)
+        {
+          if (buffer->GetUsageBits() & vk::BufferUsageFlagBits::eVertexBuffer)
+            currentCmdBuffer->BindVertexBuffer(bindingPoint, buffer, 0);
+          else if (buffer->GetUsageBits() & vk::BufferUsageFlagBits::eIndexBuffer)
+            currentCmdBuffer->BindIndexBuffer(buffer, 0);
+        }
+
+        // bind camera data
+        renderers[renIndex]->UpdateDataAndBind(currentCmdBuffer, frameIndex);
+
+        // Draw first
+        renderers[renIndex]->Draw(frameIndex);
+
+        // End the command buffer recording
+        currentCmdBuffer->EndRecording();
+        /*-----------------------------------------------------------------------*/
+        /* Renderer end                                                          */
+        /*-----------------------------------------------------------------------*/
 
         // submit a command buffer from the current render graph and make it wait for the previous render graph before submitting it to GPU. 
         graphicsQueue->SubmitCommandBuffer
         (
-          { rg->GetCommandBuffer(renderContext.GetCurrentFrame()) },
+          { currentCmdBuffer },
           { (vpIndex == viewports.size() - 1 && renIndex == renderers.size() - 1) ? frameData.semRenderFinishHdl : graphSemaphores[!semIndex] },
           { (vpIndex == 0 && renIndex == 0) ? frameData.semImgAvailableHdl : graphSemaphores[semIndex] },
           { vk::PipelineStageFlagBits::eColorAttachmentOutput },
@@ -279,7 +307,7 @@ namespace SHADE
     for (auto vp : viewports)
     for (auto renderer : vp->GetRenderers())
     {
-      renderer->GetRenderGraph()->FinaliseBatch();
+      renderer->GetRenderGraph()->FinaliseBatch(renderContext.GetCurrentFrame());
     }
 
     // Resize
@@ -387,14 +415,19 @@ namespace SHADE
     resourceManager.Free(material);
   }
   
-  Handle<SHMaterialInstance> SHGraphicsSystem::AddMaterialInstance(Handle<SHMaterial> material)
+  Handle<SHMaterialInstance> SHGraphicsSystem::AddOrGetBaseMaterialInstance(Handle<SHMaterial> material)
   {
-    return resourceManager.Create<SHMaterialInstance>(material);
+      return materialInstanceCache.CreateOrGet(resourceManager, material);
   }
   
-  SHADE::Handle<SHADE::SHMaterialInstance> SHGraphicsSystem::AddMaterialInstance()
+  SHADE::Handle<SHADE::SHMaterialInstance> SHGraphicsSystem::AddOrGetBaseMaterialInstance()
   {
-      return AddMaterialInstance(defaultMaterial);
+      return AddOrGetBaseMaterialInstance(defaultMaterial);
+  }
+
+  SHADE::Handle<SHADE::SHMaterialInstance> SHGraphicsSystem::AddMaterialInstanceCopy(Handle<SHMaterialInstance> materialInst)
+  {
+	  return resourceManager.Create<SHMaterialInstance>(materialInst->GetBaseMaterial());
   }
 
   void SHGraphicsSystem::RemoveMaterialInstance(Handle<SHMaterialInstance> materialInstance)

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

@@ -28,6 +28,7 @@ of DigiPen Institute of Technology is prohibited.
 #include "Graphics/MiddleEnd/Shaders/SHShaderSourceLibrary.h"
 #include "Graphics/MiddleEnd/Shaders/SHShaderModuleLibrary.h"
 #include "SHMeshLibrary.h"
+#include "Graphics/MiddleEnd/Materials/SHMaterialInstanceCache.h"
 
 namespace SHADE
 {
@@ -119,9 +120,10 @@ namespace SHADE
     /* Material Creation Functions                                                 */
     /*-----------------------------------------------------------------------------*/
     Handle<SHMaterial> AddMaterial(Handle<SHVkShaderModule> vertShader, Handle<SHVkShaderModule> fragShader, Handle<SHSubpass> subpass);
-    void RemoveMaterial(Handle<SHMaterial> material);;
+    void RemoveMaterial(Handle<SHMaterial> material);
-    Handle<SHMaterialInstance> AddMaterialInstance();
+    Handle<SHMaterialInstance> AddOrGetBaseMaterialInstance();
-    Handle<SHMaterialInstance> AddMaterialInstance(Handle<SHMaterial> material);
+    Handle<SHMaterialInstance> AddOrGetBaseMaterialInstance(Handle<SHMaterial> material);
+    Handle<SHMaterialInstance> AddMaterialInstanceCopy(Handle<SHMaterialInstance> materialInst);
     void RemoveMaterialInstance(Handle<SHMaterialInstance> materialInstance);
     
     /*-----------------------------------------------------------------------------*/
@@ -230,6 +232,7 @@ namespace SHADE
     // Middle End Resources
 	ResourceManager                                           resourceManager;
     SHMeshLibrary                                             meshLibrary;
+    SHMaterialInstanceCache                                   materialInstanceCache;
     // Viewports 
     Handle<SHViewport>                                        defaultViewport;    // Whole screen
     std::vector<Handle<SHViewport>>                           viewports;          // Additional viewports

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

@@ -38,7 +38,7 @@ namespace SHADE
     dataStore.reset();
   }
 
-  void SHMaterialInstance::ExportProperties(void* dest) const
+  void SHMaterialInstance::ExportProperties(void* dest)
   {
     assert(dataStore != nullptr);
 
@@ -62,6 +62,9 @@ namespace SHADE
       const auto DATA_OFFSET = variable->offset;
       memcpy(static_cast<char*>(dest) + DATA_OFFSET, dataStore.get() + data.StoredDataOffset, data.DataSize);
     }
+
+    // Data was exported so unflag
+    dataWasChanged = false;
   }
 
   /*---------------------------------------------------------------------------------*/

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

@@ -62,12 +62,13 @@ namespace SHADE
     template<typename T>
     const T& GetProperty(const std::string& key) const;
     void ResetProperties() noexcept;
-    void ExportProperties(void* dest) const;
+    void ExportProperties(void* dest);
 
     /*-----------------------------------------------------------------------------*/
     /* Getter Functions                                                            */
     /*-----------------------------------------------------------------------------*/
-    Handle<SHMaterial> GetBaseMaterial() const { return baseMaterial; } 
+    Handle<SHMaterial> GetBaseMaterial() const noexcept { return baseMaterial; } 
+    bool               HasChanged() const noexcept { return dataWasChanged; }
 
     private:
     /*-----------------------------------------------------------------------------*/
@@ -77,6 +78,7 @@ namespace SHADE
     std::vector<OverrideData> overrideData;
     std::unique_ptr<char>     dataStore;
     size_t                    dataStoreSize = 0;
+    bool                      dataWasChanged = false;
 
     /*-----------------------------------------------------------------------------*/
     /* Helper Functions                                                            */

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

@@ -53,6 +53,9 @@ namespace SHADE
 
     // Save the override data information
     overrideData.emplace_back(std::move(od));
+
+    // Flag
+	dataWasChanged = true;
   }
   template<typename T>
   T& SHMaterialInstance::GetProperty(const std::string& key)

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

@@ -27,7 +27,6 @@ namespace SHADE
     sharedMaterial = {};
     material = {};
     oldMaterial = {};
-
   }
 
   void SHRenderable::OnDestroy()
@@ -82,7 +81,7 @@ namespace SHADE
     if (!material)
     {
       SHGraphicsSystem* gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
-      material = gfxSystem->AddMaterialInstance(sharedMaterial->GetBaseMaterial());
+      material = gfxSystem->AddOrGetBaseMaterialInstance(sharedMaterial->GetBaseMaterial());
     }
 
     return material;
@@ -93,5 +92,4 @@ namespace SHADE
       materialChanged = false;
       oldMaterial = {};
   }
-
 }

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

@@ -66,7 +66,6 @@ namespace SHADE
       /* Data Members                                                                  */
       /*-------------------------------------------------------------------------------*/
       Handle<SHMesh>             Mesh;
-      SHMatrix                   TransformMatrix; // TODO: Replace with Transform component
 
       private:
       /*-------------------------------------------------------------------------------*/

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

@@ -20,20 +20,33 @@ of DigiPen Institute of Technology is prohibited.
 #include "SHMaterial.h"
 #include "Graphics/MiddleEnd/Interface/SHGraphicsConstants.h"
 #include "Graphics/Descriptors/SHVkDescriptorSetGroup.h"
+#include "Graphics/Buffers/SHVkBuffer.h"
 
 namespace SHADE
 {
   /*-----------------------------------------------------------------------------------*/
   /* Constructor/Destructors                                                           */
   /*-----------------------------------------------------------------------------------*/
-  SHRenderer::SHRenderer(Handle<SHVkLogicalDevice> logicalDevice, uint32_t numFrames, Handle<SHVkDescriptorPool> descriptorPool, Handle<SHVkDescriptorSetLayout> cameraDescLayout, Handle<SHViewport> viewport, Handle<SHRenderGraph> renderGraph)
+  SHRenderer::SHRenderer(Handle<SHVkLogicalDevice> logicalDevice, uint32_t numFrames, std::vector<Handle<SHVkCommandPool>>& cmdPools, Handle<SHVkDescriptorPool> descriptorPool, Handle<SHVkDescriptorSetLayout> cameraDescLayout, Handle<SHViewport> viewport, Handle<SHRenderGraph> renderGraph)
   : viewport    { viewport }
   , renderGraph { renderGraph } 
   {
-    cameraDescriptorSet = logicalDevice->CreateDescriptorSetGroup(descriptorPool, { cameraDescLayout }, { 1 });
+    commandBuffers.resize(static_cast<std::size_t>(numFrames));
-    cpuCameraData.resize(numFrames);
+
+    for (uint32_t i = 0; i < commandBuffers.size(); ++i)
+      commandBuffers[i] = cmdPools[i]->RequestCommandBuffer(SH_CMD_BUFFER_TYPE::PRIMARY);
+
+    cameraDescriptorSet = descriptorPool->Allocate({ cameraDescLayout }, { 1 });
 
    cameraDataAlignedSize = logicalDevice->PadUBOSize(sizeof(SHShaderCameraData));
+
+   cameraBuffer = logicalDevice->CreateBuffer(cameraDataAlignedSize * numFrames, nullptr, cameraDataAlignedSize * numFrames, vk::BufferUsageFlagBits::eUniformBuffer, VMA_MEMORY_USAGE_AUTO, VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT);
+
+   std::array cameraBufferArray{cameraBuffer};
+
+   cameraDescriptorSet->ModifyWriteDescBuffer(SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS, SHGraphicsConstants::DescriptorSetBindings::CAMERA_DATA, std::span<Handle<SHVkBuffer>>{ cameraBufferArray.data(), cameraBufferArray.size()}, 0, sizeof (SHShaderCameraData));
+
+   cameraDescriptorSet->UpdateDescriptorSetBuffer(SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS, SHGraphicsConstants::DescriptorSetBindings::CAMERA_DATA);
   }
 
   /*-----------------------------------------------------------------------------------*/
@@ -47,21 +60,33 @@ namespace SHADE
   /*-----------------------------------------------------------------------------------*/
   /* Drawing Functions                                                                 */
   /*-----------------------------------------------------------------------------------*/
-  void SHRenderer::Draw(uint32_t frameIndex, std::initializer_list<std::pair<Handle<SHVkBuffer>, uint32_t>> graphScopeBuffers) noexcept
+  void SHRenderer::Draw(uint32_t frameIndex) noexcept
   {
-    renderGraph->Execute(frameIndex, graphScopeBuffers);
+    renderGraph->Execute(frameIndex, commandBuffers[frameIndex]);
   }
 
-  void SHRenderer::BindDescriptorSet(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex) noexcept
+  void SHRenderer::UpdateDataAndBind(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex) noexcept
   {
+    cpuCameraData.viewProjectionMatrix = camera->GetViewProjectionMatrix();
+    cameraBuffer->WriteToMemory(&cpuCameraData, sizeof(SHShaderCameraData), 0, cameraDataAlignedSize * frameIndex);
+
       std::array<uint32_t, 1> dynamicOffsets{ frameIndex * cameraDataAlignedSize };
 
     cmdBuffer->BindDescriptorSet(cameraDescriptorSet, vk::PipelineBindPoint::eGraphics, SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS, std::span{ dynamicOffsets.data(), 1 });
   }
 
+  void SHRenderer::UpdateCameraDataToBuffer(void) noexcept
+  {
+  }
+
   Handle<SHRenderGraph> SHRenderer::GetRenderGraph(void) const noexcept
   {
     return renderGraph;
   }
 
+  Handle<SHVkCommandBuffer> SHRenderer::GetCommandBuffer(uint32_t frameIndex) const noexcept
+  {
+    return commandBuffers[frameIndex];
+  }
+
 }

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

@@ -39,6 +39,7 @@ namespace SHADE
     class SHVkDescriptorSetGroup;
     class SHGraphicsGlobalData;
     class SHVkDescriptorPool;
+    class SHVkBuffer;
 
     struct SHShaderCameraData
     {
@@ -63,7 +64,7 @@ namespace SHADE
         /*-----------------------------------------------------------------------------*/
         /* Constructor/Destructors                                                     */
         /*-----------------------------------------------------------------------------*/
-        SHRenderer(Handle<SHVkLogicalDevice> logicalDevice, uint32_t numFrames, Handle<SHVkDescriptorPool> descriptorPool, Handle<SHVkDescriptorSetLayout> cameraDescLayout, Handle<SHViewport> viewport, Handle<SHRenderGraph> renderGraph);
+        SHRenderer(Handle<SHVkLogicalDevice> logicalDevice, uint32_t numFrames, std::vector<Handle<SHVkCommandPool>>& cmdPools, Handle<SHVkDescriptorPool> descriptorPool, Handle<SHVkDescriptorSetLayout> cameraDescLayout, Handle<SHViewport> viewport, Handle<SHRenderGraph> renderGraph);
 
         /*-----------------------------------------------------------------------------*/
         /* Camera Registration                                                         */
@@ -73,13 +74,15 @@ namespace SHADE
         /*-----------------------------------------------------------------------------*/
         /* Drawing Functions                                                           */
         /*-----------------------------------------------------------------------------*/
-        void Draw(uint32_t frameIndex, std::initializer_list<std::pair<Handle<SHVkBuffer>, uint32_t>> graphScopeBuffers) noexcept;
+        void Draw(uint32_t frameIndex) noexcept;
-        void BindDescriptorSet (Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex) noexcept;
+        void UpdateDataAndBind (Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex) noexcept;
+        void UpdateCameraDataToBuffer (void) noexcept;
 
         /*-----------------------------------------------------------------------------*/
         /* Setters and Getters                                                         */
         /*-----------------------------------------------------------------------------*/
         Handle<SHRenderGraph> GetRenderGraph (void) const noexcept;
+        Handle<SHVkCommandBuffer> GetCommandBuffer(uint32_t frameIndex) const noexcept;
 
       private:
         /*-----------------------------------------------------------------------------*/
@@ -92,7 +95,16 @@ namespace SHADE
         Handle<SHCamera>                camera;	
         Handle<SHRenderGraph>           renderGraph;
         Handle<SHVkDescriptorSetGroup>  cameraDescriptorSet;
-        std::vector<SHShaderCameraData> cpuCameraData; 
+        Handle<SHVkBuffer>              cameraBuffer;
+
+        // we really only need 1 copy even though we need %swapchainImages copies for
+        // GPU.
+        SHShaderCameraData              cpuCameraData; 
+
+        //! Command buffers for the render graph
+        std::vector<Handle<SHVkCommandBuffer>> commandBuffers;
+
+
                 
     };
 }

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

@@ -49,10 +49,10 @@ namespace SHADE
 	/*---------------------------------------------------------------------------------*/
 	/* Renderer Registration Functions                                                 */
 	/*---------------------------------------------------------------------------------*/
-	Handle<SHRenderer> SHViewport::AddRenderer(ResourceManager& resourceManager, uint32_t numFrames, Handle<SHVkDescriptorPool> descriptorPool, Handle<SHVkDescriptorSetLayout> cameraDescLayout, Handle<SHRenderGraph> renderGraph)
+	Handle<SHRenderer> SHViewport::AddRenderer(ResourceManager& resourceManager, uint32_t numFrames, std::vector<Handle<SHVkCommandPool>>& cmdPools, Handle<SHVkDescriptorPool> descriptorPool, Handle<SHVkDescriptorSetLayout> cameraDescLayout, Handle<SHRenderGraph> renderGraph)
 	{
 		// Create the renderer
-		auto renderer = resourceManager.Create<SHRenderer>(device, numFrames, descriptorPool, cameraDescLayout, GetHandle(), renderGraph);
+		auto renderer = resourceManager.Create<SHRenderer>(device, numFrames, cmdPools, descriptorPool, cameraDescLayout, GetHandle(), renderGraph);
 
 		// Store
 		renderers.emplace_back(renderer);

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

@@ -32,6 +32,7 @@ namespace SHADE
 	class SHRenderGraph;
 	class SHVkDescriptorPool;
 	class SHVkDescriptorSetLayout;
+	class SHVkCommandPool;
 
 	/*---------------------------------------------------------------------------------*/
 	/* Type Definitions                                                                */
@@ -58,7 +59,7 @@ namespace SHADE
 		/*-----------------------------------------------------------------------------*/
 		/* Renderers Registration Functions                                            */
 		/*-----------------------------------------------------------------------------*/
-		Handle<SHRenderer> AddRenderer(ResourceManager& resourceManager, uint32_t numFrames, Handle<SHVkDescriptorPool> descriptorPool, Handle<SHVkDescriptorSetLayout> cameraDescLayout, Handle<SHRenderGraph> renderGraph);
+		Handle<SHRenderer> AddRenderer(ResourceManager& resourceManager, uint32_t numFrames, std::vector<Handle<SHVkCommandPool>>& cmdPools, Handle<SHVkDescriptorPool> descriptorPool, Handle<SHVkDescriptorSetLayout> cameraDescLayout, Handle<SHRenderGraph> renderGraph);
 		void RemoveRenderer(Handle<SHRenderer> renderer);
 
 		/*-----------------------------------------------------------------------------*/

SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialInstanceCache.cpp

@@ -0,0 +1,47 @@
+/************************************************************************************//*!
+\file           SHMaterialInstanceCache.cpp
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Sep 25, 2022
+\brief			Contains the definition of SHMaterialInstanceCache's functions.
+
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+#include "SHpch.h"
+#include "SHMaterialInstanceCache.h"
+
+#include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h"
+#include "Resource/ResourceLibrary.h"
+
+
+namespace SHADE
+{
+  /*---------------------------------------------------------------------------------*/
+  /* Usage Functions                                                                 */
+  /*---------------------------------------------------------------------------------*/
+  SHADE::Handle<SHADE::SHMaterialInstance> SHMaterialInstanceCache::CreateOrGet(ResourceManager& manager, Handle<SHMaterial> material)
+  {
+    // Check if there is already an existing instance
+    auto matInst = cache.find(material);
+    if (matInst == cache.end())
+    {
+      // Create and return
+      return cache.emplace(material, manager.Create<SHMaterialInstance>(material)).first->second;
+    }
+
+    return matInst->second;
+  }
+  
+  void SHMaterialInstanceCache::Remove(Handle<SHMaterial> material)
+  {
+    cache.erase(material);
+  }
+  
+  void SHMaterialInstanceCache::Clear()
+  {
+    cache.clear();
+  }
+}

SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialInstanceCache.h

@@ -0,0 +1,93 @@
+/************************************************************************************//*!
+\file           SHMaterialInstanceCache.h
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Sep 25, 2022
+\brief          Contains the definition of SHMaterialInstanceCache.
+
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+#pragma once
+
+// STL Includes
+#include <unordered_map>
+// Project Includes
+#include "Resource/Handle.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Forward Declarations                                                              */
+  /*-----------------------------------------------------------------------------------*/
+  class SHMaterial;
+  class SHMaterialInstance;
+  class ResourceManager;
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Type Definitions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+  /*************************************************************************************/
+  /*!
+    \brief
+      Creates and caches base SHMaterialInstances. Note that base SHMaterialInstances
+      refer to SHMaterialInstances with no overrides.
+  */
+  /*************************************************************************************/
+  class SHMaterialInstanceCache
+  {
+    public:
+    /*---------------------------------------------------------------------------------*/
+    /* Usage Functions                                                                 */
+    /*---------------------------------------------------------------------------------*/
+    /***********************************************************************************/
+    /*!
+           
+     \brief
+         
+          
+     \param material
+        Material to get the SHMaterialInstance for.
+
+     \return
+        Handle to the base SHMaterialInstance that is mapped to SHMaterial.
+                
+    */ 
+    /***********************************************************************************/
+    Handle<SHMaterialInstance> CreateOrGet(ResourceManager& manager, Handle<SHMaterial> material);
+    /***********************************************************************************/
+    /*!
+        
+     \brief
+        Removes a SHMaterialInstance from the cache with a matching material.
+     
+     \param material
+        Handle to a SHMaterial that is used to check for removal.
+        
+    */ 
+    /***********************************************************************************/
+    void Remove(Handle<SHMaterial> material);
+    /***********************************************************************************/
+    /*!
+       
+     \brief
+        Removes all SHMaterialInstances in the cache.
+            
+    */ 
+    /***********************************************************************************/
+    void Clear();
+
+    private:
+    /*---------------------------------------------------------------------------------*/
+    /* Type Definitions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    using MaterialMap = std::unordered_map<Handle<SHMaterial>, Handle<SHMaterialInstance>>;
+
+    /*---------------------------------------------------------------------------------*/
+    /* Data Members                                                                    */
+    /*---------------------------------------------------------------------------------*/
+    MaterialMap cache;
+  };
+}

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

@@ -18,7 +18,7 @@ namespace SHADE
     auto pipelineLayout = logicalDevice->CreatePipelineLayout(params);
 
     // Create the pipeline and configure the default vertex input state
-    auto newPipeline = logicalDevice->CreatePipeline(pipelineLayout, nullptr, renderpass, subpass, SH_PIPELINE_TYPE::GRAPHICS);
+    auto newPipeline = logicalDevice->CreateGraphicsPipeline(pipelineLayout, nullptr, renderpass, subpass);
     newPipeline->GetPipelineState().SetVertexInputState(globalData->GetDefaultViState());
     
     // Actually construct the pipeline

SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp

@@ -0,0 +1,142 @@
+/************************************************************************************//*!
+\file           SHTextureLibrary.cpp
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Sep 20, 2022
+\brief          Contains definitions for all of the functions of the classes that deal 
+                with storage and management of buffers for textures.
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+#include "SHpch.h"
+#include "SHTextureLibrary.h"
+
+#include "Graphics/SHVulkanIncludes.h"
+
+#include "Graphics/Devices/SHVkLogicalDevice.h"
+#include "Graphics/Buffers/SHVkBuffer.h"
+#include "Graphics/Commands/SHVkCommandBuffer.h"
+#include "Graphics/SHVkUtil.h"
+#include "Tools/SHLogger.h"
+
+namespace SHADE
+{
+    /*---------------------------------------------------------------------------------*/
+    /* Usage Functions                                                                 */
+    /*---------------------------------------------------------------------------------*/
+    Handle<SHTexture> SHTextureLibrary::Add(uint32_t pixelCount, const SHTexture::PixelChannel* const pixelData, SHTexture::TextureFormat format, uint32_t mipLevels)
+    {
+        isDirty = true;
+
+        auto handle = resourceManager.Create<SHTexture>();
+        addJobs.emplace_back(AddJob { pixelCount, pixelData, format, mipLevels });
+        return handle;
+    }
+
+    void SHTextureLibrary::Remove(Handle<SHTexture> texture)
+    {
+        if (!texture)
+            throw std::invalid_argument("Attempted to remove a Texture that did not belong to the Texture Library!");
+
+        removeJobs.emplace_back(texture);
+        isDirty = true;
+    }
+
+    void SHTextureLibrary::BuildImages(Handle<SHVkLogicalDevice> device, Handle<SHVkCommandBuffer> cmdBuffer, Handle<SHVkQueue> graphicsQueue, Handle<SHVkDescriptorPool> descPool, Handle<SHVkDescriptorSetLayout> descLayout)
+    {
+        /* Remove Textures */
+        std::vector<vk::ImageMemoryBarrier> pipelineBarriers(addJobs.size());
+
+        /* Add Textures */
+        // Transition
+        for (int i = 0; auto& job : addJobs)
+        {
+            job.Image = resourceManager.Create<SHVkImage>();
+            job.Image->PrepareImageTransitionInfo(vk::ImageLayout::eUndefined, vk::ImageLayout::eTransferDstOptimal, pipelineBarriers[i]);
+            ++i;
+        }
+        vk::PipelineStageFlagBits srcStage = vk::PipelineStageFlagBits::eTopOfPipe;
+        vk::PipelineStageFlagBits dstStage = vk::PipelineStageFlagBits::eTopOfPipe;
+        preparePipelineBarriers(vk::ImageLayout::eUndefined, vk::ImageLayout::eTransferDstOptimal, srcStage, dstStage, pipelineBarriers);
+        cmdBuffer->PipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe, vk::PipelineStageFlagBits::eTransfer, {}, {}, {}, pipelineBarriers);
+
+        // Copy
+        for (auto& job : addJobs)
+        {
+            job.Image->TransferToDeviceResource(cmdBuffer);
+        }
+
+        // Transition
+        for (int i = 0; auto & job : addJobs)
+        {
+            // Transition
+            job.Image->PrepareImageTransitionInfo(vk::ImageLayout::eTransferDstOptimal, vk::ImageLayout::eShaderReadOnlyOptimal, pipelineBarriers[i]);
+        }
+        preparePipelineBarriers(vk::ImageLayout::eTransferDstOptimal, vk::ImageLayout::eShaderReadOnlyOptimal, srcStage, dstStage, pipelineBarriers);
+        cmdBuffer->PipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe, vk::PipelineStageFlagBits::eTransfer, {}, {}, {}, pipelineBarriers);
+        
+        // Execute Commands
+        graphicsQueue->SubmitCommandBuffer({ cmdBuffer });
+        device->WaitIdle();
+
+        // Create Image View
+        for (auto& job : addJobs)
+        {
+            const SHImageViewDetails DETAILS
+            {
+                .viewType         = vk::ImageViewType::e2D,
+                .format           = job.TextureFormat,
+                .imageAspectFlags = vk::ImageAspectFlagBits::eColor,
+                .baseMipLevel     = 0,
+                .mipLevelCount    = job.MipLevels, 
+                .baseArrayLayer   = 0,
+                .layerCount       = 0
+            };
+            job.Handle->ImageView = job.Image->CreateImageView(device, job.Image, DETAILS);
+        }
+
+        // Build Descriptor
+        Handle<SHVkDescriptorSetGroup> descSetGroup = descPool->Allocate({ descLayout }, { 1 });
+        
+
+        isDirty = false;
+    }
+
+    /*---------------------------------------------------------------------------------*/
+    /* Usage Functions                                                                 */
+    /*---------------------------------------------------------------------------------*/
+    void SHTextureLibrary::preparePipelineBarriers(vk::ImageLayout oldLayout, vk::ImageLayout newLayout, vk::PipelineStageFlagBits& srcStage, vk::PipelineStageFlagBits& dstStage, std::vector<vk::ImageMemoryBarrier>& barriers)
+    {
+        if (oldLayout == vk::ImageLayout::eUndefined && newLayout == vk::ImageLayout::eTransferDstOptimal)
+        {
+            srcStage = vk::PipelineStageFlagBits::eTopOfPipe;
+            dstStage = vk::PipelineStageFlagBits::eTransfer;
+
+            for (auto& barrier : barriers)
+            {
+                barrier.srcAccessMask = vk::AccessFlagBits::eNone;
+                barrier.dstAccessMask = vk::AccessFlagBits::eTransferWrite;
+            }
+        }
+        else if (oldLayout == vk::ImageLayout::eTransferDstOptimal && newLayout == vk::ImageLayout::eShaderReadOnlyOptimal)
+        {
+            srcStage = vk::PipelineStageFlagBits::eTransfer;
+
+            // TODO, what if we want to access in compute shader
+            dstStage = vk::PipelineStageFlagBits::eFragmentShader;
+
+            for (auto& barrier : barriers)
+            {
+                barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
+                barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
+            }
+        }
+        else
+        {
+            SHLOG_ERROR("Image layouts are invalid. ");
+        }
+    }
+
+}

SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.h

@@ -0,0 +1,163 @@
+/************************************************************************************//*!
+\file           SHTextureLibrary.h
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Sep 20, 2022
+\brief          Contains definitions for all of the classes that deal with storage and
+                management of textures.
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+#pragma once
+
+// STL Includes
+#include <vector>
+// Project Includes
+#include "Resource/Handle.h"
+#include "Resource/ResourceLibrary.h"
+#include "Math/SHMath.h"
+#include "Graphics/SHVulkanIncludes.h"
+
+namespace SHADE
+{
+    /*---------------------------------------------------------------------------------*/
+    /* Forward Declarations                                                            */
+    /*---------------------------------------------------------------------------------*/
+    class SHVkBuffer;
+    class SHVkLogicalDevice;
+    class SHVkCommandBuffer;
+    class SHVkImage;
+    class SHVkImageView;
+    class SHVkQueue;
+    class SHVkDescriptorPool;
+    class SHVkDescriptorSetLayout;
+
+    /*---------------------------------------------------------------------------------*/
+    /* Type Definitions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    class SHTexture
+    {
+        public:
+        /*-----------------------------------------------------------------------------*/
+        /* Type Definitions                                                            */
+        /*-----------------------------------------------------------------------------*/
+        using PixelChannel  = float;
+        using TextureFormat = vk::Format; // TODO: Change
+        using Index         = uint32_t;
+
+        /*-----------------------------------------------------------------------------*/
+        /* Data Members                                                                */
+        /*-----------------------------------------------------------------------------*/
+        Handle<SHVkImageView> ImageView;
+        Index                 TextureArrayIndex = std::numeric_limits<Index>::max();
+    };
+    /***********************************************************************************/
+    /*!
+      \brief
+        Manages storage for all textures in the Graphics System as a single set of 
+        textures.
+    */
+    /***********************************************************************************/
+    class SHTextureLibrary
+    {
+      public:
+        /*-----------------------------------------------------------------------------*/
+        /* Usage Functions                                                             */
+        /*-----------------------------------------------------------------------------*/
+        /*******************************************************************************/
+        /*!
+        
+         \brief
+           Adds a texture to the Texture Library. But this does not mean that the 
+           textures have been added yet. A call to "BuildImages()" is required to 
+           transfer all textures into the GPU.
+        
+         \param pixelCount
+           Number of pixels in this Mesh.
+         \param positions
+           Pointer to the first in a contiguous array of SHMathVec3s that define vertex
+           positions.
+         \param format
+           Format of the texture loaded in.
+
+         \return
+          Handle to the created Texture. This is not valid to be used until a call to
+          BuildImages().
+        
+        */ 
+        /*******************************************************************************/
+        Handle<SHTexture> Add(uint32_t pixelCount, const SHTexture::PixelChannel* const pixelData, SHTexture::TextureFormat format, uint32_t mipLevels);
+        /*******************************************************************************/
+        /*! 
+         
+         \brief
+           Removes a mesh from the Texture Library. But this does not mean that the
+           textures have been removed yet.  A call to "BuildImages()" is required to 
+           finalise all changes.
+
+         \param mesh
+           Handle to the mesh to remove.
+
+        */ 
+        /*******************************************************************************/
+        void Remove(Handle<SHTexture> mesh);
+        /***************************************************************************/
+        /*! 
+         
+         \brief
+           Finalises all changes to the Texture Library into the GPU buffers.
+         
+         \param device
+           Device used to create and update the buffers.
+         \param cmdBuffer
+           Command buffer used to set up transfers of data in the GPU memory. This 
+           call must be preceded by calls to cmdBuffer's BeginRecording() and ended
+           with EndRecording(). Do recall to also submit the cmdBuffer to a transfer
+           queue.
+        */ 
+        /***************************************************************************/
+        void BuildImages(Handle<SHVkLogicalDevice> device, Handle<SHVkCommandBuffer> cmdBuffer, Handle<SHVkQueue> graphicsQueue, Handle<SHVkDescriptorPool> descPool, Handle<SHVkDescriptorSetLayout> descLayout);
+
+        /*-----------------------------------------------------------------------------*/
+        /* Getter Functions                                                            */
+        /*-----------------------------------------------------------------------------*/
+        Handle<SHVkBuffer> GetTextureBuffer() const noexcept { return texStorageBuffer; }
+
+      private:
+        /*-----------------------------------------------------------------------------*/
+        /* Type Definition                                                             */
+        /*-----------------------------------------------------------------------------*/
+        struct AddJob
+        {
+            uint32_t                       PixelCount    = 0;
+            const SHTexture::PixelChannel* PixelData     = nullptr;
+            SHTexture::TextureFormat       TextureFormat = {};
+            uint32_t                       MipLevels = 0;
+            Handle<SHVkImage>              Image;
+            Handle<SHTexture>              Handle;
+        };
+
+        /*-----------------------------------------------------------------------------*/
+        /* Data Members                                                                */
+        /*-----------------------------------------------------------------------------*/
+        // Manipulation Queues
+        std::vector<AddJob> addJobs;
+        std::vector<Handle<SHTexture>> removeJobs;
+        // Tracking
+        ResourceManager resourceManager;
+        std::vector<Handle<SHTexture>> texOrder;
+        // CPU Storage
+        std::vector<SHTexture::PixelChannel> texStorage;
+        // GPU Storage
+        Handle<SHVkBuffer> texStorageBuffer{};
+        // Flags
+        bool isDirty = true;
+
+        /*-----------------------------------------------------------------------------*/
+        /* Helper Functions                                                            */
+        /*-----------------------------------------------------------------------------*/
+        void preparePipelineBarriers(vk::ImageLayout oldLayout, vk::ImageLayout newLayout, vk::PipelineStageFlagBits& srcStage, vk::PipelineStageFlagBits& dstStage, std::vector<vk::ImageMemoryBarrier>& barriers);
+    };
+}

SHADE_Engine/src/Graphics/Pipeline/SHPipelineLayoutParams.h

@@ -25,6 +25,15 @@ namespace SHADE
     //! want to use it for allocating descriptor sets.
     std::vector<Handle<SHVkDescriptorSetLayout>> const& globalDescSetLayouts = {};
   };
+
+  struct SHPipelineLayoutParamsDummy
+  {
+    /*-----------------------------------------------------------------------*/
+    /* MEMBER VARIABLES                                                      */
+    /*-----------------------------------------------------------------------*/
+
+    std::vector<Handle<SHVkDescriptorSetLayout>> const& globalDescSetLayouts = {};
+  };
 }
 
 #endif

SHADE_Engine/src/Graphics/Pipeline/SHPipelineState.h

@@ -64,7 +64,7 @@ namespace SHADE
     vk::CullModeFlags cull_mode{ vk::CullModeFlagBits::eBack };
 
     //! CW or CCW
-    vk::FrontFace frontFacingOrientation{ vk::FrontFace::eClockwise };
+    vk::FrontFace frontFacingOrientation{ vk::FrontFace::eCounterClockwise };
 
     bool depthBias{ VK_FALSE };
   };

SHADE_Engine/src/Graphics/Pipeline/SHVkPipeline.cpp

@@ -179,7 +179,7 @@ namespace SHADE
   /*!
   
     \brief
-      Non-default ctor.
+      Non-default ctor for creating graphics pipeline.
     
     \param inLogicalDeviceHdl
       Needed for creation and destruction.
@@ -200,14 +200,12 @@ namespace SHADE
       The subpass that this pipeline will be used in. If state is not
       nullptr, this parameter is ignored.
 
-    \param type
-      The type of the pipeline. 
    
   */
   /***************************************************************************/
-  SHVkPipeline::SHVkPipeline(Handle<SHVkLogicalDevice> const& inLogicalDeviceHdl, Handle<SHVkPipelineLayout> const& inPipelineLayout, SHVkPipelineState const* const state, Handle<SHVkRenderpass> const& renderpassHdl, Handle<SHSubpass> subpass, SH_PIPELINE_TYPE type) noexcept
+  SHVkPipeline::SHVkPipeline(Handle<SHVkLogicalDevice> const& inLogicalDeviceHdl, Handle<SHVkPipelineLayout> const& inPipelineLayout, SHVkPipelineState const* const state, Handle<SHVkRenderpass> const& renderpassHdl, Handle<SHSubpass> subpass) noexcept
     : pipelineState{ }
-    , pipelineType {type}
+    , pipelineType {SH_PIPELINE_TYPE::GRAPHICS}
     , vkPipeline {VK_NULL_HANDLE}
     , logicalDeviceHdl{ inLogicalDeviceHdl }
     , pipelineLayout { inPipelineLayout }
@@ -250,6 +248,33 @@ namespace SHADE
     vkPipeline = VK_NULL_HANDLE;
   }
 
+  /***************************************************************************/
+  /*!
+  
+    \brief
+      Just to differentiate between compute and graphics pipeline, we will
+      have a constructor that takes in less parameters; sufficient for the
+      compute pipeline to be created. 
+    
+    \param inLogicalDeviceHdl
+    \param inPipelineLayout
+   
+    \return 
+  
+  */
+  /***************************************************************************/
+  SHVkPipeline::SHVkPipeline(Handle<SHVkLogicalDevice> const& inLogicalDeviceHdl, Handle<SHVkPipelineLayout> const& inPipelineLayout) noexcept
+    : pipelineState{ }
+    , pipelineType{ SH_PIPELINE_TYPE::COMPUTE }
+    , vkPipeline{ VK_NULL_HANDLE }
+    , logicalDeviceHdl{ inLogicalDeviceHdl }
+    , pipelineLayout{ inPipelineLayout }
+    , created{ false }
+
+  {
+
+  }
+
   /***************************************************************************/
   /*!
   

SHADE_Engine/src/Graphics/Pipeline/SHVkPipeline.h

@@ -51,8 +51,10 @@ namespace SHADE
                    Handle<SHVkPipelineLayout> const& inPipelineLayout, 
                    SHVkPipelineState const* const    state, 
                    Handle<SHVkRenderpass> const&     renderpassHdl,
-                   Handle<SHSubpass>                 subpass,
+                   Handle<SHSubpass>                 subpass) noexcept;
-                   SH_PIPELINE_TYPE                  type) noexcept;
+
+    SHVkPipeline(Handle<SHVkLogicalDevice> const& inLogicalDeviceHdl,
+      Handle<SHVkPipelineLayout> const& inPipelineLayout) noexcept;
 
     SHVkPipeline  (SHVkPipeline&& rhs) noexcept;
     ~SHVkPipeline (void)               noexcept;

SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.cpp

@@ -198,7 +198,7 @@ namespace SHADE
     // 1 descriptor set layout for every descriptor set detected. 
     for (auto const& set : setsWithBindings)
     {
-      auto newDescriptorSetLayout = logicalDeviceHdl->CreateDescriptorSetLayout(set.second);
+      auto newDescriptorSetLayout = logicalDeviceHdl->CreateDescriptorSetLayout(set.first, set.second);
       descriptorSetLayoutsAllocate.push_back(newDescriptorSetLayout);
     }
 
@@ -254,12 +254,6 @@ namespace SHADE
     // Clear pc ranges
     vkPcRanges.clear();
 
-    // Kill all descriptor set layouts
-    for (auto& layout : descriptorSetLayoutsGlobal)
-    	SHVkInstance::GetResourceManager().Free(layout);
-
-    descriptorSetLayoutsGlobal.clear();
-
     for (auto& layout : descriptorSetLayoutsAllocate)
       SHVkInstance::GetResourceManager().Free(layout);
 
@@ -285,9 +279,9 @@ namespace SHADE
    
   */
   /***************************************************************************/
-  SHVkPipelineLayout::SHVkPipelineLayout(Handle<SHVkLogicalDevice> const& inLogicalDeviceHdl, SHPipelineLayoutParams& pipelineLayoutParams) noexcept
+  SHVkPipelineLayout::SHVkPipelineLayout(Handle<SHVkLogicalDevice> const& inLogicalDeviceHdl, SHPipelineLayoutParams const& pipelineLayoutParams) noexcept
     : vkPipelineLayout {VK_NULL_HANDLE}
-    , shaderModules{std::move (pipelineLayoutParams.shaderModules)}
+    , shaderModules{pipelineLayoutParams.shaderModules}
     , logicalDeviceHdl {inLogicalDeviceHdl}
     , pushConstantInterface{}
     , vkPcRanges{}
@@ -308,6 +302,46 @@ namespace SHADE
     RecreateIfNeeded ();
   }
 
+
+  SHVkPipelineLayout::SHVkPipelineLayout(Handle<SHVkLogicalDevice> const& inLogicalDeviceHdl, SHPipelineLayoutParamsDummy const& pipelineLayoutParams) noexcept
+    : vkPipelineLayout{ VK_NULL_HANDLE }
+    , shaderModules{ }
+    , logicalDeviceHdl{ inLogicalDeviceHdl }
+    , pushConstantInterface{}
+    , vkPcRanges{}
+    , descriptorSetLayoutsGlobal{} 
+    , descriptorSetLayoutsAllocate{}
+    , vkDescriptorSetLayoutsAllocate{}
+    , vkDescriptorSetLayoutsPipeline{}
+
+  {
+    vkDescriptorSetLayoutsPipeline.resize(pipelineLayoutParams.globalDescSetLayouts.size());
+    for (uint32_t i = 0; auto& layout : vkDescriptorSetLayoutsPipeline)
+    {
+    	layout = pipelineLayoutParams.globalDescSetLayouts[i]->GetVkHandle();
+      ++i;
+    }
+
+    vk::PipelineLayoutCreateInfo plCreateInfo{};
+
+    // Set push constant data to pipeline layout
+    plCreateInfo.pushConstantRangeCount = 0;
+    plCreateInfo.pPushConstantRanges = nullptr;
+
+    // To initialize the descriptor set layouts for the pipeline layout.
+    plCreateInfo.setLayoutCount = static_cast<uint32_t>(vkDescriptorSetLayoutsPipeline.size());
+    plCreateInfo.pSetLayouts = vkDescriptorSetLayoutsPipeline.data();
+
+    if (auto const RESULT = logicalDeviceHdl->GetVkLogicalDevice().createPipelineLayout(&plCreateInfo, nullptr, &vkPipelineLayout); RESULT != vk::Result::eSuccess)
+    {
+      SHVulkanDebugUtil::ReportVkError(RESULT, "Failed to create Pipeline Layout. ");
+      return;
+    }
+    else
+      SHVulkanDebugUtil::ReportVkSuccess("Successfully created Pipeline Layout. ");
+
+  }
+
   /***************************************************************************/
   /*!
   

SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.h

@@ -57,7 +57,8 @@ namespace SHADE
     /*-----------------------------------------------------------------------*/
     /* CTORS AND DTORS                                                       */
     /*-----------------------------------------------------------------------*/
-    SHVkPipelineLayout            (Handle<SHVkLogicalDevice> const& inLogicalDeviceHdl, SHPipelineLayoutParams& pipelineLayoutParams) noexcept;
+    SHVkPipelineLayout(Handle<SHVkLogicalDevice> const& inLogicalDeviceHdl, SHPipelineLayoutParams const& pipelineLayoutParams) noexcept;
+    SHVkPipelineLayout(Handle<SHVkLogicalDevice> const& inLogicalDeviceHdl, SHPipelineLayoutParamsDummy const& pipelineLayoutParams) noexcept;
     SHVkPipelineLayout            (SHVkPipelineLayout&& rhs) noexcept;
     ~SHVkPipelineLayout           (void) noexcept;
     SHVkPipelineLayout& operator= (SHVkPipelineLayout&& rhs) noexcept;

SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp

@@ -220,7 +220,6 @@ namespace SHADE
     , depthReferences{}
     , inputReferences{}
   {
-    superBatch = rm.Create<SHSuperBatch>(GetHandle());
   }
 
   /***************************************************************************/
@@ -346,10 +345,13 @@ namespace SHADE
     inputReferences.push_back({ resourceAttachmentMapping->at(ptrToResources->at(resourceToReference).GetId().Raw), vk::ImageLayout::eShaderReadOnlyOptimal });
   }
 
-  void SHSubpass::Execute(Handle<SHVkCommandBuffer>& commandBuffer) noexcept
+  void SHSubpass::Execute(Handle<SHVkCommandBuffer>& commandBuffer, uint32_t frameIndex) noexcept
   {
+    // Ensure correct transforms are provided
+    superBatch->UpdateBuffers(frameIndex);
+
     // Draw all the batches
-    superBatch->Draw(commandBuffer);
+    superBatch->Draw(commandBuffer, frameIndex);
 
     // Draw all the exterior draw calls
     for (auto& drawCall : exteriorDrawCalls)
@@ -363,6 +365,12 @@ namespace SHADE
     exteriorDrawCalls.push_back(newDrawCall);
   }
 
+  void SHSubpass::Init(ResourceManager& resourceManager) noexcept
+  {
+    superBatch = resourceManager.Create<SHSuperBatch>(GetHandle());
+
+  }
+
   /***************************************************************************/
   /*!
 
@@ -521,6 +529,9 @@ namespace SHADE
     , configured{ rhs.configured }
     , executed{ rhs.executed }
     , ptrToResources{ rhs.ptrToResources }
+    , pipelineLibrary{ std::move(rhs.pipelineLibrary) }
+    , batcher { std::move(rhs.batcher) }
+
   {
     rhs.renderpass = {};
   }
@@ -541,6 +552,8 @@ namespace SHADE
     resourceAttachmentMapping = std::move(rhs.resourceAttachmentMapping);
     subpassIndexing = std::move(rhs.subpassIndexing);
     ptrToResources = std::move(rhs.ptrToResources);
+    pipelineLibrary = std::move(rhs.pipelineLibrary);
+    batcher = std::move(rhs.batcher);
 
     rhs.renderpass = {};
 
@@ -574,6 +587,7 @@ namespace SHADE
     subpasses.emplace_back(resourceManager.Create<SHSubpass>(resourceManager, GetHandle(), subpasses.size(), &resourceAttachmentMapping, ptrToResources));
     subpassIndexing.try_emplace(subpassName, static_cast<uint32_t>(subpasses.size()) - 1u);
     Handle<SHSubpass> subpass = subpasses.back();
+    subpass->Init(resourceManager);
 
     // Register the SuperBatch
     batcher.RegisterSuperBatch(subpass->GetSuperBatch());
@@ -588,7 +602,7 @@ namespace SHADE
 
     for (uint32_t i = 0; i < subpasses.size(); ++i)
     {
-      subpasses[i]->Execute(commandBuffer);
+      subpasses[i]->Execute(commandBuffer, frameIndex);
 
       // Go to next subpass if not last subpass
       if (i != subpasses.size() - 1)
@@ -621,9 +635,9 @@ namespace SHADE
     return pipeline;
   }
 
-  void SHRenderGraphNode::FinaliseBatch()
+  void SHRenderGraphNode::FinaliseBatch(uint32_t frameIndex)
   {
-    batcher.FinaliseBatches(logicalDeviceHdl);
+    batcher.FinaliseBatches(logicalDeviceHdl, frameIndex);
   }
 
   /***************************************************************************/
@@ -702,7 +716,7 @@ namespace SHADE
     // First we want to take all the attachment descriptions and initialize the 
     // finalLayout to whatever layout is specified in the last subpass that references the attachment.
 
-    for (auto& node : nodes)
+    for (uint32_t i = 0; auto& node : nodes)
     {
       // key is handle ID, value is pair (first is initial layout, second is final layout).
       std::unordered_map<uint32_t, vk::ImageLayout> resourceAttLayouts;
@@ -716,7 +730,7 @@ namespace SHADE
       {
         for (auto& color : subpass->colorReferences)
         {
-          if (node->attResources[color.attachment]->resourceType == SH_ATT_DESC_TYPE::COLOR_PRESENT)
+          if (i == nodes.size() - 1 && node->attResources[color.attachment]->resourceType == SH_ATT_DESC_TYPE::COLOR_PRESENT)
             resourceAttLayouts[color.attachment] = vk::ImageLayout::ePresentSrcKHR;
           else
             resourceAttLayouts[color.attachment] = color.layout;
@@ -735,6 +749,7 @@ namespace SHADE
         att.initialLayout = vk::ImageLayout::eUndefined;
         att.finalLayout = resourceAttLayouts[i];
       }
+      ++i;
     }
 
     // at this point all attachment descs will have their final layouts initialized as if they were standalone and did
@@ -843,7 +858,7 @@ namespace SHADE
         for (auto& inputAtt : subpass->inputReferences)
         {
           auto resource = node->attResources[inputAtt.attachment];
-          if (resource->resourceType == SH_ATT_DESC_TYPE::COLOR)
+          if (resource->resourceType == SH_ATT_DESC_TYPE::COLOR || resource->resourceType == SH_ATT_DESC_TYPE::COLOR_PRESENT)
             colorRead |= (1 << i);
           else if (resource->resourceType == SH_ATT_DESC_TYPE::DEPTH_STENCIL)
             depthRead |= (1 << i);
@@ -946,25 +961,6 @@ namespace SHADE
     }
   }
 
-  /***************************************************************************/
-  /*!
-
-    \brief
-      Configures command pools and command buffers.
-
-  */
-  /***************************************************************************/
-  void SHRenderGraph::ConfigureCommands(void) noexcept
-  {
-    //commandPools.resize (static_cast<std::size_t>(swapchainHdl->GetNumImages()));
-    commandBuffers.resize(static_cast<std::size_t>(swapchainHdl->GetNumImages()));
-
-    for (uint32_t i = 0; i < commandBuffers.size(); ++i)
-    {
-    	commandBuffers[i] = commandPools[i]->RequestCommandBuffer(SH_CMD_BUFFER_TYPE::PRIMARY);
-    }
-  }
-
   /***************************************************************************/
   /*!
 
@@ -980,12 +976,11 @@ namespace SHADE
 
   */
   /***************************************************************************/
-  void SHRenderGraph::Init(Handle<SHVkLogicalDevice> const& logicalDevice, Handle<SHVkSwapchain> const& swapchain, std::vector<Handle<SHVkCommandPool>> const& cmdPools, Handle<SHGraphicsGlobalData> inGlobalData) noexcept
+  void SHRenderGraph::Init(Handle<SHVkLogicalDevice> const& logicalDevice, Handle<SHVkSwapchain> const& swapchain, Handle<SHGraphicsGlobalData> inGlobalData) noexcept
   {
     logicalDeviceHdl = logicalDevice;
     swapchainHdl = swapchain;
     globalData = inGlobalData;
-    commandPools = cmdPools;
   }
 
   /***************************************************************************/
@@ -1010,6 +1005,34 @@ namespace SHADE
 
   }
 
+  SHRenderGraph::SHRenderGraph(SHRenderGraph&& rhs) noexcept
+    : logicalDeviceHdl{ rhs.logicalDeviceHdl }
+    , swapchainHdl{ rhs.swapchainHdl }
+    , nodeIndexing{ std::move(rhs.nodeIndexing) }
+    , nodes{ std::move(rhs.nodes) }
+    , graphResources{ std::move(rhs.graphResources) }
+    , resourceManager{ std::move(rhs.resourceManager) }
+    , globalData{ rhs.globalData }
+  {
+
+  }
+
+  SHRenderGraph& SHRenderGraph::operator=(SHRenderGraph&& rhs) noexcept
+  {
+    if (&rhs == this)
+      return *this;
+
+    logicalDeviceHdl = rhs.logicalDeviceHdl;
+    swapchainHdl = rhs.swapchainHdl;
+    nodeIndexing = std::move(rhs.nodeIndexing);
+    nodes = std::move(rhs.nodes);
+    graphResources = std::move(rhs.graphResources);
+    resourceManager = std::move(rhs.resourceManager);
+    globalData = rhs.globalData;
+
+    return *this;
+  }
+
   /***************************************************************************/
   /*!
 
@@ -1087,40 +1110,24 @@ namespace SHADE
     ConfigureSubpasses();
     ConfigureRenderpasses();
     ConfigureFramebuffers();
-    ConfigureCommands();
   }
 
   // TODO: The graph scope buffers were meant to bind vertex buffers and index buffers for meshes. Find a 
   // better way to manage these 
-  void SHRenderGraph::Execute(uint32_t frameIndex, std::initializer_list<std::pair<Handle<SHVkBuffer>, uint32_t>> graphScopeBuffers) noexcept
+  void SHRenderGraph::Execute(uint32_t frameIndex, Handle<SHVkCommandBuffer> cmdBuffer) noexcept
   {
-    //commandPools[frameIndex]->Reset();
-
-    auto& cmdBuffer = commandBuffers[frameIndex];
-    cmdBuffer->BeginRecording();
-
     // TODO: DON'T HARDCODE THIS
     cmdBuffer->SetViewportScissor(1920.0f, 1080.0f, 1920, 1080);
 
-    for (auto& [buffer, bindingPoint]: graphScopeBuffers)
-    {
-    	if (buffer->GetUsageBits() & vk::BufferUsageFlagBits::eVertexBuffer)
-        cmdBuffer->BindVertexBuffer(bindingPoint, buffer, 0);
-      else if (buffer->GetUsageBits() & vk::BufferUsageFlagBits::eIndexBuffer)
-        cmdBuffer->BindIndexBuffer(buffer, 0);
-    }
-
     for (auto& node : nodes)
       node->Execute(cmdBuffer, frameIndex);
-
-    cmdBuffer->EndRecording();
   }
 
-  void SHRenderGraph::FinaliseBatch()
+  void SHRenderGraph::FinaliseBatch(uint32_t frameIndex)
   {
     for (auto& node : nodes)
     {
-      node->FinaliseBatch();
+      node->FinaliseBatch(frameIndex);
     }
   }
 
@@ -1132,9 +1139,5 @@ namespace SHADE
     return {};
   }
 
-  Handle<SHVkCommandBuffer> const& SHRenderGraph::GetCommandBuffer(uint32_t frameIndex) const noexcept
-  {
-    return commandBuffers[frameIndex];
-  }
 
 }

SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.h

@@ -137,9 +137,11 @@ namespace SHADE
     void AddInput(std::string resourceToReference) noexcept;
 
     // Runtime functions
-    void Execute(Handle<SHVkCommandBuffer>& commandBuffer) noexcept;
+    void Execute(Handle<SHVkCommandBuffer>& commandBuffer, uint32_t frameIndex) noexcept;
     void AddExteriorDrawCalls(std::function<void(Handle<SHVkCommandBuffer>&)> const& newDrawCall) noexcept;
 
+    void Init (ResourceManager& resourceManager) noexcept;
+
     /*-----------------------------------------------------------------------*/
     /* GETTERS AND SETTERS                                                   */
     /*-----------------------------------------------------------------------*/
@@ -230,7 +232,7 @@ namespace SHADE
     // TODO: RemoveSubpass()
     void                 Execute             (Handle<SHVkCommandBuffer>& commandBuffer, uint32_t frameIndex) noexcept;
     Handle<SHVkPipeline> GetOrCreatePipeline (std::pair<Handle<SHVkShaderModule>, Handle<SHVkShaderModule>> const& vsFsPair, Handle<SHSubpass> subpass) noexcept;
-    void                 FinaliseBatch();
+    void FinaliseBatch(uint32_t frameIndex);
 
     /*-----------------------------------------------------------------------*/
     /* SETTERS AND GETTERS                                                   */
@@ -250,7 +252,6 @@ namespace SHADE
     void ConfigureSubpasses              (void) noexcept;
     void ConfigureRenderpasses           (void) noexcept;
     void ConfigureFramebuffers           (void) noexcept;
-    void ConfigureCommands               (void) noexcept;
 
     /*-----------------------------------------------------------------------*/
     /* PRIVATE MEMBER VARIABLES                                              */
@@ -272,12 +273,6 @@ namespace SHADE
     //! Resource library for graph handles
     ResourceManager resourceManager;
     
-    //! Command pool for the render graph. DO NOT RESET OR FREE THESE, THEY ARE NON-OWNING. TODO: If application is multithreaded, we need more pools. 
-    std::vector<Handle<SHVkCommandPool>> commandPools;
-
-    //! Command buffers for the render graph
-    std::vector<Handle<SHVkCommandBuffer>> commandBuffers;
-    
     //! Handle to global data
     Handle<SHGraphicsGlobalData> globalData;
 
@@ -286,22 +281,23 @@ namespace SHADE
     /* CTORS AND DTORS                                                       */
     /*-----------------------------------------------------------------------*/
     SHRenderGraph (void) noexcept;
+    SHRenderGraph(SHRenderGraph&& rhs) noexcept;
+    SHRenderGraph& operator=(SHRenderGraph&& rhs) noexcept;
 
     /*-----------------------------------------------------------------------*/
     /* PUBLIC MEMBER FUNCTIONS                                               */
     /*-----------------------------------------------------------------------*/
-    void                      Init         (Handle<SHVkLogicalDevice> const& logicalDevice, Handle<SHVkSwapchain> const& swapchain, std::vector<Handle<SHVkCommandPool>> const& cmdPools, Handle<SHGraphicsGlobalData> inGlobalData) noexcept;
+    void                      Init         (Handle<SHVkLogicalDevice> const& logicalDevice, Handle<SHVkSwapchain> const& swapchain, Handle<SHGraphicsGlobalData> inGlobalData) noexcept;
     void                      AddResource  (std::string resourceName, SH_ATT_DESC_TYPE type, uint32_t w = static_cast<uint32_t>(-1), uint32_t h = static_cast<uint32_t>(-1), vk::Format format = vk::Format::eB8G8R8A8Unorm, uint8_t levels = 1, vk::ImageCreateFlagBits createFlags = {});
     Handle<SHRenderGraphNode> AddNode      (std::string nodeName, std::initializer_list<std::string> resourceNames, std::initializer_list<std::string> predecessorNodes) noexcept;
     void                      Generate     (void) noexcept;
-    void                      Execute      (uint32_t frameIndex, std::initializer_list<std::pair<Handle<SHVkBuffer>, uint32_t>> graphScopeBuffers) noexcept;
+    void                      Execute      (uint32_t frameIndex, Handle<SHVkCommandBuffer> cmdBuffer) noexcept;
-    void                      FinaliseBatch();
+    void FinaliseBatch(uint32_t frameIndex);
 
     /*-----------------------------------------------------------------------*/
     /* SETTERS AND GETTERS                                                   */
     /*-----------------------------------------------------------------------*/
     Handle<SHRenderGraphNode> GetNode                 (std::string const& nodeName) const noexcept;
-    Handle<SHVkCommandBuffer> const& GetCommandBuffer (uint32_t frameIndex) const noexcept;
   };
 }
 

SHADE_Engine/src/Graphics/SHVkUtil.cpp

@@ -71,4 +71,14 @@ namespace SHADE
       );
     }
   }
+
+  BindingAndSetHash SHVkUtil::GenBindingSetHash(uint32_t set, uint32_t binding) noexcept
+  {
+    // Find the target writeDescSet
+    BindingAndSetHash writeHash = binding;
+    writeHash |= static_cast<uint64_t>(set) << 32;
+
+    return writeHash;
+  }
+
 }

SHADE_Engine/src/Graphics/SHVkUtil.h

@@ -76,6 +76,8 @@ namespace SHADE
     */ 
     /***********************************************************************************/
     static void EnsureBufferAndCopyHostVisibleData(Handle<SHVkLogicalDevice> device, Handle<SHVkBuffer>& bufferHandle, void* src, uint32_t size, vk::BufferUsageFlagBits usage);
+
+    static BindingAndSetHash GenBindingSetHash (uint32_t set, uint32_t binding) noexcept;
   };
 }
 

SHADE_Engine/src/Graphics/SHVulkanDefines.h

@@ -6,6 +6,8 @@
 namespace SHADE
 {
   using SHQueueFamilyIndex = uint32_t;
+  using BindingAndSetHash = uint64_t;
+  using SetIndex = uint32_t;
 
 }
 

SHADE_Engine/src/Graphics/SHVulkanIncludes.h

@@ -6,5 +6,6 @@
 #define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
 #define VULKAN_HPP_NO_NODISCARD_WARNINGS
 #include <vulkan/vulkan.hpp>
+#include "Graphics/SHVulkanDefines.h"
 
 #endif

SHADE_Engine/src/Graphics/Shaders/SHShaderReflected.h

@@ -9,8 +9,6 @@
 
 namespace SHADE
 {
-  using BindingAndSetHash = uint64_t;
-
   struct SHShaderDescriptorBindingInfo
   {
   private:

SHADE_Engine/src/Input/SHInputManagerSystem.cpp

@@ -0,0 +1,186 @@
+/*********************************************************************
+ * \file   SHInputManagerSystem.cpp
+ * \author Ryan Wang Nian Jing
+ * \brief  Definition of input manager.
+ *				 Handles input from keyboard and mouse. Soon to include controller.
+ *
+ * \copyright Copyright (c) 2022 DigiPen Institute of Technology. Reproduction
+   or disclosure of this file or its contents without the prior written
+   consent of DigiPen Institute of Technology is prohibited.
+ *********************************************************************/
+
+#pragma once
+#include <SHpch.h>
+#include "SHInputManagerSystem.h"
+
+namespace SHADE
+{
+  /*------------------------------------------------------------------------*/
+  /* Static defines                                                         */
+  /*------------------------------------------------------------------------*/
+  
+  unsigned SHInputManagerSystem::keyCount = 0;
+  bool SHInputManagerSystem::keys[MAX_KEYS];
+  bool SHInputManagerSystem::keysLast[MAX_KEYS];
+  double SHInputManagerSystem::keysHeldTime[MAX_KEYS];
+  double SHInputManagerSystem::keysReleasedTime[MAX_KEYS];
+
+  unsigned SHInputManagerSystem::keyToggleCount = 0;
+  bool SHInputManagerSystem::keysToggle[MAX_KEYS];
+  bool SHInputManagerSystem::keysToggleLast[MAX_KEYS];
+  double SHInputManagerSystem::keysToggleOnTime[MAX_KEYS];
+  double SHInputManagerSystem::keysToggleOffTime[MAX_KEYS];
+
+  int SHInputManagerSystem::mouseScreenX = 0;
+  int SHInputManagerSystem::mouseScreenY = 0;
+  int SHInputManagerSystem::mouseScreenXLast = 0;
+  int SHInputManagerSystem::mouseScreenYLast = 0;
+  double SHInputManagerSystem::mouseVelocityX = 0;
+  double SHInputManagerSystem::mouseVelocityY = 0;
+  int SHInputManagerSystem::mouseWheelVerticalDelta = 0;
+  int SHInputManagerSystem::mouseWheelVerticalDeltaPoll = 0;
+
+  void SHInputManagerSystem::Init()
+  {
+    keyCount = 0;
+    SecureZeroMemory(keys, sizeof(keys));
+    SecureZeroMemory(keysLast, sizeof(keysLast));
+    SecureZeroMemory(keysHeldTime, sizeof(keysHeldTime));
+    SecureZeroMemory(keysReleasedTime, sizeof(keysReleasedTime));
+
+    keyToggleCount = 0;
+    SecureZeroMemory(keysToggle, sizeof(keysToggle));
+    SecureZeroMemory(keysToggleLast, sizeof(keysToggleLast));
+    SecureZeroMemory(keysToggleOnTime, sizeof(keysToggleOnTime));
+    SecureZeroMemory(keysToggleOffTime, sizeof(keysToggleOffTime));
+
+    mouseScreenX = 0;
+    mouseScreenY = 0;
+    mouseScreenXLast = 0;
+    mouseScreenYLast = 0;
+    mouseWheelVerticalDelta = 0;
+    mouseWheelVerticalDeltaPoll = 0;
+  }
+  
+  void SHInputManagerSystem::Exit()
+  {
+    //No dynamically allocated memory. Nothing to do here.
+  }
+
+  void SHInputManagerSystem::InputManagerRoutine::
+    FixedExecute(double dt) noexcept
+  {
+    //Keyboard and Mouse Buttons////////////////////////////////////////////////
+    //Poll
+    unsigned char keyboardState[MAX_KEYS];
+    GetKeyboardState(keyboardState);
+    keyCount = 0;
+    keyToggleCount = 0;
+    for (size_t i = 0; i < MAX_KEYS; ++i)
+    {
+      //Ignore shift, ctrl and alt since they are split to left and right
+      if (static_cast<SH_KEYCODE>(i) == SH_KEYCODE::SHIFT ||
+        static_cast<SH_KEYCODE>(i) == SH_KEYCODE::CTRL ||
+        static_cast<SH_KEYCODE>(i) == SH_KEYCODE::ALT)
+        continue;
+
+      //Pressed state
+      if (keyboardState[i] & 0b10000000)
+      {
+        ++keyCount;
+        keys[i] = true;
+      }
+      else keys[i] = false;
+
+      //Toggle state
+      if (keyboardState[i] & 0b00000001)
+      {
+        ++keyToggleCount;
+        keysToggle[i] = true;
+      }
+      else keysToggle[i] = false;
+    }
+
+    //Timers
+    for (size_t i = 0; i < MAX_KEYS; ++i)
+    {
+      if (keys[i]) //Key is down
+      {
+        if (!keysLast[i]) //Key was just pressed
+        {
+          keysHeldTime[i] = 0.0; //Reset timer
+        }
+        keysHeldTime[i] += dt; //Tick up
+      }
+      else //Key is up
+      {
+        if (keysLast[i]) //Key was just released
+        {
+          keysReleasedTime[i] = 0.0; //Reset timer
+        }
+        keysReleasedTime[i] += dt; //Tick up
+      }
+    }
+
+    //Write to lastKeys
+    memcpy(keysLast, keys, sizeof(keys));
+
+    //Mouse Positioning/////////////////////////////////////
+    //https://stackoverflow.com/a/6423739
+
+    //Set last positioning
+    mouseScreenXLast = mouseScreenX;
+    mouseScreenYLast = mouseScreenY;
+
+    //Get cursor position, even when it is outside window
+    POINT p;
+    GetCursorPos(&p);
+    mouseScreenX = p.x;
+    mouseScreenY = p.y;
+
+    //Mouse wheel vertical delta updating
+    mouseWheelVerticalDelta = 0;
+    mouseWheelVerticalDelta = mouseWheelVerticalDeltaPoll;
+    mouseWheelVerticalDeltaPoll = 0;
+  }
+
+  bool SHInputManagerSystem::AnyKeyDown(SH_KEYCODE* firstDetected) noexcept
+  {
+    for (size_t i = 0; i < MAX_KEYS; ++i)
+    {
+      if (keys[i] && !keysLast[i])
+      {
+        if (firstDetected) *firstDetected = static_cast<SH_KEYCODE>(i);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool SHInputManagerSystem::AnyKey(SH_KEYCODE* firstDetected) noexcept
+  {
+    for (size_t i = 0; i < MAX_KEYS; ++i)
+    {
+      if (keys[i])
+      {
+        if (firstDetected) *firstDetected = static_cast<SH_KEYCODE>(i);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool SHInputManagerSystem::AnyKeyUp(SH_KEYCODE* firstDetected) noexcept
+  {
+    for (size_t i = 0; i < MAX_KEYS; ++i)
+    {
+      if (!keys[i] && keysLast[i])
+      {
+        if (firstDetected) *firstDetected = static_cast<SH_KEYCODE>(i);
+        return true;
+      }
+    }
+    return false;
+  }
+
+} //namespace SHADE

SHADE_Engine/src/Input/SHInputManagerSystem.h

@@ -0,0 +1,580 @@
+/*********************************************************************
+ * \file   SHInputManagerSystem.h
+ * \author Ryan Wang Nian Jing
+ * \brief  Declaration of input manager.
+ *				 Handles input from keyboard and mouse. Soon to include controller.
+ *
+ * \copyright Copyright (c) 2022 DigiPen Institute of Technology. Reproduction
+   or disclosure of this file or its contents without the prior written
+   consent of DigiPen Institute of Technology is prohibited.
+ *********************************************************************/
+
+#pragma once
+//#include <Xinput.h>
+//#include "../../SHADE_Managed/src/SHpch.h"
+#include "ECS_Base/System/SHSystem.h"
+#include "ECS_Base/System/SHFixedSystemRoutine.h"
+
+namespace SHADE
+{
+  class SH_API SHInputManagerSystem : public SHSystem
+  {
+  public:
+    class SH_API InputManagerRoutine : public SHFixedSystemRoutine
+    {
+    public:
+      virtual void FixedExecute(double dt) noexcept override final;
+    };
+
+  public:
+    /*------------------------------------------------------------------------*/
+    /* Enumerations                                                           */
+    /*------------------------------------------------------------------------*/
+    enum class SH_KEYCODE
+    {
+      LMB = 0X01,
+      RMB = 0X02,
+      CANCEL = 0X03,
+      MMB = 0X04,
+      XMB1 = 0X05,
+      XMB2 = 0X06,
+
+      BACKSPACE = 0X08,
+      TAB = 0X09,
+
+      CLEAR = 0X0C,
+      ENTER = 0X0D,
+
+      SHIFT = 0X10, //USE LEFT OR RIGHT SHIFT INSTEAD
+      CTRL = 0X11, //USE LEFT OR RIGHT CTRL INSTEAD
+      ALT = 0X12, //USE LEFT OR RIGHT ALT INSTEAD
+      PAUSE = 0X13,
+      CAPS_LOCK = 0X14,
+      IME_KANA = 0X15,
+      IME_HANGUL = 0X15,
+      IME_ON = 0X16,
+      IME_JUNJA = 0X17,
+      IME_FINAL = 0X18,
+      IME_HANJA = 0X19,
+      IME_KANJI = 0X19,
+      IME_OFF = 0X1A,
+      ESCAPE = 0X1B,
+      IME_CONVERT = 0X1C,
+      IME_NONCONVERT = 0X1D,
+      IME_ACCEPT = 0X1E,
+      IME_MODECHANGE = 0X1F,
+      SPACE = 0X20,
+      PAGE_UP = 0X21,
+      PAGE_DOWN = 0X22,
+      END = 0X23,
+      HOME = 0X24,
+      LEFT_ARROW = 0X25,
+      UP_ARROW = 0X26,
+      RIGHT_ARROW = 0X27,
+      DOWN_ARROW = 0X28,
+      SELECT = 0X29,
+      PRINT = 0X2A,
+      EXECUTE = 0X2B,
+      PRINT_SCREEN = 0X2C,
+      INSERT = 0X2D,
+      DEL = 0X2E,
+      HELP = 0X2F,
+
+      NUMBER_0 = 0X30,
+      NUMBER_1,
+      NUMBER_2,
+      NUMBER_3,
+      NUMBER_4,
+      NUMBER_5,
+      NUMBER_6,
+      NUMBER_7,
+      NUMBER_8,
+      NUMBER_9,
+
+      A = 0X41,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G,
+      H,
+      I,
+      J,
+      K,
+      L,
+      M,
+      N,
+      O,
+      P,
+      Q,
+      R,
+      S,
+      T,
+      U,
+      V,
+      W,
+      X,
+      Y,
+      Z,
+
+      LEFT_WINDOWS = 0X5B,
+      RIGHT_WINDOWS,
+      APPS,
+
+      SLEEP = 0X5F,
+
+      NUMPAD_0 = 0X60,
+      NUMPAD_1,
+      NUMPAD_2,
+      NUMPAD_3,
+      NUMPAD_4,
+      NUMPAD_5,
+      NUMPAD_6,
+      NUMPAD_7,
+      NUMPAD_8,
+      NUMPAD_9,
+
+      MULTIPLY = 0X6A,
+      ADD,
+      SEPARATOR,
+      SUBTRACT,
+      DECIMAL,
+      DIVIDE,
+
+      F1 = 0X70,
+      F2,
+      F3,
+      F4,
+      F5,
+      F6,
+      F7,
+      F8,
+      F9,
+      F10,
+      F11,
+      F12,
+      F13,
+      F14,
+      F15,
+      F16,
+      F17,
+      F18,
+      F19,
+      F20,
+      F21,
+      F22,
+      F23,
+      F24,
+
+      NUM_LOCK = 0X90,
+      SCROLL_LOCK = 0X91,
+
+      OEM_PC98_NUMPAD_EQUAL = 0X92,
+      OEM_FUJITSU_DICTIONARY = 0X92,
+      OEM_FUJITSU_UNREGISTER,
+      OEM_FUJITSU_REGISTER,
+      OEM_FUJITSU_LEFT_THUMB,
+      OEM_FUJITSU_RIGHT_THUMB,
+
+      LEFT_SHIFT = 0XA0,
+      RIGHT_SHIFT,
+      LEFT_CTRL,
+      RIGHT_CTRL,
+      LEFT_ALT,
+      RIGHT_ALT,
+      BROWSER_BACK,
+      BROWSER_FORWARD,
+      BROWSER_REFRESH,
+      BROWSER_STOP,
+      BROWSER_SEARCH,
+      BROWSER_FAVOURITES,
+      BROWSER_HOME,
+      VOLUME_MUTE,
+      VOLUME_DOWN,
+      VOLUME_UP,
+      MEDIA_NEXT_TRACK,
+      MEDIA_PREVIOUS_TRACK,
+      MEDIA_STOP,
+      MEDIA_PLAY_PAUSE,
+      LAUNCH_MAIL,
+      LAUNCH_MEDIA_SELECT,
+      LAUNCH_APP_1,
+      LAUNCH_APP_2,
+
+      OEM_1 = 0XBA,
+      OEM_PLUS,
+      OEM_COMMA,
+      OEM_MINUS,
+      OEM_PERIOD,
+      OEM_2,
+      OEM_3,
+
+      GAMEPAD_A = 0XC3,
+      GAMEPAD_B,
+      GAMEPAD_X,
+      GAMEPAD_Y,
+      GAMEPAD_RIGHTSHOULDER,
+      GAMEPAD_LEFTSHOULDER,
+      GAMEPAD_LEFTTRIGGER,
+      GAMEPAD_RIGHTTRIGGER,
+      GAMEPAD_DPAD_UP,
+      GAMEPAD_DPAD_DOWN,
+      GAMEPAD_DPAD_LEFT,
+      GAMEPAD_DPAD_RIGHT,
+      GAMEPAD_MENU,
+      GAMEPAD_VIEW,
+      GAMEPAD_LEFT_THUMBSTICK_BUTTON,
+      GAMEPAD_RIGHT_THUMBSTICK_BUTTON,
+      GAMEPAD_LEFT_THUMBSTICK_UP,
+      GAMEPAD_LEFT_THUMBSTICK_DOWN,
+      GAMEPAD_LEFT_THUMBSTICK_RIGHT,
+      GAMEPAD_LEFT_THUMBSTICK_LEFT,
+      GAMEPAD_RIGHT_THUMBSTICK_UP,
+      GAMEPAD_RIGHT_THUMBSTICK_DOWN,
+      GAMEPAD_RIGHT_THUMBSTICK_RIGHT,
+      GAMEPAD_RIGHT_THUMBSTICK_LEFT,
+
+      OEM_4,
+      OEM_5,
+      OEM_6,
+      OEM_7,
+      OEM_8,
+
+      OEM_AX = 0XE1,
+      OEM_102,
+      OEM_ICO_HELP,
+      OEM_ICO_00,
+      IME_PROCESS,
+      OEM_ICO_CLEAR,
+      PACKET,
+
+      OEM_RESET = 0XE9,
+      OEM_JUMP,
+      OEM_PA1,
+      OEM_PA2,
+      OEM_PA3,
+      OEM_WSCTRL,
+      OEM_CUSEL,
+      OEM_ATTN,
+      OEM_FINISH,
+      OEM_COPY,
+      OEM_AUTO,
+      OEM_ENLW,
+      OEM_BACKTAB,
+
+      ATTN,
+      CRSEL,
+      EXSEL,
+      EREOF,
+      PLAY,
+      ZOOM,
+      NONAME,
+      PA_1,
+      OEM_CLEAR
+    };
+
+  public:
+    /*------------------------------------------------------------------------*/
+    /* Constructors & Destructor                                              */
+    /*------------------------------------------------------------------------*/
+    SHInputManagerSystem() noexcept = default;
+    ~SHInputManagerSystem() noexcept = default;
+
+    SHInputManagerSystem(const SHInputManagerSystem&) = delete;
+    SHInputManagerSystem(SHInputManagerSystem&&) = delete;
+
+    SHInputManagerSystem& operator= (const SHInputManagerSystem&) = delete;
+    SHInputManagerSystem& operator= (SHInputManagerSystem&&) = delete;
+
+    /*------------------------------------------------------------------------*/
+    /* SHSystem Overrides                                                     */
+    /*------------------------------------------------------------------------*/
+    virtual void Init() override final;
+    virtual void Exit() override final;
+
+    /*------------------------------------------------------------------------*/
+    /* Member Functions                                                       */
+    /*------------------------------------------------------------------------*/
+
+    //Needs to be linked to WM_MOUSEWHEEL in wndProc
+    static inline void PollWheelVerticalDelta(WPARAM wParam) noexcept
+    {
+      mouseWheelVerticalDeltaPoll += GET_WHEEL_DELTA_WPARAM(wParam);
+    }
+
+    //For testing purposes
+    //static void PrintCurrentState() noexcept;
+
+    /*------------------------------------------------------------------------*/
+    /* Input state accessors (KB & M)                                         */
+    /*------------------------------------------------------------------------*/
+    //Get how many keys are presently down
+    static inline unsigned GetKeyCount() noexcept
+    {
+      return keyCount;
+    }
+
+    //How many keys are presently toggled
+    static inline unsigned GetKeyToggleCount() noexcept
+    {
+      return keyToggleCount;
+    }
+
+    //Any key pressed in THIS FRAME ONLY
+    //Keys being held beforehand don't count
+    //Output parameter is which key was first to be detected
+    static bool AnyKeyDown(SH_KEYCODE* firstKey = nullptr) noexcept;
+
+    //Any key is being held down
+    //Return false if no key being held
+    //Output parameter is which key was first to be detected
+    static bool AnyKey(SH_KEYCODE* firstKey = nullptr) noexcept;
+
+    //Any key released in THIS FRAME ONLY
+    //Keys that are released beforehand don't count
+    //Output parameter is which key was first to be detected
+    static bool AnyKeyUp(SH_KEYCODE* firstKey = nullptr) noexcept;
+
+    //Check if a particular key was pressed down in THIS FRAME ONLY
+    //Keys being held beforehand don't count
+    //Output parameter is how long the key has been released for prior
+    static inline bool GetKeyDown (SH_KEYCODE key,
+      double* releasedTime = nullptr) noexcept
+    {
+      if (releasedTime) *releasedTime = keysReleasedTime[static_cast<int>(key)];
+      return (keys[static_cast<int>(key)] && !keysLast[static_cast<int>(key)]);
+    }
+
+    //Check if a particular key was toggled on in THIS FRAME ONLY
+    //Keys that stay toggled on afterwards don't count
+    //Output parameter is how long the key has been toggled off for prior
+    static inline bool GetKeyToggleOn (SH_KEYCODE key,
+      double* toggleOffTime = nullptr) noexcept
+    {
+      if (toggleOffTime)
+        *toggleOffTime = keysToggleOffTime[static_cast<int>(key)];
+      return (keysToggle[static_cast<int>(key)] &&
+        !keysToggleLast[static_cast<int>(key)]);
+    }
+
+    //Check if a particular key is presently being held down on
+    //Output parameter is how long the key has been held and released
+    static inline bool GetKey(SH_KEYCODE key,
+      double* heldTime = nullptr, double* releasedTime = nullptr) noexcept
+    {
+      if (heldTime) *heldTime = keysHeldTime[static_cast<int>(key)];
+      if (releasedTime) *releasedTime = keysReleasedTime[static_cast<int>(key)];
+      return keys[static_cast<int>(key)];
+    }
+
+    //Check if a particular key is presently toggled on
+    //Output parameter is how long the key has been toggled on and off
+    static inline bool GetKeyToggle(SH_KEYCODE key,
+      double* onTime = nullptr, double* offTime = nullptr) noexcept
+    {
+      if (onTime) *onTime = keysToggleOnTime[static_cast<int>(key)];
+      if (offTime) *offTime = keysToggleOffTime[static_cast<int>(key)];
+      return keysToggle[static_cast<int>(key)];
+    }
+
+    //Check if a particular key was released in THIS FRAME ONLY
+    //Keys already released beforehand don't count
+    //Output parameter is how long the key has been held for prior
+    static inline bool GetKeyUp(SH_KEYCODE key,
+      double* heldTime = nullptr) noexcept
+    {
+      if (heldTime) *heldTime = keysHeldTime[static_cast<int>(key)];
+      return (!keys[static_cast<int>(key)] && keysLast[static_cast<int>(key)]);
+    }
+
+    //Check if a particular key was toggled off in THIS FRAME ONLY
+    //Keys that stay toggled off afterwards don't count
+    //Output parameter is how long the key has been toggled on for prior
+    static inline bool GetKeyToggleOff(SH_KEYCODE key,
+      double* toggleOnTime = nullptr) noexcept
+    {
+      if (toggleOnTime)
+        *toggleOnTime = keysToggleOnTime[static_cast<int>(key)];
+      return (!keysToggle[static_cast<int>(key)] &&
+        keysToggleLast[static_cast<int>(key)]);
+    }
+
+    //Mouse/////////////
+
+    //Get the mouse location with respect to the screen
+    static inline void GetMouseScreenPosition (int* x = nullptr,
+      int* y = nullptr) noexcept
+    {
+      if (x) *x = mouseScreenX;
+      if (y) *y = mouseScreenY;
+    }
+
+    //Get the mouse location with respect to current window
+    static inline void GetMouseWindowPosition (int* x = nullptr,
+      int* y = nullptr) noexcept
+    {
+      POINT p{ mouseScreenX, mouseScreenY };
+      ScreenToClient(GetActiveWindow(), &p);
+      if (x) *x = mouseScreenX;
+      if (y) *y = mouseScreenY;
+    }
+
+    //Get the mouse velocity
+    //Two output parameters for x and y velocitites
+    //In pixels per second for both
+    static inline void GetMouseVelocity(double* x = nullptr,
+      double* y = nullptr) noexcept
+    {
+      if (x) *x = mouseVelocityX;
+      if (y) *y = mouseVelocityY;
+    }
+
+    //Get the mouse wheel vertical delta
+    static inline int GetMouseWheelVerticalDelta() noexcept
+    {
+      return mouseWheelVerticalDelta;
+    }
+
+    //GET INPUT TIMINGS///////////////////////////////////////////////////////////
+
+    //Keyboard/////////////
+
+    //How long has this key been held down for
+    static inline double GetKeyHeldTime(SH_KEYCODE key) noexcept
+    {
+      return keysHeldTime[static_cast<int>(key)];
+    }
+
+    //How long has this key been released for
+    static inline double GetKeyReleasedTime(SH_KEYCODE key) noexcept
+    {
+      return keysReleasedTime[static_cast<int>(key)];
+    }
+
+    //How long has this key been toggled on for
+    static inline double GetKeyToggleOnTime(SH_KEYCODE key) noexcept
+    {
+      return keysToggleOnTime[static_cast<int>(key)];
+    }
+
+    //How long has this keen been toggled off for
+    static inline double GetKeyToggleOffTime(SH_KEYCODE key) noexcept
+    {
+      return keysToggleOffTime[static_cast<int>(key)];
+    }
+
+    /*------------------------------------------------------------------------*/
+    /* Other Functions                                                        */
+    /*------------------------------------------------------------------------*/
+
+    //Mouse////////////////////////
+
+    //Move mouse cursor to a position on the screen
+    static inline void SetMouseScreenPosition(int x = 0, int y = 0) noexcept
+    {
+      SetCursorPos(x, y);
+    }
+
+    //Move mouse cursor to a position on the active window
+    static inline void SetMouseWindowPosition(int x = 0, int y = 0) noexcept
+    {
+      POINT p{ x, y };
+      ClientToScreen(GetActiveWindow(), &p);
+      SetCursorPos(p.x, p.y);
+    }
+
+  private:
+    /*------------------------------------------------------------------------*/
+    /* Constants                                                              */
+    /*------------------------------------------------------------------------*/
+    static constexpr size_t MAX_KEYS = UCHAR_MAX + 1;
+
+    /*------------------------------------------------------------------------*/
+    /* Data Members                                                           */
+    /*------------------------------------------------------------------------*/
+
+    //KEYBOARD AND MOUSE BUTTONS////////////////////////////////////////////////
+    
+    //How many keys are presently being pressed
+    static unsigned keyCount;
+
+    //Key states of all keys presently
+    //true for being pressed, false for released
+    static bool keys[MAX_KEYS];
+
+    //Key states of all keys in the last frame
+  //true for being pressed, false for released
+    static bool keysLast[MAX_KEYS];
+
+    //Key held durations
+    //Stops ticking up when released
+    //Will be reset when held again
+    static double keysHeldTime[MAX_KEYS];
+
+    //Key released durations
+    //Stops ticking up when held
+    //Will be reset when off again
+    static double keysReleasedTime[MAX_KEYS];
+
+    //How many keys are presently being toggled
+    static unsigned keyToggleCount;
+
+    //Toggle key states of keys (not neccessarily just caps/num/scroll locks)
+    static bool keysToggle[MAX_KEYS];
+
+    //Toggle key states of keys in the last frame
+    static bool keysToggleLast[MAX_KEYS];
+
+    //Key toggle durations
+    //Stops ticking up when untoggled
+    //Will be reset when toggled again
+    static double keysToggleOnTime[MAX_KEYS];
+
+    //Key untoggle durations
+    //Stops ticking up when toggled
+    //Will be reset when untoggled again
+    static double keysToggleOffTime[MAX_KEYS];
+
+    //MOUSE VARIABLES///////////////////////////////////////////////////////////
+
+    //Present horizontal positioning of the mouse WRT the screen
+    //Increasing rightwards
+    static int mouseScreenX;
+    //Present vertical positioning of the mouse WRT the screen
+    //Increasing downwards
+    static int mouseScreenY;
+
+    //Horizontal positioning of the mouse WRT screen in last frame
+    //Increasing rightwards
+    static int mouseScreenXLast;
+    //Vertical positioning of the mouse WRT screen in the last frame
+    //Increasing downwards
+    static int mouseScreenYLast;
+
+    //The velocity at which the mouse is being moved horizontally (px/s)
+    //Rightwards is positive
+    static double mouseVelocityX;
+    //The velocity at which the mouse is being moved vertically (px/s)
+    //Downwards is positive
+    static double mouseVelocityY;
+
+    //For polling mouse wheel events, not to be read
+    static int mouseWheelVerticalDeltaPoll;
+    //Mouse wheel vertical rotation speed. Positive is rotation AWAY from user
+    static int mouseWheelVerticalDelta;
+
+    //CONTROLLER VARIABLES//////////////////////////////////////////////////////
+
+    //OTHER VARIABLES///////////////////////////////////////////////////////////
+
+    //Axis bindings
+    //X
+    
+    //Y
+
+    //Other mappings
+
+    //Buffer
+  };
+}

SHADE_Engine/src/Scripting/SHScriptEngine.cpp

@@ -103,17 +103,17 @@ namespace SHADE
   /*-----------------------------------------------------------------------------------*/
   /* Script Manipulation Functions                                                     */
   /*-----------------------------------------------------------------------------------*/
-  bool SHScriptEngine::AddScript(const SHEntity& entity, const std::string_view& scriptName)
+  bool SHScriptEngine::AddScript(EntityID entity, const std::string_view& scriptName)
   {
-      return csScriptsAdd(entity.GetEID(), scriptName.data());
+      return csScriptsAdd(entity, scriptName.data());
   }
-  void SHScriptEngine::RemoveAllScripts(const SHEntity& entity)
+  void SHScriptEngine::RemoveAllScripts(EntityID entity)
   {
-      csScriptsRemoveAll(entity.GetEID());
+      csScriptsRemoveAll(entity);
   }
-  void SHScriptEngine::RemoveAllScriptsImmediately(const SHEntity& entity, bool callOnDestroy)
+  void SHScriptEngine::RemoveAllScriptsImmediately(EntityID entity, bool callOnDestroy)
   {
-      csScriptsRemoveAllImmediately(entity.GetEID(), callOnDestroy);
+      csScriptsRemoveAllImmediately(entity, callOnDestroy);
   }
   
   /*---------------------------------------------------------------------------------*/

SHADE_Engine/src/Scripting/SHScriptEngine.h

@@ -116,14 +116,14 @@ namespace SHADE
     /// True if successfully added. False otherwise with the error logged to the
     /// console.
     /// </returns>
-    bool AddScript(const SHEntity& entity, const std::string_view& scriptName);
+    bool AddScript(EntityID entity, const std::string_view& scriptName);
     /// <summary>
     /// Removes all Scripts attached to the specified Entity. Does not do anything
     /// if the specified Entity is invalid or does not have any Scripts
     /// attached.
     /// </summary>
     /// <param name="entity">The entity to remove the scripts from.</param>
-    void RemoveAllScripts(const SHEntity& entity);
+    void RemoveAllScripts(EntityID entity);
     /// <summary>
     /// Removes all Scripts attached to the specified Entity. Unlike
     /// RemoveAllScripts(), this removes all the scripts immediately.
@@ -135,7 +135,7 @@ namespace SHADE
     /// Whether or not to call OnDestroy on the scripts. This is ignored if not in
     /// play mode.
     /// </param>
-    void RemoveAllScriptsImmediately(const SHEntity& entity, bool callOnDestroy);
+    void RemoveAllScriptsImmediately(EntityID entity, bool callOnDestroy);
 
     /*-----------------------------------------------------------------------------*/
     /* Script Serialisation Functions                                              */

TempShaderFolder/ShaderDescriptorDefinitions.glsl

@@ -0,0 +1,11 @@
+#define SET_STATIC_GLOBALS 0
+#define SET_DYNAMIC_GLOBALS 1
+#define SET_HIGH_FREQUENCY_GLOBALS 2
+
+#define BINDING_GENERIC_DATA 0
+#define BINDING_IMAGE_AND_SAMPLERS_DATA 1
+#define BINDING_LIGHTS_DATA 0
+#define BINDING_CAMERA_DATA 0
+#define BINDING_BATCHED_PER_INST_DATA 0
+
+

TempShaderFolder/TestCubeVs.glsl

@@ -1,6 +1,8 @@
 #version 450
 #extension GL_KHR_vulkan_glsl : enable
 
+//#include "ShaderDescriptorDefinitions.glsl"
+
 layout(location = 0) in vec3 aVertexPos;
 layout(location = 1) in vec2 aUV;
 layout(location = 2) in vec3 aNormal;
@@ -28,6 +30,12 @@ layout(location = 0) out struct
 
 } Out;
 
+layout(set = 2, binding = 0) uniform CameraData
+{
+  vec4 position; 
+  mat4 vpMat;
+} cameraData;
+
 void main()
 {
   //const float gamma = testPushConstant.eyePosition.w;
@@ -48,6 +56,7 @@ void main()
   //Out.uv = aUV;
 
   // render NDC first
-  gl_Position = vec4(aVertexPos, 1.0);
+  //gl_Position = vec4(aVertexPos, 1.0f);
+  gl_Position = cameraData.vpMat * worldTransform * vec4 (aVertexPos, 1.0f);
   Out.vertColor = vec4 (aVertexPos, 1.0f);
 }