.gitignore

@@ -363,8 +363,6 @@ MigrationBackup/
 
 *.filters
 
-Assets/Editor/Layouts/UserLayout.ini
-
 JSON/Schemas/Catalog/
 
 Assets/Editor/Editor.SHConfig

Assets/Application.SHConfig

@@ -1,4 +1,4 @@
 Start in Fullscreen: false
-Starting Scene ID: 87244611
+Starting Scene ID: 97158628
 Window Size: {x: 1920, y: 1080}
 Window Title: SHADE Engine

Assets/Bindings.SHConfig

@@ -1 +1,96 @@
+7
+Controller Look Horizontal
 0
+0
+5
+0.2
+5
+0
+0
+0
+1
+18
+0
+Controller Look Vertical
+0
+0
+5
+0.2
+5
+0
+0
+0
+1
+19
+0
+Horizontal
+0
+0
+5
+0.2
+5
+1
+2
+39
+68
+2
+37
+65
+2
+3
+16
+1
+2
+Jump
+0
+0
+1000
+0.2
+1000
+0
+1
+32
+0
+1
+10
+0
+Mouse Look Horizontal
+1
+0
+1
+0.2
+1
+0
+0
+0
+0
+0
+Mouse Look Vertical
+2
+0
+1
+0.2
+1
+0
+0
+0
+0
+0
+Vertical
+0
+0
+5
+0.2
+5
+1
+2
+38
+87
+2
+40
+83
+2
+0
+17
+1
+1

Assets/Editor/Editor.SHConfig

@@ -1,4 +0,0 @@
-Start Maximized: true
-Working Scene ID: 97161771
-Window Size: {x: 1920, y: 1080}
-Style: 0

Assets/Editor/Layouts/UserLayout.ini

@@ -0,0 +1,165 @@
+[Window][MainStatusBar]
+Pos=0,989
+Size=1920,20
+Collapsed=0
+
+[Window][SHEditorMenuBar]
+Pos=0,48
+Size=1920,941
+Collapsed=0
+
+[Window][Hierarchy Panel]
+Pos=0,187
+Size=300,802
+Collapsed=0
+DockId=0x00000004,0
+
+[Window][Debug##Default]
+Pos=60,60
+Size=400,400
+Collapsed=0
+
+[Window][Inspector]
+Pos=1604,48
+Size=316,941
+Collapsed=0
+DockId=0x00000006,0
+
+[Window][Profiler]
+Pos=0,48
+Size=300,137
+Collapsed=0
+DockId=0x00000003,0
+
+[Window][Viewport]
+Pos=227,48
+Size=1457,1012
+Collapsed=0
+DockId=0x0000000B,0
+
+[Window][ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌð‡Žoû]
+Pos=60,60
+Size=32,64
+Collapsed=0
+
+[Window][ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ]
+Pos=60,60
+Size=999,581
+Collapsed=0
+
+[Window][ð‡–oû]
+Pos=60,60
+Size=32,64
+Collapsed=0
+
+[Window][ÌÌÌÌ]
+Pos=60,60
+Size=553,422
+Collapsed=0
+
+[Window][]
+Pos=60,60
+Size=770,394
+Collapsed=0
+
+[Window][ Viewport]
+Pos=227,48
+Size=1457,1012
+Collapsed=0
+DockId=0x0000000B,0
+
+[Window][ Viewport]
+Pos=227,48
+Size=1457,1012
+Collapsed=0
+DockId=0x0000000B,0
+
+[Window][î<>‹ Viewport]
+Pos=302,48
+Size=1300,836
+Collapsed=0
+DockId=0x0000000B,0
+
+[Window][V]
+Pos=310,722
+Size=1501,338
+Collapsed=0
+DockId=0x00000008,0
+
+[Window][p›£€Ê
]
+Pos=310,750
+Size=1501,310
+Collapsed=0
+DockId=0x0000000A,0
+
+[Window][ Asset Browser]
+Pos=302,886
+Size=1300,103
+Collapsed=0
+DockId=0x0000000C,0
+
+[Window][Material Inspector]
+Pos=1604,48
+Size=316,941
+Collapsed=0
+DockId=0x00000006,1
+
+[Window][Save scene as...]
+Pos=1197,693
+Size=165,120
+Collapsed=0
+
+[Window][Create New Asset]
+Pos=896,472
+Size=464,144
+Collapsed=0
+
+[Window][Collider Tag Panel]
+Pos=60,60
+Size=625,744
+Collapsed=0
+
+[Window][Input Bindings Panel]
+Pos=60,60
+Size=154,204
+Collapsed=0
+
+[Window][Save Scene As]
+Pos=877,444
+Size=165,120
+Collapsed=0
+
+[Table][0x9D40AE32,17]
+Column 0  Weight=1.0000
+Column 1  Weight=1.0000
+Column 2  Weight=1.0000
+Column 3  Weight=1.0000
+Column 4  Weight=1.0000
+Column 5  Weight=1.0000
+Column 6  Weight=1.0000
+Column 7  Weight=1.0000
+Column 8  Weight=1.0000
+Column 9  Weight=1.0000
+Column 10 Weight=1.0000
+Column 11 Weight=1.0000
+Column 12 Weight=1.0000
+Column 13 Weight=1.0000
+Column 14 Weight=1.0000
+Column 15 Weight=1.0000
+Column 16 Weight=1.0000
+
+[Docking][Data]
+DockSpace           ID=0xC5C9B8AB Window=0xBE4044E9 Pos=0,71 Size=1920,941 Split=X
+  DockNode          ID=0x00000005 Parent=0xC5C9B8AB SizeRef=1602,1036 Split=X
+    DockNode        ID=0x00000001 Parent=0x00000005 SizeRef=300,1036 Split=Y Selected=0x1E6EB881
+      DockNode      ID=0x00000003 Parent=0x00000001 SizeRef=225,147 Selected=0x1E6EB881
+      DockNode      ID=0x00000004 Parent=0x00000001 SizeRef=225,863 Selected=0xE096E5AE
+    DockNode        ID=0x00000002 Parent=0x00000005 SizeRef=1300,1036 Split=Y Selected=0xB41284E7
+      DockNode      ID=0x00000007 Parent=0x00000002 SizeRef=1501,672 Split=Y Selected=0xB41284E7
+        DockNode    ID=0x00000009 Parent=0x00000007 SizeRef=1501,700 Split=Y Selected=0xB41284E7
+          DockNode  ID=0x0000000B Parent=0x00000009 SizeRef=1501,836 CentralNode=1 Selected=0xB41284E7
+          DockNode  ID=0x0000000C Parent=0x00000009 SizeRef=1501,103 Selected=0xB128252A
+        DockNode    ID=0x0000000A Parent=0x00000007 SizeRef=1501,310 Selected=0xD446F7B6
+      DockNode      ID=0x00000008 Parent=0x00000002 SizeRef=1501,338 Selected=0xD9F31532
+  DockNode          ID=0x00000006 Parent=0xC5C9B8AB SizeRef=316,1036 Selected=0xE7039252
+

Assets/Materials/AnimatedBag.shmat

@@ -0,0 +1,8 @@
+- VertexShader: 47911992
+  FragmentShader: 46377769
+  SubPass: G-Buffer Write
+  Properties:
+    data.color: {x: 1, y: 1, z: 1, w: 1}
+    data.textureIndex: 58303057
+    data.alpha: 0
+    data.beta: {x: 1, y: 1, z: 1}

Assets/Materials/AnimatedBag.shmat.shmeta

@@ -0,0 +1,3 @@
+Name: AnimatedBag
+ID: 117923942
+Type: 7

Assets/Materials/AnimatedRaccoon.shmat

@@ -0,0 +1,8 @@
+- VertexShader: 47911992
+  FragmentShader: 46377769
+  SubPass: G-Buffer Write
+  Properties:
+    data.color: {x: 1, y: 1, z: 1, w: 1}
+    data.textureIndex: 64651793
+    data.alpha: 0
+    data.beta: {x: 1, y: 1, z: 1}

Assets/Materials/AnimatedRaccoon.shmat.shmeta

@@ -0,0 +1,3 @@
+Name: AnimatedRaccoon
+ID: 128805346
+Type: 7

Assets/Materials/UIMat_LoseScene.shmat

@@ -1,6 +1,6 @@
 - VertexShader: 46580970
   FragmentShader: 35983630
-  SubPass: G-Buffer Write
+  SubPass: UI
   Properties:
     data.color: {x: 1, y: 1, z: 1, w: 1}
     data.textureIndex: 54324293

Assets/Materials/UIMat_MainMenu.shmat

@@ -1,6 +1,6 @@
 - VertexShader: 46580970
   FragmentShader: 35983630
-  SubPass: G-Buffer Write
+  SubPass: UI
   Properties:
     data.color: {x: 1, y: 1, z: 1, w: 1}
     data.textureIndex: 54429632

Assets/Materials/UIMat_WinScene.shmat

@@ -1,6 +1,6 @@
 - VertexShader: 46580970
   FragmentShader: 35983630
-  SubPass: G-Buffer Write
+  SubPass: UI
   Properties:
     data.color: {x: 1, y: 1, z: 1, w: 1}
     data.textureIndex: 57302694

Assets/Models/BoneIKTest4.shmodel.shmeta

@@ -0,0 +1,7 @@
+Name: BoneIKTest4
+ID: 81814706
+Type: 4
+Sub Assets:
+Name: Cube
+ID: 137599708
+Type: 8

Assets/Scripts/SC_SoundsBoard.cs

@@ -4,6 +4,7 @@ using System;
 
 public class SoundsBoard : Script
 {
+  AudioClipHandler test;
   protected override void awake()
   {
     /*
@@ -31,13 +32,21 @@ event:/Homeowner/homeowner_humming
 event:/Homeowner/homeowner_footsteps
 event:/Homeowner/homeowner_detect_raccoon
      */
+    test = Audio.CreateAudioClip("event:/Music/player_undetected");
+    Audio.AddAudioClipToSFXChannelGroup(test);
+  }
+
+  protected override void start()
+  {
+    test.Play();
   }
   protected override void update()
   {
+
     if (Input.GetKeyDown(Input.KeyCode.Q))
-      Audio.PlayBGMOnce2D("event:/UI/mouse_down_element");
+      test.Play();
     if (Input.GetKeyDown(Input.KeyCode.W))
-      Audio.PlayBGMOnce2D("event:/UI/mouse_down_empty");
+      test.Stop(true);
     if (Input.GetKeyDown(Input.KeyCode.E))
       Audio.PlayBGMOnce2D("event:/UI/mouse_enter_element");
     if (Input.GetKeyDown(Input.KeyCode.R))

Assets/Shaders/Anim_VS.glsl

@@ -0,0 +1,78 @@
+#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;
+layout(location = 3)  in vec3 aTangent;
+layout(location = 4)  in mat4 worldTransform;
+layout(location = 8)  in uvec2 integerData;
+layout(location = 9)  in uvec4 aBoneIndices;
+layout(location = 10) in vec4 aBoneWeights;
+layout(location = 11) in uint firstBoneIndex;
+
+layout(location = 0) out struct
+{
+  vec4 vertPos; // location 0
+  vec2 uv; // location = 1
+  vec4 normal; // location = 2
+  vec4 worldPos; // location = 3 
+} Out;
+
+// material stuff
+layout(location = 4) out struct
+{
+  int materialIndex;
+  uint eid;
+  uint lightLayerIndex;
+
+} Out2;
+
+layout(set = 1, binding = 0) uniform CameraData
+{
+  vec4 position; 
+  mat4 vpMat;
+  mat4 viewMat;
+  mat4 projMat;
+} cameraData;
+
+layout (std430, set = 2, binding = 1) buffer AnimBoneMatrices
+{
+  mat4 data[];
+} BoneMatrices;
+
+void main()
+{
+  Out2.materialIndex = gl_InstanceIndex;
+  Out2.eid             = integerData[0];
+  Out2.lightLayerIndex = integerData[1];
+
+  // for transforming gBuffer position and normal data
+  mat4 modelViewMat = cameraData.viewMat * worldTransform;
+
+  // gBuffer position will be in view space
+  Out.vertPos = modelViewMat * vec4(aVertexPos, 1.0f);
+  
+  Out.worldPos = worldTransform * vec4 (aVertexPos, 1.0f);
+
+  // uvs for texturing in fragment shader
+  Out.uv = aUV;
+
+  mat3 transposeInv = mat3 (transpose(inverse(modelViewMat)));
+
+  // normals are also in view space
+  Out.normal.rgb = transposeInv * aNormal.rgb;
+  Out.normal.rgb = normalize (Out.normal.rgb);
+
+  // Compute bone matrix
+  mat4 boneMatrix = BoneMatrices.data[firstBoneIndex + aBoneIndices[0]] * aBoneWeights[0];
+  boneMatrix     += BoneMatrices.data[firstBoneIndex + aBoneIndices[1]] * aBoneWeights[1];
+  boneMatrix     += BoneMatrices.data[firstBoneIndex + aBoneIndices[2]] * aBoneWeights[2];
+  boneMatrix     += BoneMatrices.data[firstBoneIndex + aBoneIndices[3]] * aBoneWeights[3];
+
+  // clip space for rendering
+  gl_Position = cameraData.vpMat * worldTransform * boneMatrix * vec4 (aVertexPos, 1.0f);
+}

Assets/Shaders/Anim_VS.shshaderb.shmeta

@@ -0,0 +1,3 @@
+Name: Anim_VS
+ID: 47911992
+Type: 2

Assets/Shaders/TestCube_FS.glsl

@@ -17,7 +17,6 @@ layout(location = 0) in struct
   vec2 uv; // location = 1
   vec4 normal; // location = 2
   vec4 worldPos; // location = 3 
-
 } In;
 
 // material stuff

Assets/Shaders/TestCube_VS.glsl

@@ -10,7 +10,9 @@ layout(location = 2) in vec3 aNormal;
 layout(location = 3) in vec3 aTangent;
 layout(location = 4) in mat4 worldTransform;
 layout(location = 8) in uvec2 integerData;
-
+layout(location = 9)  in uvec4 aBoneIndices;
+layout(location = 10) in vec4 aBoneWeights;
+layout(location = 11) in uint firstBoneIndex;
 
 layout(location = 0) out struct
 {

Assets/Shaders/UI_FS.glsl

@@ -33,18 +33,11 @@ layout (std430, set = 2, binding = 0) buffer MaterialProperties     // For mater
   MatPropData data[];
 } MatProp;
 
-layout(location = 0) out vec4 position;
+layout(location = 0) out vec4 fragColor;
 layout(location = 1) out uint outEntityID;
-layout(location = 2) out uint lightLayerIndices;
-layout(location = 3) out vec4 normals;
-layout(location = 4) out vec4 albedo;
 
 void main()
 {
-  position = In.vertPos;
-  normals = In.normal;
-  albedo = texture(textures[nonuniformEXT(MatProp.data[In2.materialIndex].textureIndex)], In.uv);
-
+  fragColor = texture(textures[nonuniformEXT(MatProp.data[In2.materialIndex].textureIndex)], In.uv);
   outEntityID = In2.eid;
-  lightLayerIndices = In2.lightLayerIndex;
 }

SHADE_Application/src/Application/SBApplication.cpp

@@ -34,6 +34,7 @@
 #include "Physics/System/SHPhysicsDebugDrawSystem.h"
 #include "Scripting/SHScriptEngine.h"
 #include "UI/SHUISystem.h"
+#include "Animation/SHAnimationSystem.h"
 
 // Components
 #include "Graphics/MiddleEnd/Interface/SHRenderable.h"
@@ -47,6 +48,7 @@
 
 #include "Tools/Logger/SHLogger.h"
 #include "Tools/SHDebugDraw.h"
+#include "Resource/SHResourceManager.h"
 
 using namespace SHADE;
 
@@ -95,6 +97,7 @@ namespace Sandbox
     // Link up SHDebugDraw
     SHSystemManager::CreateSystem<SHDebugDrawSystem>();
     SHDebugDraw::Init(SHSystemManager::GetSystem<SHDebugDrawSystem>());
+    SHSystemManager::CreateSystem<SHAnimationSystem>();
     
 #ifdef SHEDITOR
     SDL_Init(SDL_INIT_VIDEO);
@@ -141,7 +144,7 @@ namespace Sandbox
 #ifdef SHEDITOR
     SHSystemManager::RegisterRoutine<SHEditor, SHEditor::EditorRoutine>();
 #endif
-
+    SHSystemManager::RegisterRoutine<SHAnimationSystem, SHAnimationSystem::UpdateRoutine>();
     SHSystemManager::RegisterRoutine<SHGraphicsSystem, SHGraphicsSystem::RenderRoutine>();
     SHSystemManager::RegisterRoutine<SHGraphicsSystem, SHGraphicsSystem::EndRoutine>();
 
@@ -149,6 +152,7 @@ namespace Sandbox
     SHComponentManager::CreateComponentSparseSet<SHColliderComponent>();
     SHComponentManager::CreateComponentSparseSet<SHTransformComponent>();
     SHComponentManager::CreateComponentSparseSet<SHRenderable>();
+    SHComponentManager::CreateComponentSparseSet<SHAnimatorComponent>();
     //SHComponentManager::CreateComponentSparseSet<SHCameraComponent>();
 
     SHAssetManager::Load();
@@ -170,6 +174,10 @@ namespace Sandbox
 
     // Link up SHDebugDraw
     SHDebugDraw::Init(SHSystemManager::GetSystem<SHDebugDrawSystem>());
+
+    auto clip = SHResourceManager::LoadOrGet<SHAnimationClip>(77816045);
+    auto rig = SHResourceManager::LoadOrGet<SHRig>(77816045);
+    int i = 0;
   }
 
   void SBApplication::Update(void)
@@ -232,7 +240,13 @@ namespace Sandbox
     SDL_Quit();
   #endif
 
+    // Unload scenes
     SHSceneManager::Exit();
+
+    // Free all remaining resources
+    SHResourceManager::UnloadAll();
+
+    // Shut down engine
     SHSystemManager::Exit();
     SHAssetManager::Exit();
   }

SHADE_Engine/src/Animation/SHAnimationClip.cpp

@@ -0,0 +1,65 @@
+/************************************************************************************//*!
+\file           SHAnimationClip.cpp
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Nov 20, 2022
+\brief          Contains the function definitions of the SHAnimationClip class.
+
+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.
+*//*************************************************************************************/
+// Pre-compiled Header
+#include "SHpch.h"
+// Primary Header
+#include "SHAnimationClip.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Constructors                                                                      */
+  /*-----------------------------------------------------------------------------------*/
+  SHAnimationClip::SHAnimationClip(const SHAnimAsset& asset)
+  : ticksPerSecond { static_cast<int>(asset.ticksPerSecond) }
+  , totalTime      { static_cast<float>(asset.duration) / static_cast<int>(asset.ticksPerSecond) }
+  {
+    // Populate keyframes
+    for (const auto& channel : asset.nodeChannels)
+    {
+      // Create a channel
+      Channel newChannel;
+      newChannel.Name = std::string(channel.name);
+      newChannel.PositionKeyFrames.reserve(channel.positionKeys.size());
+      newChannel.RotationKeyFrames.reserve(channel.rotationKeys.size());
+      newChannel.ScaleKeyFrames.reserve(channel.scaleKeys.size());
+
+      // Populate Keyframes
+      for (const auto& posKey : channel.positionKeys)
+      {
+        newChannel.PositionKeyFrames.emplace_back(SHAnimationKeyFrame<SHVec3>{ static_cast<int>(posKey.time), posKey.value});
+      }
+      for (const auto& rotKey : channel.rotationKeys)
+      {
+        newChannel.RotationKeyFrames.emplace_back(SHAnimationKeyFrame<SHQuaternion>{ static_cast<int>(rotKey.time), rotKey.value});
+      }
+      for (const auto& scaleKey : channel.scaleKeys)
+      {
+        newChannel.ScaleKeyFrames.emplace_back(SHAnimationKeyFrame<SHVec3>{ static_cast<int>(scaleKey.time), scaleKey.value});
+      }
+
+      newChannel.MaxFrames = std::max({ newChannel.PositionKeyFrames.size(), newChannel.RotationKeyFrames.size(), newChannel.ScaleKeyFrames.size() });
+
+      // Insert the channel
+      channels.emplace_back(std::move(newChannel));
+    }
+  }
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Usage Functions                                                                   */
+  /*-----------------------------------------------------------------------------------*/
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Helper Functions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+
+}

SHADE_Engine/src/Animation/SHAnimationClip.h

@@ -0,0 +1,85 @@
+/************************************************************************************//*!
+\file           SHAnimationClip.h
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Dec 12, 2022
+\brief          Contains the definition of the SHAnimationClip struct and related types.
+
+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
+
+// Project Includes
+#include "SH_API.h"
+#include "Math/SHMatrix.h"
+#include "Assets/Asset Types/Models/SHAnimationAsset.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Type Definitions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+  /// <summary>
+  /// Defines a single key frame in an animation for a specific type of data.
+  /// </summary>
+  template<typename T>
+  struct SHAnimationKeyFrame
+  {
+    int FrameIndex;
+    T   Data;
+  };
+
+  /// <summary>
+  /// Represents a animation clip of a 3D animation that is made for a specific model
+  /// rig.
+  /// </summary>
+  class SH_API SHAnimationClip
+  { 
+    public:
+    /*---------------------------------------------------------------------------------*/
+    /* Type Definitions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Defines the animations of a single bone in a rig.
+    /// </summary>
+    struct Channel
+    {
+      std::string Name;
+      std::vector<SHAnimationKeyFrame<SHVec3>>       PositionKeyFrames;
+      std::vector<SHAnimationKeyFrame<SHQuaternion>> RotationKeyFrames;
+      std::vector<SHAnimationKeyFrame<SHVec3>>       ScaleKeyFrames;
+      int MaxFrames;
+    };
+
+    /*---------------------------------------------------------------------------------*/
+    /* Constructors                                                                    */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Constructs an SHAnimation Clip from a specified SHAnimAsset.
+    /// </summary>
+    /// <param name="asset">Animation asset to load.</param>
+    explicit SHAnimationClip(const SHAnimAsset& asset);
+    
+    /*---------------------------------------------------------------------------------*/
+    /* Getter Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    const std::vector<Channel>& GetChannels() const noexcept { return channels; }
+    int GetTicksPerSecond() const noexcept { return ticksPerSecond; }
+    float GetTotalTime() const noexcept { return totalTime; }
+
+    private:
+    /*---------------------------------------------------------------------------------*/
+    /* Data Members                                                                    */
+    /*---------------------------------------------------------------------------------*/
+    std::vector<Channel> channels;
+    int ticksPerSecond;
+    float totalTime;
+
+    /*---------------------------------------------------------------------------------*/
+    /* Helper Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+
+  };
+}

SHADE_Engine/src/Animation/SHAnimationSystem.cpp

@@ -0,0 +1,54 @@
+/************************************************************************************//*!
+\file           SHAnimationSystem.cpp
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Nov 20, 2022
+\brief          Contains the function definitions of the SHAnimationSystem class.
+
+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.
+*//*************************************************************************************/
+// Precompiled Header
+#include "SHpch.h"
+// Primary Include
+#include "SHAnimationSystem.h"
+// Project Includes
+#include "ECS_Base/Managers/SHComponentManager.h"
+#include "SHAnimatorComponent.h"
+#include "ECS_Base/General/SHFamily.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* System Routine Functions - UpdateRoutine                                          */
+  /*-----------------------------------------------------------------------------------*/
+  SHAnimationSystem::UpdateRoutine::UpdateRoutine()
+  : SHSystemRoutine("Animation System Update", true)
+  {
+    SHFamilyID<SHSystem>::GetID<SHAnimationSystem>();
+  }
+
+  void SHAnimationSystem::UpdateRoutine::Execute(double dt) noexcept
+  {
+    auto& animators = SHComponentManager::GetDense<SHAnimatorComponent>();
+    for (auto& animator : animators)
+    {
+      animator.Update(dt);
+    }
+  }
+
+  /*---------------------------------------------------------------------------------*/
+  /* SHSystem Overrides                                                              */
+  /*---------------------------------------------------------------------------------*/
+  void SHAnimationSystem::Init(void)
+  {
+
+  }
+
+  void SHAnimationSystem::Exit(void)
+  {
+
+  }
+
+}

SHADE_Engine/src/Animation/SHAnimationSystem.h

@@ -0,0 +1,55 @@
+/************************************************************************************//*!
+\file           SHAnimationSystem.h
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Nov 20, 2022
+\brief          Contains the definition of the SHAnimationSystem class and related types.
+
+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
+
+// Project Includes
+#include "SH_API.h"
+#include "ECS_Base/System/SHSystem.h"
+#include "ECS_Base/System/SHSystemRoutine.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Type Definitions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+  /// <summary>
+  /// System that is responsible for updating all animations.
+  /// </summary>
+  class SH_API SHAnimationSystem : public SHSystem
+  {
+    public:
+    /*---------------------------------------------------------------------------------*/
+    /* Type Definitions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Responsible for updating the playback of all animator components and computing
+    /// the required bone matrices.
+    /// </summary>
+    class SH_API UpdateRoutine final : public SHSystemRoutine
+    {
+      public:
+      UpdateRoutine();
+      void Execute(double dt) noexcept override final;
+    };
+
+    /*---------------------------------------------------------------------------------*/
+    /* Constructors                                                                    */
+    /*---------------------------------------------------------------------------------*/
+    SHAnimationSystem() = default;
+
+    /*---------------------------------------------------------------------------------*/
+    /* SHSystem Overrides                                                              */
+    /*---------------------------------------------------------------------------------*/
+    virtual void Init(void) override final;
+    virtual void Exit(void) override final;
+  };
+}

SHADE_Engine/src/Animation/SHAnimatorComponent.cpp

@@ -0,0 +1,187 @@
+/************************************************************************************//*!
+\file           SHAnimatorComponent.cpp
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Nov 20, 2022
+\brief          Contains the definition of functions of the SHAnimatorComponent Component
+                class.
+
+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.
+*//*************************************************************************************/
+// Precompiled Header
+#include "SHpch.h"
+// Primary Include
+#include "SHAnimatorComponent.h"
+// STL Includes
+#include <queue>
+// Project Includes
+#include "SHRig.h"
+#include "Math/SHMatrix.h"
+#include "SHAnimationClip.h"
+#include "Graphics/SHVkUtil.h"
+#include "Graphics/MiddleEnd/Interface/SHGraphicsSystem.h"
+#include "ECS_Base/Managers/SHSystemManager.h"
+#include "Tools/SHDebugDraw.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Usage Functions                                                                   */
+  /*-----------------------------------------------------------------------------------*/
+  void SHAnimatorComponent::Play()
+  {
+    isPlaying = false;
+  }
+
+  void SHAnimatorComponent::Play(Handle<SHAnimationClip> clip)
+  {
+    currClip = clip;
+    currPlaybackTime = 0.0f;
+    Play();
+  }
+
+  void SHAnimatorComponent::PlayFromStart()
+  {
+    isPlaying = true;
+    currPlaybackTime = 0.0f;
+  }
+
+  void SHAnimatorComponent::Pause()
+  {
+    isPlaying = false;
+  }
+
+  void SHAnimatorComponent::Stop()
+  {
+    isPlaying = false;
+    currPlaybackTime = 0.0f;
+  }
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Setter Functions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+  void SHAnimatorComponent::SetRig(Handle<SHRig> newRig)
+  {
+    // Same rig, don't bother
+    if (rig == newRig)
+      return;
+
+    rig = newRig;
+
+    // Populate bone matrices based on new rig's default pose
+    boneMatrices.clear();
+    if (rig)
+    {
+      std::fill_n(std::back_inserter(boneMatrices), rig->GetNodeCount(), SHMatrix::Identity);
+    }
+  }
+
+  void SHAnimatorComponent::SetClip(Handle<SHAnimationClip> newClip)
+  {
+    // No change
+    if (currClip == newClip)
+      return;
+
+    // Set parameters
+    currClip = newClip;
+    secsPerTick = 1.0f / currClip->GetTicksPerSecond();
+
+    // Build channel map
+    channelMap.clear();
+    if (currClip)
+    {
+      for (const auto& channel : currClip->GetChannels())
+      {
+        channelMap.emplace(channel.Name, &channel);
+      }
+    }
+
+    if (rig && currClip)
+    {
+      updatePoseWithClip(0.0f);
+    }
+  }
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Update Functions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+  void SHAnimatorComponent::Update(float dt)
+  {
+    // Nothing to animate
+    if (!currClip || !isPlaying || !rig)
+      return;
+
+    // Update time on the playback
+    currPlaybackTime += dt;
+    if (currPlaybackTime > currClip->GetTotalTime())
+    {
+      currPlaybackTime = currPlaybackTime - currClip->GetTotalTime();
+    }
+
+    // Reset all matrices
+    for (auto& mat : boneMatrices)
+    {
+      mat = SHMatrix::Identity;
+    }
+
+    // Play the clip
+    updatePoseWithClip(currPlaybackTime);
+  }
+  
+  /*-----------------------------------------------------------------------------------*/
+  /* Helper Functions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+  void SHAnimatorComponent::updatePoseWithClip(float poseTime)
+  {
+    // Get closest frame index
+    const int CLOSEST_FRAME_IDX = static_cast<int>(std::floorf(poseTime * currClip->GetTicksPerSecond()));
+    updatePoseWithClip(CLOSEST_FRAME_IDX, poseTime, rig->GetRootNode(), SHMatrix::Identity);
+  }
+
+  void SHAnimatorComponent::updatePoseWithClip(int closestFrameIndex, float poseTime, Handle<SHRigNode> node, const SHMatrix& parentMatrix)
+  {
+    // Check if there is a channel for this node
+    const std::string& BONE_NAME = rig->GetName(node);
+    SHMatrix transformMatrix = node->TransformMatrix;
+    if (channelMap.contains(BONE_NAME))
+    {
+      const auto CHANNEL = channelMap[BONE_NAME];
+      transformMatrix = SHMatrix::Transform
+      (
+        getInterpolatedValue(CHANNEL->PositionKeyFrames, closestFrameIndex, poseTime),
+        getInterpolatedValue(CHANNEL->RotationKeyFrames, closestFrameIndex, poseTime),
+        getInterpolatedValue(CHANNEL->ScaleKeyFrames, closestFrameIndex, poseTime)
+      );
+    }
+
+    // Apply parent's transformation
+    transformMatrix = transformMatrix * parentMatrix;
+
+    // Apply transformations to this node
+    const int BONE_MTX_IDX = rig->GetNodeIndex(node);
+    std::optional<SHVec3> position;
+    if (BONE_MTX_IDX >= 0)
+    {
+      boneMatrices[BONE_MTX_IDX] = node->OffsetMatrix * transformMatrix;
+    }
+
+    // Apply pose to children
+    for (auto& child : node->Children)
+    {
+      updatePoseWithClip(closestFrameIndex, poseTime, child, transformMatrix);
+    }
+  }
+}
+
+/*-------------------------------------------------------------------------------------*/
+/* RTTR Registration                                                                   */
+/*-------------------------------------------------------------------------------------*/
+RTTR_REGISTRATION
+{
+  using namespace SHADE;
+  using namespace rttr;
+
+  registration::class_<SHAnimatorComponent>("Animator Component");
+}

SHADE_Engine/src/Animation/SHAnimatorComponent.h

@@ -0,0 +1,155 @@
+/************************************************************************************//*!
+\file           SHAnimatorComponent.h
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Nov 20, 2022
+\brief          Contains the definition of the SHAnimatorComponent class and related 
+                types.
+
+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>
+// External Dependencies
+#include <rttr/registration>
+// Project Includes
+#include "ECS_Base/Components/SHComponent.h"
+#include "Resource/SHHandle.h"
+#include "Math/SHMatrix.h"
+#include "Math/Vector/SHVec3.h"
+#include "Math/SHQuaternion.h"
+#include "SHAnimationClip.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Forward Declarations                                                              */
+  /*-----------------------------------------------------------------------------------*/
+  class SHRig;
+  struct SHRigNode;
+  class SHAnimationClip;
+  class SHVkBuffer;
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Type Definitions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+  /// <summary>
+  /// Component that holds and controls the animation related properties of a skinned 
+  /// mesh.
+  /// </summary>
+  class SH_API SHAnimatorComponent final : public SHComponent
+  {    
+    public:
+    /*---------------------------------------------------------------------------------*/
+    /* Usage Functions                                                                 */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Plays the currently loaded animation from the last time.
+    /// </summary>
+    void Play();
+    /// <summary>
+    /// Plays the specified animation clip from the start.
+    /// </summary>
+    /// <param name="clip"></param>
+    void Play(Handle<SHAnimationClip> clip);
+    /// <summary>
+    /// Plays the currently loaded animation clip from the start.
+    /// </summary>
+    void PlayFromStart();
+    /// <summary>
+    /// Pauses the animation at the current time.
+    /// </summary>
+    void Pause();
+    /// <summary>
+    /// Stops the animation and resets the play time back to 0.
+    /// </summary>
+    void Stop();
+
+    /*---------------------------------------------------------------------------------*/
+    /* Setter Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Sets the animation rig for this animator.
+    /// </summary>
+    /// <param name="newRig">Rig to use.</param>
+    void SetRig(Handle<SHRig> newRig);
+    /// <summary>
+    /// Sets the animation clip of this animator without playing it.
+    /// This will set the pose of the model to it's initial pose.
+    /// If the clip is the same as the current clip, nothing happens.
+    /// </summary>
+    /// <param name="newClip">Clip to use.</param>
+    void SetClip(Handle<SHAnimationClip> newClip);
+
+    /*---------------------------------------------------------------------------------*/
+    /* Getter Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Retrieves all the bone matrices of this animator.
+    /// </summary>
+    /// <returns>Reference to a vector of the bone matrices.</returns>
+    const std::vector<SHMatrix>& GetBoneMatrices() const noexcept { return boneMatrices; }
+    /// <summary>
+    /// Retrieve the currently set model rig.
+    /// </summary>
+    /// <returns>Handle to the currently set rig.</returns>
+    Handle<SHRig> GetRig() const noexcept { return rig; }
+    /// <summary>
+    /// <summary>
+    /// Retrieve the currently set animation clip.
+    /// </summary>
+    /// <returns>Handle to the currently set animation clip.</returns>
+    Handle<SHAnimationClip> GetCurrentClip() const noexcept { return currClip; }
+    /// <summary>
+    /// Checks if an animation is currently playing.
+    /// </summary>
+    /// <returns>True if an animation clip is currently playing.</returns>
+    bool IsPlaying() const { return isPlaying; }
+
+    /*---------------------------------------------------------------------------------*/
+    /* Update Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Updates the current state of the animation if one is specified based on the
+    /// current animation clip and frames. This will update the bone matrices.
+    /// </summary>
+    /// <param name="dt">Time passed since the last frame.</param>
+    void Update(float dt);
+
+    private:
+    /*---------------------------------------------------------------------------------*/
+    /* Data Members                                                                    */
+    /*---------------------------------------------------------------------------------*/
+    // Resources
+    Handle<SHRig> rig;
+    Handle<SHAnimationClip> currClip;
+    // Playback Tracking
+    float currPlaybackTime = 0.0f;
+    bool isPlaying = true;
+    // Useful Cached Data
+    float secsPerTick = 0.0f;
+    // Buffer
+    std::vector<SHMatrix> boneMatrices;
+    // Caches
+    std::unordered_map<std::string, const SHAnimationClip::Channel*> channelMap;
+
+    /*---------------------------------------------------------------------------------*/
+    /* Helper Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    void updatePoseWithClip(float poseTime);
+    void updatePoseWithClip(int closestFrameIndex, float poseTime, Handle<SHRigNode> node, const SHMatrix& parentMatrix);
+    template<typename T>
+    T getInterpolatedValue(const std::vector<SHAnimationKeyFrame<T>>& keyframes, int closestFrameIndex, float poseTime);
+
+    /*---------------------------------------------------------------------------------*/
+    /* RTTR                                                                            */
+    /*---------------------------------------------------------------------------------*/
+    RTTR_ENABLE()
+  };
+}
+
+#include "SHAnimatorComponent.hpp"

SHADE_Engine/src/Animation/SHAnimatorComponent.hpp

@@ -0,0 +1,82 @@
+/************************************************************************************//*!
+\file           SHAnimatorComponent.hpp
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Jan 10, 2023
+\brief          Contains the definition of function templates of the SHAnimatorComponent
+                Component class.
+
+Copyright (C) 2023 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.
+*//*************************************************************************************/
+// Primary Include
+#include "SHAnimatorComponent.h"
+// Project Includes
+#include "SHRig.h"
+#include "Math/SHMatrix.h"
+#include "SHAnimationClip.h"
+#include "Graphics/SHVkUtil.h"
+#include "Graphics/MiddleEnd/Interface/SHGraphicsSystem.h"
+#include "ECS_Base/Managers/SHSystemManager.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Helper Functions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+  template<typename T>
+  T SHAnimatorComponent::getInterpolatedValue(const std::vector<SHAnimationKeyFrame<T>>& keyframes, int closestFrameIndex, float poseTime)
+  {
+    // Only allow SHVec3 and SHQuaternion
+    static_assert(std::is_same_v<T, SHVec3> || std::is_same_v<T, SHQuaternion>, "Only interpolation for SHVec3 and SHQuaternion is allowed.");
+
+    // Find the key frames that surround the current frame index
+    auto firstKeyFrame = keyframes.end();
+    auto nextKeyFrame = keyframes.end();
+    for (auto iter = keyframes.begin(); iter != keyframes.end(); ++iter)
+    {
+      const auto& KEYFRAME = *iter;
+
+      if (KEYFRAME.FrameIndex <= closestFrameIndex)
+      {
+        firstKeyFrame = iter;
+      }
+      else // KEYFRAME.FrameIndex > closestFrameIndex
+      {
+        nextKeyFrame = iter;
+        break;
+      }
+    }
+
+    // Edge Cases
+    if (firstKeyFrame == keyframes.end())
+    {
+      // No keyframes at all, means no changes
+      if (nextKeyFrame == keyframes.end())
+        return T();
+      // Out of range, clamp to the back
+      else
+        return nextKeyFrame->Data;
+    }
+    // At the back, so no keyframes will follow
+    else if (nextKeyFrame == keyframes.end())
+    {
+      return firstKeyFrame->Data;
+    }
+
+    // Get interpolated vector
+    const float PREV_FRAME_TIME = firstKeyFrame->FrameIndex * secsPerTick;
+    const float NEXT_FRAME_TIME = nextKeyFrame->FrameIndex * secsPerTick;
+    const float NORMALISED_TIME = (poseTime - PREV_FRAME_TIME) / (NEXT_FRAME_TIME - PREV_FRAME_TIME);
+
+    if constexpr (std::is_same_v<T, SHQuaternion>)
+    {
+      return SHQuaternion::Slerp(firstKeyFrame->Data, nextKeyFrame->Data, NORMALISED_TIME);
+    }
+    else if constexpr (std::is_same_v<T, SHVec3>)
+    {
+      return SHVec3::Lerp(firstKeyFrame->Data, nextKeyFrame->Data, NORMALISED_TIME);
+    }
+  }
+}

SHADE_Engine/src/Animation/SHRig.cpp

@@ -0,0 +1,149 @@
+/************************************************************************************//*!
+\file           SHRig.cpp
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Nov 20, 2022
+\brief          Contains the function definitions of the SHRig class.
+
+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.
+*//*************************************************************************************/
+// Pre-compiled Header
+#include "SHpch.h"
+// Primary Header
+#include "SHRig.h"
+// STL Includes
+#include <stack>
+// Project Headers
+#include "Assets/Asset Types/Models/SHRigAsset.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Constructors                                                                      */
+  /*-----------------------------------------------------------------------------------*/
+  SHRig::SHRig(const SHRigAsset& asset, SHResourceLibrary<SHRigNode>& nodeStore)
+  {
+    // Don't bother if empty
+    if (asset.root == nullptr)
+    {
+      SHLOG_ERROR("[SHRig] Attempted to load an invalid rig with no root.");
+      return;
+    }
+
+    // Do a recursive depth first traversal to populate the rig
+    rootNode = recurseCreateNode(asset, asset.root, nodeStore);
+    if (rootNode)
+    {
+      globalInverseMatrix = SHMatrix::Inverse(rootNode->TransformMatrix);
+    }
+  }
+
+  SHRig::SHRig(SHRig&& rhs)
+  : rootNode            { rhs.rootNode }
+  , nodeNames           { std::move(rhs.nodeNames) }
+  , nodesByName         { std::move(rhs.nodesByName) }
+  , nodes               { std::move(rhs.nodes) }
+  , nodeIndexMap        { std::move(rhs.nodeIndexMap) }
+  , globalInverseMatrix { std::move(rhs.globalInverseMatrix) }
+  {
+    rhs.rootNode = {};
+  }
+  SHRig::~SHRig()
+  {
+    // Unload all nodes
+    for (auto node : nodes)
+    {
+      if (node)
+        node.Free();
+    }
+    nodes.clear();
+  }
+
+  SHRig& SHRig::operator=(SHRig&& rhs)
+  {
+    rootNode            = rhs.rootNode;
+    nodeNames           = std::move(rhs.nodeNames);
+    nodesByName         = std::move(rhs.nodesByName);
+    nodes               = std::move(rhs.nodes);
+    nodeIndexMap        = std::move(rhs.nodeIndexMap);
+    globalInverseMatrix = std::move(rhs.globalInverseMatrix);
+
+    rhs.rootNode = {};
+
+    return *this;
+  }
+  /*-----------------------------------------------------------------------------------*/
+  /* Usage Functions                                                                   */
+  /*-----------------------------------------------------------------------------------*/
+  const std::string& SHRig::GetName(Handle<SHRigNode> node) const noexcept
+  {
+    static const std::string EMPTY_STRING = "";
+
+    if (nodeNames.contains(node))
+      return nodeNames.at(node);
+      
+    return EMPTY_STRING;
+  }
+
+  Handle<SHRigNode> SHRig::GetNode(const std::string& name) const noexcept
+  {
+    if (nodesByName.contains(name))
+      return nodesByName.at(name);
+
+    return {};
+  }
+  
+  int SHRig::GetNodeCount() const noexcept
+  {
+    return static_cast<int>(nodes.size());
+  }
+
+  int SHRig::GetNodeIndex(Handle<SHRigNode> node) const noexcept
+  {
+    if (nodeIndexMap.contains(node))
+    {
+      return nodeIndexMap.at(node);
+    }
+
+    return -1;
+  }
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Helper Functions                                                                   */
+  /*-----------------------------------------------------------------------------------*/
+  Handle<SHRigNode> SHRig::recurseCreateNode(const SHRigAsset& asset, const SHRigNodeAsset* sourceNode, SHResourceLibrary<SHRigNode>& nodeStore)
+  {
+    // Construct the node
+    auto newNode = nodeStore.Create();
+
+    // Fill the node with data
+    const auto& NODE_DATA = asset.nodeDataCollection.at(sourceNode->idRef);
+    newNode->OffsetMatrix = SHMatrix::Transpose(NODE_DATA.offset);
+    newNode->TransformMatrix = SHMatrix::Transpose(NODE_DATA.transform);
+
+    // Populate maps
+    if (!NODE_DATA.name.empty())
+    {
+      nodeNames.emplace(newNode, NODE_DATA.name);
+      nodesByName.emplace(NODE_DATA.name, newNode);
+    }
+    nodeIndexMap.emplace(newNode, sourceNode->idRef);
+    nodes.emplace_back(newNode);
+
+    // Fill child nodes
+    for (const auto& child : sourceNode->children)
+    {
+      // Ignore nulls
+      if (child == nullptr)
+        continue;
+
+      // Recursively create children
+      auto childNode = recurseCreateNode(asset, child, nodeStore); // Not sure why this works but it is required for
+      newNode->Children.emplace_back(childNode);        // the emplace_back operation to not crash
+    }
+
+    return newNode;
+  }
+}

SHADE_Engine/src/Animation/SHRig.h

@@ -0,0 +1,147 @@
+/************************************************************************************//*!
+\file           SHRig.h
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Nov 20, 2022
+\brief          Contains the definition of the SHRig struct and related types.
+
+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 <string>
+#include <vector>
+#include <unordered_map>
+
+// Project Includes
+#include "SH_API.h"
+#include "Math/SHMatrix.h"
+#include "Resource/SHHandle.h"
+#include "Resource/SHResourceLibrary.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Forward Declarations                                                              */
+  /*-----------------------------------------------------------------------------------*/
+  struct SHRigAsset;
+  struct SHRigNodeAsset;
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Type Definitions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+  /// <summary>
+  /// 
+  /// </summary>
+  struct SHRigNode
+  {
+    /// <summary>
+    /// Matrix that performs a transformation from local space to bone (node) space.
+    /// </summary>
+    SHMatrix OffsetMatrix;
+    /// <summary>
+    /// Matrix that performs a transformation from bone (node) space to local space.
+    /// </summary>
+    SHMatrix TransformMatrix;
+    /// <summary>
+    /// Child nodes of this node.
+    /// </summary>
+    std::vector<Handle<SHRigNode>> Children;
+  };
+
+  /// <summary>
+  /// Represents an animation skeletal rig for a model.
+  /// </summary>
+  class SH_API SHRig
+  { 
+    public:
+    /*---------------------------------------------------------------------------------*/
+    /* Constructors/Destructors                                                        */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Constructs a rig from a SHRigAsset.
+    /// </summary>
+    /// <param name="asset">
+    /// SHRigAsset to load.
+    /// </param>
+    /// <param name="nodeStore">
+    /// Reference to a ResourceLibrary to use to create the rig's nodes.
+    /// </param>
+    explicit SHRig(const SHRigAsset& asset, SHResourceLibrary<SHRigNode>& nodeStore);
+    /// <summary>
+    /// Move Constructor
+    /// </summary>
+    /// <param name="rhs>SHRig to move from.</param>
+    SHRig(SHRig&& rhs);
+    /// <summary>
+    /// Default destructor.
+    /// </summary>
+    ~SHRig();
+
+    /*---------------------------------------------------------------------------------*/
+    /* Operator Overloads                                                              */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Move assignment operator.
+    /// </summary>
+    /// <param name="rhs>SHRig to move from.</param>
+    /// <returns>Reference to this object.</returns>
+    SHRig& operator=(SHRig&& rhs);
+    
+    /*---------------------------------------------------------------------------------*/
+    /* Getter Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Retrieves the name of a node.
+    /// </summary>
+    /// <param name="node">Node to get the name of.</param>
+    /// <returns>
+    /// Name of the node. If it does not have a name or is invalid, an empty string will 
+    /// be provided.
+    /// </returns>
+    const std::string& GetName(Handle<SHRigNode> node) const noexcept;
+    /// <summary>
+    /// Retrieves the root node of the rig.
+    /// </summary>
+    /// <returns>Handle to the root node of the rig.</returns>
+    Handle<SHRigNode> GetRootNode() const noexcept { return rootNode; }
+    const SHMatrix& GetGlobalInverseMatrix() const noexcept { return globalInverseMatrix; }
+    /// <summary>
+    /// Retrieves a node via name.
+    /// </summary>
+    /// <param name="name">Name of the node to retrieve.</param>
+    /// <returns>
+    /// Node with the specified name. If it does not have a name or is invalid, an empty 
+    /// handle will be provided.
+    /// </returns>
+    Handle<SHRigNode> GetNode(const std::string& name) const noexcept;
+    /// <summary>
+    /// Returns the number of nodes in the rig. This matches the number of bone matrices
+    /// needed.
+    /// </summary>
+    int GetNodeCount() const noexcept;
+    /// <summary>
+    /// Retrieves the index in the node storage.
+    /// </summary>
+    int GetNodeIndex(Handle<SHRigNode> node) const noexcept;
+
+    private:
+    /*---------------------------------------------------------------------------------*/
+    /* Data Members                                                                    */
+    /*---------------------------------------------------------------------------------*/
+    Handle<SHRigNode> rootNode;
+    std::unordered_map<Handle<SHRigNode>, std::string> nodeNames;
+    std::unordered_map<std::string, Handle<SHRigNode>> nodesByName;
+    std::vector<Handle<SHRigNode>> nodes;
+    std::unordered_map<Handle<SHRigNode>, int> nodeIndexMap;
+    SHMatrix globalInverseMatrix;
+
+    /*---------------------------------------------------------------------------------*/
+    /* Helper Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    Handle<SHRigNode> recurseCreateNode(const SHRigAsset& asset, const SHRigNodeAsset* sourceNode, SHResourceLibrary<SHRigNode>& nodeStore);
+  };
+}

SHADE_Engine/src/Assets/Asset Types/Models/SHAnimationAsset.h

@@ -0,0 +1,88 @@
+/*************************************************************************//**
+ * \file    SHAnimationAsset.h
+ * \author  Loh Xiao Qi
+ * \date    October 2022
+ * \brief    
+ *
+ * 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 "Math/SHMath.h"
+#include "Assets/Asset Types/SHAssetData.h"
+
+#include <vector>
+
+
+namespace SHADE
+{
+	enum class SHAnimationBehaviour : uint8_t
+	{
+		DEFAULT = 0x0,
+		CONSTANT = 0x1,
+		LINEAR = 0x2,
+		REPEAT = 0x3
+	};
+
+	// Smallest data containers
+	struct PositionKey
+	{
+		float time;
+		SHVec3 value;
+	};
+	
+	struct RotationKey
+	{
+		float time;
+		SHVec4 value;
+	};
+	
+	struct ScaleKey
+	{
+		float time;
+		SHVec3 value;
+	};
+
+	// Headers for read/write
+	struct SHAnimNodeInfo
+	{
+		uint32_t charCount;
+		uint32_t posKeyCount;
+		uint32_t rotKeyCount;
+		uint32_t scaKeyCount;
+	};
+
+	struct SHAnimDataHeader
+	{
+		uint32_t charCount;
+		uint32_t animNodeCount;
+		std::vector<SHAnimNodeInfo> nodeHeaders;
+	};
+
+	// Main data containers
+	struct SHAnimData
+	{
+		std::string name;
+		SHAnimationBehaviour pre;
+		SHAnimationBehaviour post;
+
+		std::vector<PositionKey> positionKeys;
+		std::vector<RotationKey> rotationKeys;
+		std::vector<ScaleKey> scaleKeys;
+
+	};
+
+	struct SH_API SHAnimAsset : SHAssetData
+	{
+		std::string name;
+
+		double duration;
+		double ticksPerSecond;
+
+		std::vector<SHAnimData> nodeChannels;
+		//std::vector<aiMeshAnim*> meshChannels;
+		//std::vector<aiMeshMorphAnim*> morphMeshChannels;
+	};
+}

SHADE_Engine/src/Assets/Asset Types/Models/SHMeshAsset.h

@@ -0,0 +1,63 @@
+/******************************************************************************
+ * \file    SHMeshAsset.h
+ * \author  Loh Xiao Qi
+ * \date    19 November 2022
+ * \brief   
+ * 
+ * \copyright	Copyright (c) 2021 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 "Math/SHMath.h"
+#include "Assets/Asset Types/SHAssetData.h"
+#include "Math/Vector/SHVec4U.h"
+
+#include <vector>
+#include <string>
+
+namespace SHADE
+{
+  constexpr int BONE_INDEX_ALIGHTMENT = 4;
+
+	struct SHMeshDataHeader
+	{
+		uint32_t vertexCount;
+		uint32_t indexCount;
+		uint32_t charCount;
+		uint32_t boneCount;
+	};
+
+	struct MeshBoneInfo
+	{
+		uint32_t charCount;
+		uint32_t weightCount; // Size should be same as boneCount
+	};
+
+	struct BoneWeight
+	{
+		uint32_t index;
+		float weight;
+	};
+
+	struct MeshBone
+	{
+		std::string name;
+		SHMatrix offset;
+		std::vector<BoneWeight> weights;
+	};
+
+	struct SH_API SHMeshAsset : SHAssetData
+	{
+		std::string name;
+		std::vector<SHVec3>   VertexPositions;
+		std::vector<SHVec3>   VertexTangents;
+		std::vector<SHVec3>   VertexNormals;
+		std::vector<SHVec2>   VertexTexCoords;
+		std::vector<uint32_t> Indices;
+		std::vector<SHVec4U>  VertexBoneIndices;
+		std::vector<SHVec4>   VertexBoneWeights;
+    uint32_t BoneCount;
+	};
+}

SHADE_Engine/src/Assets/Asset Types/Models/SHModelAsset.h

@@ -13,36 +13,28 @@
 #pragma once
 
 #include <vector>
-#include "Math/SHMath.h"
-#include "SHAssetData.h"
+
+#include "Assets/Asset Types/Models/SHAnimationAsset.h"
+#include "Assets/Asset Types/Models/SHMeshAsset.h"
+#include "Assets/Asset Types/Models/SHRigAsset.h"
 
 namespace SHADE
 {
-  struct SHMeshAssetHeader
-  {
-    uint32_t vertexCount;
-    uint32_t indexCount;
-    std::string name;
-  };
-
   struct SHModelAssetHeader
   {
     size_t meshCount;
-  };
-
-  struct SH_API SHMeshData : SHAssetData
-  {
-    SHMeshAssetHeader header;
-    std::vector<SHVec3> VertexPositions;
-    std::vector<SHVec3> VertexTangents;
-    std::vector<SHVec3> VertexNormals;
-    std::vector<SHVec2> VertexTexCoords;
-    std::vector<uint32_t> Indices;
+		size_t animCount;
   };
 
   struct SH_API SHModelAsset : SHAssetData
   {
     SHModelAssetHeader header;
-    std::vector<SHMeshData*> subMeshes;
+    SHRigAsset rig;
+
+    std::vector<SHMeshDataHeader> meshHeaders;
+    std::vector<SHAnimDataHeader> animHeaders;
+
+    std::vector<SHMeshAsset*> meshes;
+    std::vector<SHAnimAsset*> anims;
   };
 }

SHADE_Engine/src/Assets/Asset Types/Models/SHRigAsset.cpp

@@ -0,0 +1,13 @@
+#include "SHpch.h"
+#include "SHRigAsset.h"
+
+#include <queue>
+
+namespace SHADE
+{
+  SHRigAsset::~SHRigAsset()
+  {
+    if (root != nullptr)
+    delete[] root;
+  }
+}

SHADE_Engine/src/Assets/Asset Types/Models/SHRigAsset.h

@@ -0,0 +1,47 @@
+/******************************************************************************
+ * \file    SHRigAsset.h
+ * \author  Loh Xiao Qi
+ * \date    19 November 2022
+ * \brief   
+ * 
+ * \copyright	Copyright (c) 2021 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 "Math/SHMath.h"
+#include "Assets/Asset Types/SHAssetData.h"
+
+#include <map>
+
+namespace SHADE
+{
+	struct SHRigDataHeader
+	{
+		uint32_t nodeCount;
+		std::vector<uint32_t> charCounts;
+	};
+
+	struct SHRigNodeData
+	{
+		std::string name;
+		SHMatrix transform;
+    SHMatrix offset;
+	};
+
+	struct SHRigNodeAsset
+	{
+		uint32_t idRef;
+		std::vector<SHRigNodeAsset*> children;
+	};
+
+	struct SH_API SHRigAsset : SHAssetData
+	{
+    ~SHRigAsset();
+
+    SHRigDataHeader header;
+		std::vector<SHRigNodeData> nodeDataCollection;
+		SHRigNodeAsset* root;
+	};
+}

SHADE_Engine/src/Assets/Asset Types/SHAnimationAsset.h

@@ -1,30 +0,0 @@
-/*************************************************************************//**
- * \file    SHAnimationAsset.h
- * \author  Loh Xiao Qi
- * \date    October 2022
- * \brief    
- *
- * 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 <vector>
-#include <assimp/anim.h>
-#include "SHAssetData.h"
-
-namespace SHADE
-{
-	struct SH_API SHAnimationAsset : SHAssetData
-	{
-		std::string name;
-
-		std::vector<aiNodeAnim*> nodeChannels;
-		std::vector<aiMeshAnim*> meshChannels;
-		std::vector<aiMeshMorphAnim*> morphMeshChannels;
-
-		double duration;
-		double ticksPerSecond;
-	};
-}

SHADE_Engine/src/Assets/Asset Types/SHAssetIncludes.h

@@ -1,4 +1,4 @@
 #pragma once
 
-#include "SHModelAsset.h"
+#include "Models/SHModelAsset.h"
 #include "SHTextureAsset.h"

SHADE_Engine/src/Assets/Libraries/Loaders/SHModelLoader.cpp

@@ -13,73 +13,321 @@
 #include "SHpch.h"
 #include "SHModelLoader.h"
 #include <fstream>
+#include <queue>
 
 namespace SHADE
 {
-  void SHModelLoader::ReadHeader(std::ifstream& file, SHMeshLoaderHeader& header) noexcept
+  void SHModelLoader::ReadHeaders(FileReference file, SHModelAsset& asset)
   {
     file.read(
-      reinterpret_cast<char*>(&header),
-      sizeof(SHMeshLoaderHeader)
+      reinterpret_cast<char*>(&asset.header),
+      sizeof(asset.header)
+    );
+    
+    if (asset.header.meshCount > 0)
+    {
+      asset.meshHeaders.resize(asset.header.meshCount);
+      file.read(
+        reinterpret_cast<char*>(asset.meshHeaders.data()),
+        asset.header.meshCount * sizeof(SHMeshDataHeader)
+      );
+    }
+
+    if (asset.header.animCount > 0)
+    {
+      asset.animHeaders.resize(asset.header.animCount);
+      for (auto i {0}; i < asset.header.animCount; ++i)
+      {
+        auto& animHeader = asset.animHeaders[i];
+        file.read(
+          reinterpret_cast<char*>(&animHeader.charCount),
+          sizeof(uint32_t)
+        );
+        
+        file.read(
+          reinterpret_cast<char*>(&animHeader.animNodeCount),
+          sizeof(uint32_t)
+        );
+
+        animHeader.nodeHeaders.resize(animHeader.animNodeCount);
+        for (auto j {0}; j < animHeader.animNodeCount; ++j)
+        {
+          auto& nodeHeader = animHeader.nodeHeaders[j];
+                    
+          file.read(
+            reinterpret_cast<char*>(&nodeHeader),
+            sizeof(SHAnimNodeInfo)
+          );
+        }
+      }
+    }
+  }
+
+  void SHModelLoader::ReadData(FileReference file, SHModelAsset& asset)
+  {
+    ReadMeshData(file, asset.meshHeaders, asset.meshes);
+    ReadAnimData(file, asset.animHeaders, asset.anims);
+
+    // Not eof yet, animation exists
+    if (file.peek() != EOF)
+    {
+      ReadRigHeader(file, asset.rig.header);
+      ReadRigData(file, asset.rig.header, asset.rig.nodeDataCollection);
+      ReadRigTree(file, asset.rig.header, asset.rig.root);
+    }
+  }
+
+  void SHModelLoader::ReadAnimNode(FileReference file, SHAnimNodeInfo const& info, SHAnimData& data)
+  {
+    data.name.resize(info.charCount);
+    file.read(
+      data.name.data(),
+      info.charCount
+    );
+
+    file.read(
+      reinterpret_cast<char*>(&data.pre),
+      sizeof(SHAnimationBehaviour)
+    );
+
+    file.read(
+      reinterpret_cast<char*>(&data.post),
+      sizeof(SHAnimationBehaviour)
+    );
+
+    uint32_t keySize {0};
+    file.read(
+      reinterpret_cast<char*>(&keySize),
+      sizeof(uint32_t)
+    );
+
+    data.positionKeys.resize(keySize);
+    data.rotationKeys.resize(keySize);
+    data.scaleKeys.resize(keySize);
+
+    file.read(
+      reinterpret_cast<char*>(data.positionKeys.data()),
+      sizeof(PositionKey) * keySize
+    );
+
+    file.read(
+      reinterpret_cast<char*>(data.rotationKeys.data()),
+      sizeof(RotationKey) * keySize
+    );
+
+    file.read(
+      reinterpret_cast<char*>(data.scaleKeys.data()),
+      sizeof(ScaleKey) * keySize
     );
   }
 
-  void SHModelLoader::ReadData(std::ifstream& file, SHMeshLoaderHeader const& header, SHMeshData& data) noexcept
+  void SHModelLoader::ReadRigHeader(FileReference file, SHRigDataHeader& header)
   {
-    auto const vertexVec3Byte{ sizeof(SHVec3) * header.vertexCount };
-    auto const vertexVec2Byte{ sizeof(SHVec2) * header.vertexCount };
+    file.read(
+      reinterpret_cast<char*>(&header.nodeCount),
+      sizeof(uint32_t)
+    );
 
-    data.VertexPositions.resize(header.vertexCount);
-    data.VertexTangents.resize(header.vertexCount);
-    data.VertexNormals.resize(header.vertexCount);
-    data.VertexTexCoords.resize(header.vertexCount);
-    data.Indices.resize(header.indexCount);
-    data.header.name.resize(header.charCount);
-
-    file.read(data.header.name.data(), header.charCount);
-    file.read(reinterpret_cast<char*>(data.VertexPositions.data()), vertexVec3Byte);
-    file.read(reinterpret_cast<char*>(data.VertexTangents.data()), vertexVec3Byte);
-    file.read(reinterpret_cast<char*>(data.VertexNormals.data()), vertexVec3Byte);
-    file.read(reinterpret_cast<char*>(data.VertexTexCoords.data()), vertexVec2Byte);
-    file.read(reinterpret_cast<char*>(data.Indices.data()), sizeof(uint32_t) * header.indexCount);
-
-    data.header.vertexCount = header.vertexCount;
-    data.header.indexCount = header.indexCount;
+    header.charCounts.resize(header.nodeCount);
+    file.read(
+    reinterpret_cast<char*>(header.charCounts.data()),
+      sizeof(uint32_t) * header.nodeCount
+    );
   }
 
-  void SHModelLoader::LoadSHMesh(AssetPath path, SHModelAsset& model) noexcept
+  void SHModelLoader::ReadRigData(FileReference file, SHRigDataHeader const& header, std::vector<SHRigNodeData>& data)
   {
+    data.resize(header.nodeCount);
+
+    for (auto i {0}; i < header.nodeCount; ++i)
+    {
+      data[i].name.resize(header.charCounts[i]);
+      file.read(
+        data[i].name.data(),
+        header.charCounts[i]
+      );
+
+      file.read(
+        reinterpret_cast<char*>(&data[i].transform),
+        sizeof(SHMatrix)
+      );
+
+      file.read(
+        reinterpret_cast<char*>(&data[i].offset),
+        sizeof(SHMatrix)
+      );
+    }
+  }
+
+  void SHModelLoader::ReadRigTree(FileReference file, SHRigDataHeader const& header, SHRigNodeAsset*& root)
+  {
+    // Read All nodes into one contiguous data block
+    struct NodeTemp
+    {
+      uint32_t id, numChild;
+    };
+
+    NodeTemp* dst = new NodeTemp[header.nodeCount];
+
+    file.read(
+      reinterpret_cast<char*>(dst),
+      sizeof(NodeTemp) * header.nodeCount
+    );
+
+    // Build and populate tree
+    SHRigNodeAsset* nodePool = new SHRigNodeAsset[header.nodeCount];
+    root = nodePool;
+
+    std::queue<std::pair<SHRigNodeAsset*, NodeTemp*>> nodeQueue;
+    nodeQueue.emplace(std::make_pair(nodePool, dst));
+
+    SHRigNodeAsset* depthPtr = nodePool + 1;
+    NodeTemp* depthTempPtr = dst + 1;
+
+    while(!nodeQueue.empty())
+    {
+      auto currPair = nodeQueue.front();
+      nodeQueue.pop();
+      auto currNode = currPair.first;
+      auto currTemp = currPair.second;
+
+      currNode->idRef = currTemp->id;
+
+      for (auto i{0}; i < currTemp->numChild; ++i)
+      {
+        currNode->children.push_back(depthPtr);
+        nodeQueue.emplace(depthPtr++, depthTempPtr++);
+      }
+    }
+
+    delete[] dst;
+  }
+
+  void SHModelLoader::ReadMeshData(FileReference file, std::vector<SHMeshDataHeader> const& headers,
+    std::vector<SHMeshAsset*>& meshes)
+  {
+    meshes.resize(headers.size());
+    for (auto i {0}; i < headers.size(); ++i)
+    {
+      auto const& header = headers[i];
+      auto& data = *new SHMeshAsset;
+
+      auto const vertexVec3Byte{ sizeof(SHVec3) * header.vertexCount };
+      auto const vertexVec2Byte{ sizeof(SHVec2) * header.vertexCount };
+
+      data.name.resize(header.charCount);
+      data.VertexPositions.resize(header.vertexCount);
+      data.VertexTangents.resize(header.vertexCount);
+      data.VertexNormals.resize(header.vertexCount);
+      data.VertexTexCoords.resize(header.vertexCount);
+      data.Indices.resize(header.indexCount);
+      data.BoneCount = header.boneCount;
+
+      file.read(data.name.data(), header.charCount);
+      file.read(reinterpret_cast<char*>(data.VertexPositions.data()), vertexVec3Byte);
+      file.read(reinterpret_cast<char*>(data.VertexTangents.data()), vertexVec3Byte);
+      file.read(reinterpret_cast<char*>(data.VertexNormals.data()), vertexVec3Byte);
+      file.read(reinterpret_cast<char*>(data.VertexTexCoords.data()), vertexVec2Byte);
+      file.read(reinterpret_cast<char*>(data.Indices.data()), sizeof(uint32_t) * header.indexCount);
+
+      if (header.boneCount)
+      {
+        std::vector<MeshBoneInfo> boneInfos(header.boneCount);
+        std::vector<MeshBone> bones(header.boneCount);
+
+        file.read(reinterpret_cast<char*>(boneInfos.data()), sizeof(MeshBoneInfo) * header.boneCount);
+
+        for (auto i{ 0 }; i < header.boneCount; ++i)
+        {
+          auto& bone = bones[i];
+          auto const& info = boneInfos[i];
+
+          bone.name.resize(info.charCount);
+          file.read(bone.name.data(), info.charCount);
+          file.read(reinterpret_cast<char*>(&bone.offset), sizeof(SHMatrix));
+          
+          bone.weights.resize(info.weightCount);
+          file.read(reinterpret_cast<char*>(bone.weights.data()), sizeof(BoneWeight) * info.weightCount);
+        }
+
+        data.VertexBoneIndices.resize(header.vertexCount);
+        data.VertexBoneWeights.resize(header.vertexCount);
+
+        for (uint32_t boneIndex{0}; boneIndex < bones.size(); ++boneIndex)
+        {
+          auto const& bone = bones[boneIndex];
+          for (auto const& weight : bone.weights)
+          {
+            auto& boneIndices = data.VertexBoneIndices[weight.index];
+            auto& boneWeight = data.VertexBoneWeights[weight.index];
+
+            for (auto j{0}; j < BONE_INDEX_ALIGHTMENT; ++j)
+            {
+              if (boneWeight[j] == 0.f)
+              {
+                boneIndices[j] = boneIndex;
+                boneWeight[j] = weight.weight;
+                break;
+              }
+            }
+          }
+        }
+      }
+
+      meshes[i] = &data;
+    }
+  }
+
+  void SHModelLoader::ReadAnimData(FileReference file, std::vector<SHAnimDataHeader> const& headers,
+    std::vector<SHAnimAsset*>& anims)
+  {
+    anims.resize(headers.size());
+    for (auto i {0}; i < headers.size(); ++i)
+    {
+      auto const& header = headers[i];
+      auto& animAsset = *new SHAnimAsset;
+
+      animAsset.name.resize(header.charCount);
+      file.read(
+        animAsset.name.data(),
+        header.charCount
+      );
+
+      file.read(
+        reinterpret_cast<char*>(&animAsset.duration),
+        sizeof(double)
+      );
+
+      file.read(
+        reinterpret_cast<char*>(&animAsset.ticksPerSecond),
+        sizeof(double)
+      );
+
+      animAsset.nodeChannels.resize(header.animNodeCount);
+      for (auto i {0}; i < header.animNodeCount; ++i)
+      {
+        ReadAnimNode(file, header.nodeHeaders[i], animAsset.nodeChannels[i]);
+      }
+
+      anims[i] = &animAsset;
+    }
+  }
+
+  SHAssetData* SHModelLoader::Load(AssetPath path)
+	{
+    auto result = new SHModelAsset();
+    
     std::ifstream file{ path.string(), std::ios::in | std::ios::binary };
     if (!file.is_open())
     {
       SHLOG_ERROR("[Model Loader] Unable to open SHModel File: {}", path.string());
-      return;
+      return nullptr;
     }
 
-    file.seekg(0);
+    ReadHeaders(file, *result);
+    ReadData(file, *result);
 
-    file.read(
-      reinterpret_cast<char*>(&model.header),
-      sizeof(SHModelAssetHeader)
-    );
-
-    std::vector<SHMeshLoaderHeader> headers(model.header.meshCount);
-    model.subMeshes.resize(model.header.meshCount);
-
-    for (auto i{ 0 }; i < model.header.meshCount; ++i)
-    {
-      model.subMeshes[i] = new SHMeshData();
-      ReadHeader(file, headers[i]);
-      ReadData(file, headers[i], *model.subMeshes[i]);
-    }
     file.close();
-	}
-
-	SHAssetData* SHModelLoader::Load(AssetPath path)
-	{
-    auto result = new SHModelAsset();
-
-    LoadSHMesh(path, *result);
 
     return result;
 	}

SHADE_Engine/src/Assets/Libraries/Loaders/SHModelLoader.h

@@ -10,7 +10,7 @@
  * of DigiPen Institute of Technology is prohibited.
  *****************************************************************************/
 #pragma once
-#include "Assets/Asset Types/SHModelAsset.h"
+#include "Assets/Asset Types/Models/SHModelAsset.h"
 #include "SHAssetLoader.h"
 #include <fstream>
 
@@ -18,19 +18,20 @@ namespace SHADE
 {
   class SHModelLoader : public SHAssetLoader
 	{
-    struct SHMeshLoaderHeader
-    {
-      uint32_t vertexCount;
-      uint32_t indexCount;
-      uint32_t charCount;
-    };
+    using FileReference = std::ifstream&;
+    
+    void ReadAnimNode(FileReference file, SHAnimNodeInfo const& info, SHAnimData& data);
 
+    void ReadRigHeader(FileReference file, SHRigDataHeader& header);
+    void ReadRigData(FileReference file, SHRigDataHeader const& header, std::vector<SHRigNodeData>& data);
+    void ReadRigTree(FileReference file, SHRigDataHeader const& header, SHRigNodeAsset*& root);
+    
+    void ReadMeshData(FileReference file, std::vector<SHMeshDataHeader> const& headers, std::vector<SHMeshAsset*>& meshes);
+    void ReadAnimData(FileReference file, std::vector<SHAnimDataHeader> const& headers, std::vector<SHAnimAsset*>& anims);
 
-    void ReadHeader(std::ifstream& file, SHMeshLoaderHeader& header) noexcept;
-    void ReadData(std::ifstream& file, SHMeshLoaderHeader const& header, SHMeshData& data) noexcept;
-
+    void ReadHeaders(FileReference file, SHModelAsset& asset);
+    void ReadData(FileReference file, SHModelAsset& asset);
 	public:
-		void LoadSHMesh(AssetPath path, SHModelAsset& model) noexcept;
 		SHAssetData* Load(AssetPath path) override;
     void Write(SHAssetData const* data, AssetPath path) override;
 	};

SHADE_Engine/src/Assets/SHAssetManager.cpp

@@ -27,6 +27,7 @@
 #include "Libraries/Compilers/SHShaderSourceCompiler.h"
 
 #include "Filesystem/SHFileSystem.h"
+#include <rttr/registration.h>
 
 namespace SHADE
 {
@@ -492,8 +493,8 @@ namespace SHADE
 	****************************************************************************/
 	void SHAssetManager::Load() noexcept
 	{
-    BuildAssetCollection();
 		InitLoaders();
+    BuildAssetCollection();
     //CompileAll();
 		//LoadAllData();
 	}
@@ -549,7 +550,7 @@ namespace SHADE
         {
           assetData.emplace(
             parent.subAssets[i]->id,
-            parentModel->subMeshes[i]
+            parentModel->meshes[i]
           );
         }
       }
@@ -607,10 +608,10 @@ namespace SHADE
 
       SHModelAsset* const data = reinterpret_cast<SHModelAsset*>(LoadData(newAsset));
       assetData.emplace(newAsset.id, data);
-      for(auto const& subMesh : data->subMeshes)
+      for(auto const& subMesh : data->meshes)
       {
         SHAsset subAsset{
-          .name = subMesh->header.name,
+          .name = subMesh->name,
           .id = GenerateAssetID(AssetType::MESH),
           .type = AssetType::MESH,
           .isSubAsset = true,
@@ -733,3 +734,25 @@ namespace SHADE
     }
   }
 }
+
+namespace rttr
+{
+  using namespace SHADE;
+  RTTR_REGISTRATION
+  {
+    registration::enumeration<AssetType>("Asset Type")
+    (
+      value("Invalid", AssetType::INVALID),
+      value("Shader", AssetType::SHADER),
+      value("Shader [Built-In]", AssetType::SHADER_BUILT_IN),
+      value("Texture", AssetType::TEXTURE),
+      value("Model", AssetType::MODEL),
+      value("Scene", AssetType::SCENE),
+      value("Prefab", AssetType::PREFAB),
+      value("Material", AssetType::MATERIAL),
+      value("Mesh", AssetType::MESH),
+      value("Script", AssetType::SCRIPT),
+      value("Font", AssetType::FONT)
+    );
+  }
+}

SHADE_Engine/src/Assets/SHAssetManager.hpp

@@ -6,6 +6,11 @@ namespace SHADE
 	template<typename T>
 	std::enable_if_t<std::is_base_of_v<SHAssetData, T>, T* const> SHAssetManager::GetData(AssetID id) noexcept
 	{
+    if (id == 0)
+    {
+      return nullptr;
+    }
+
 		if (!assetData.contains(id))
 		{
 			for (auto const& asset : std::ranges::views::values(assetCollection))

SHADE_Engine/src/AudioSystem/SHAudioSystem.cpp

@@ -125,14 +125,29 @@ namespace SHADE
       SHTransformComponent* listenerTransform = SHComponentManager::GetComponent_s<SHTransformComponent>(listener.GetEID());
       if (listenerTransform)
       {
-        listener.SetPos(listenerTransform->GetLocalPosition());
-        listener.SetForward({ (listenerTransform->GetLocalScale()[0] > 0.f) ? 1.f : -1.f, 0.f, 0.f });
+        listener.SetPos(listenerTransform->GetWorldPosition()); // TODO: Clean up listener
+        listener.SetForward({ (listenerTransform->GetLocalScale()[0] > 0.f) ? 1.f : -1.f, 0.f, 0.f }); //TODO: USE CORRECT FORWARD
         FMOD_VECTOR pos = { listener.pos[0] ,listener.pos[1] ,0.f };
         FMOD_VECTOR forward = { listener.forward[0] ,listener.forward[1] ,listener.forward[2] };
         FMOD_VECTOR up = { listener.up[0] ,listener.up[1] ,listener.up[2] };
         fmodSystem->set3DListenerAttributes(0, &pos, nullptr, &forward, &up);
       }
     }
+    
+    auto [begin, end] = audioClipLibrary.GetDenseAccess();
+    for(auto it = begin; it != end; ++it)
+    {
+      if(it->instance && (it->transformRef != MAX_EID))
+      {
+        if(SHTransformComponent* transformComponent = SHComponentManager::GetComponent_s<SHTransformComponent>(it->transformRef))
+        {
+          FMOD_3D_ATTRIBUTES attribs{}; //TODO: Set other attribs
+          auto pos = transformComponent->GetWorldPosition();
+          attribs.position = {pos.x, pos.y, pos.z};
+          it->instance->set3DAttributes(&attribs);
+        }
+      }
+    }
   }
 
   SHAudioSystem::AudioRoutine::AudioRoutine()
@@ -325,27 +340,83 @@ namespace SHADE
     return std::nullopt;
   }
 
-  AudioClip* SHAudioSystem::CreateAudioClip(const char* path)
+  Handle<AudioClip> SHAudioSystem::CreateAudioClip(const char* path)
   {
-    AudioClipID newID{};
-    AudioClip* clip = nullptr;
-    auto it = eventMap.find(path);
-    if (it != eventMap.end())
+    Handle<AudioClip> audioClipHandle{};
+
+    if(auto it = eventMap.find(path); it != eventMap.end())
     {
-      FMOD::Studio::EventInstance* event = nullptr;
-      it->second->createInstance(&event);
-      if (event)
-      {
-        //event->start();
-        newID = clipID;
-        clipID++;
-        eventInstances.emplace(newID, AudioClip(newID, event));
-        clip = &eventInstances[newID];
-      }
+      audioClipHandle = audioClipLibrary.Create();
+      it->second->createInstance(&audioClipHandle->instance);
     }
-    return clip;
+    
+    return audioClipHandle;
   }
 
+  void SHAudioSystem::AddAudioClipToBGMChannelGroup(Handle<AudioClip> handle)
+  {
+    if(!handle->instance)
+      return;
+    FMOD::ChannelGroup* channelGroup;
+    handle->instance->getChannelGroup(&channelGroup);
+
+    if(!channelGroup)
+    {
+      SHLOG_ERROR("Event instance has no channel group")
+      return;
+    }
+    bgmChannelGroup->addGroup(channelGroup);
+  }
+
+  void SHAudioSystem::AddAudioClipToSFXChannelGroup(Handle<AudioClip> handle)
+  {
+    if (!handle->instance)
+      return;
+    FMOD::ChannelGroup* channelGroup;
+    handle->instance->getChannelGroup(&channelGroup);
+
+    if (!channelGroup)
+    {
+      SHLOG_ERROR("Event instance has no channel group")
+        return;
+    }
+    sfxChannelGroup->addGroup(channelGroup);
+  }
+
+  void SHAudioSystem::AttachAudioClipToObject(Handle<AudioClip> handle, EntityID eid)
+  {
+    if (auto transform = SHComponentManager::GetComponent_s<SHTransformComponent>(eid))
+    {
+      handle->transformRef = eid;
+    }
+  }
+
+  void SHAudioSystem::DetachAudioClipFromObject(Handle<AudioClip> handle)
+  {
+    handle->transformRef = MAX_EID;
+  }
+
+  //AudioClip* SHAudioSystem::CreateAudioClip(const char* path)
+  //{
+  //  AudioClipID newID{};
+  //  AudioClip* clip = nullptr;
+  //  auto it = eventMap.find(path);
+  //  if (it != eventMap.end())
+  //  {
+  //    FMOD::Studio::EventInstance* event = nullptr;
+  //    it->second->createInstance(&event);
+  //    if (event)
+  //    {
+  //      //event->start();
+  //      newID = clipID;
+  //      clipID++;
+  //      eventInstances.emplace(newID, AudioClip(newID, event));
+  //      clip = &eventInstances[newID];
+  //    }
+  //  }
+  //  return clip;
+  //}
+
   //std::vector<const char*> SHAudioSystem::GetAllEvents()
   //{
   //  int count{};
@@ -489,41 +560,39 @@ namespace SHADE
       }
   }
 
-  AudioClip::AudioClip(AudioClipID clipID, FMOD::Studio::EventInstance* inst)
-    :instance(inst), id(clipID)
+  void AudioClip::Play()
   {
-  }
-
-  AudioClip::~AudioClip()
-  {
-  }
-
-  void AudioClip::Play(bool isSfx)
-  {
-    if (!instance)
+    if(!instance)
       return;
     instance->start();
-    auto audioSystem = SHSystemManager::GetSystem<SHADE::SHAudioSystem>();
-    instance->setVolume(audioSystem->GetMasterVolume() * (isSfx ? audioSystem->GetSfxVolume() : audioSystem->GetBgmVolume()));
   }
 
-  void AudioClip::Play(SHVec3 position, bool isSfx)
-  {
-    if (!instance)
-      return;
-    instance->start();
-    FMOD_3D_ATTRIBUTES attributes{ {} };
-    attributes.forward.z = 1.0f;
-    attributes.up.y = 1.0f;
+  //void AudioClip::Play(bool isSfx)
+  //{
+  //  if (!instance)
+  //    return;
+  //  instance->start();
+  //  auto audioSystem = SHSystemManager::GetSystem<SHADE::SHAudioSystem>();
+  //  instance->setVolume(audioSystem->GetMasterVolume() * (isSfx ? audioSystem->GetSfxVolume() : audioSystem->GetBgmVolume()));
+  //}
 
-    auto audioSystem = SHSystemManager::GetSystem<SHADE::SHAudioSystem>();
-    SHVec3 listenerPos = audioSystem->GetListenerPosition();
-    attributes.position.x = position[0];
-    attributes.position.y = position[1];
-    attributes.position.z = listenerPos[2];
-    instance->set3DAttributes(&attributes);
-    instance->setVolume(audioSystem->GetMasterVolume() * (isSfx ? audioSystem->GetSfxVolume() : audioSystem->GetBgmVolume()));
-  }
+  //void AudioClip::Play(SHVec3 position, bool isSfx)
+  //{
+  //  if (!instance)
+  //    return;
+  //  instance->start();
+  //  FMOD_3D_ATTRIBUTES attributes{ {} };
+  //  attributes.forward.z = 1.0f;
+  //  attributes.up.y = 1.0f;
+
+  //  auto audioSystem = SHSystemManager::GetSystem<SHADE::SHAudioSystem>();
+  //  SHVec3 listenerPos = audioSystem->GetListenerPosition();
+  //  attributes.position.x = position[0];
+  //  attributes.position.y = position[1];
+  //  attributes.position.z = listenerPos[2];
+  //  instance->set3DAttributes(&attributes);
+  //  instance->setVolume(audioSystem->GetMasterVolume() * (isSfx ? audioSystem->GetSfxVolume() : audioSystem->GetBgmVolume()));
+  //}
 
   void AudioClip::Stop(bool fadeOut)
   {
@@ -557,12 +626,12 @@ namespace SHADE
     instance->setParameterByName(paramName, value);
   }
 
-  void AudioClip::SetParameterLabel(const char* paramName, const char* label)
-  {
-    if (!instance)
-      return;
-    instance->setParameterByNameWithLabel(paramName, label);
-  }
+  //void AudioClip::SetParameterLabel(const char* paramName, const char* label)
+  //{
+  //  if (!instance)
+  //    return;
+  //  instance->setParameterByNameWithLabel(paramName, label);
+  //}
 
   float AudioClip::GetParameterValue(const char* paramName)
   {

SHADE_Engine/src/AudioSystem/SHAudioSystem.h

@@ -13,6 +13,7 @@
 #include "Events/SHEvent.h"
 
 #include "SH_API.h"
+#include <Resource/SHResourceLibrary.h>
 #define AUDIO_SYS_MAX_CHANNELS 1024
 
 namespace SHADE
@@ -22,27 +23,22 @@ namespace SHADE
 
   class SHAudioListenerComponent;
 
-  typedef uint64_t AudioClipID;
-
-  class AudioClip
+  class SH_API AudioClip
   {
   public:
-    AudioClip() = default;
-    AudioClip(AudioClipID clipID, FMOD::Studio::EventInstance* inst);
-    ~AudioClip();
-    void Play(bool isSfx = true);
-    void Play(SHVec3 position, bool isSfx = true);
+    void Play();
+    //void Play(SHVec3 position);
     void Stop(bool fadeOut = true);
 
     void SetPause(bool pause);
     bool IsPaused();
     void SetParameter(const char* paramName, float value);
-    void SetParameterLabel(const char* paramName, const char* label);
+    //void SetParameterLabel(const char* paramName, const char* label);
     float GetParameterValue(const char* paramName);
     friend class SHAudioSystem;
   private:
-    FMOD::Studio::EventInstance* instance;
-    AudioClipID id;
+    FMOD::Studio::EventInstance* instance = nullptr;
+    EntityID transformRef = MAX_EID;
   };
 
   class SH_API SHAudioSystem : public SHSystem
@@ -62,7 +58,7 @@ namespace SHADE
     void Exit();
 
     int GetAvailableChannelIndex();
-    /*std::vector<SHSound>::size_type CreateSound(const char* filepath, bool loop = false);*/
+
     void PlaySFX(EntityID id, EntityID eid, const bool& loop, const bool& spatial, float min = 5.0f, float max = 1000.0f);
     void PlayBGM(EntityID id, EntityID eid, const bool& loop, const bool& spatial, float min = 5.0f, float max = 1000.0f);
     void PlayEventOnce(const char* path, bool isSFX = true, EntityID eid = MAX_EID, bool spatial = false);
@@ -71,9 +67,15 @@ namespace SHADE
     void StopAllSounds();
 
     std::optional<FMOD_GUID> GetEventGUID(const char* path);
-    AudioClip* CreateAudioClip(const char* path);
-    //std::vector<const char*> GetAllEvents();
+    //AudioClip* CreateAudioClip(const char* path);
+    //AUDIO CLIP
+    Handle<AudioClip> CreateAudioClip(const char* path);
+    void AddAudioClipToBGMChannelGroup(Handle<AudioClip> handle);
+    void AddAudioClipToSFXChannelGroup(Handle<AudioClip> handle);
 
+    void AttachAudioClipToObject(Handle<AudioClip> handle, EntityID eid);
+    void DetachAudioClipFromObject(Handle<AudioClip> handle);
+    ///
     float GetBgmVolume();
     float GetSfxVolume();
     float GetMasterVolume();
@@ -84,6 +86,7 @@ namespace SHADE
     bool GetPaused() const;
     SHVec3 GetListenerPosition();
     void LoadBank(const char* path);
+
   private:
     FMOD::Studio::System* fmodStudioSystem;
     FMOD::System* fmodSystem;
@@ -95,7 +98,9 @@ namespace SHADE
     //std::unordered_map<ResourceID, SHBank> bankMap;
     std::unordered_map<std::string, SHBank> bankMap;
     std::unordered_map<std::string, FMOD::Studio::EventDescription*> eventMap;
-    std::unordered_map<AudioClipID, AudioClip> eventInstances;
+    //std::unordered_map<AudioClipID, AudioClip> eventInstances;
+    SHResourceLibrary<AudioClip> audioClipLibrary{};
+
     FMOD::ChannelGroup* bgmChannelGroup, * sfxChannelGroup, * masterGroup;
     FMOD::Channel* audioChannels[AUDIO_SYS_MAX_CHANNELS];
     FMOD_RESULT result;
@@ -105,7 +110,6 @@ namespace SHADE
     SHBank masterBank, stringsBank, musicBank, sfxBank; //To do: change to map of banks loaded by resource manager
     
     std::vector<SHAudioListenerComponent>* denseListener;
-    AudioClipID clipID = 0;
 
     SHEventHandle onPlay(SHEventPtr onStopEvent);
     SHEventHandle onStop(SHEventPtr onStopEvent);

SHADE_Engine/src/Camera/SHCameraSystem.cpp

@@ -314,7 +314,7 @@ namespace SHADE
         camera.orthoProjMatrix(3, 3) = 1.0f;
 
         //camera.perspProjMatrix = SHMatrix::OrthographicLH(9.0f, 9.0f, 0.1f, 20.0f);
-        camera.orthoProjMatrix = SHMatrix::OrthographicRH(camera.GetWidth(), camera.GetHeight(), camera.GetNear(), camera.GetFar());
+        //camera.orthoProjMatrix = SHMatrix::OrthographicLH(camera.GetWidth(), camera.GetHeight(), camera.GetNear(), camera.GetFar());
         //camera.perspProjMatrix = SHMatrix::OrthographicLH(5.0f, 5.0f, 0.1f, 20.0f);
         //camera.projMatrix.Transpose();
 

SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp

@@ -16,6 +16,9 @@
 #include "Editor/EditorWindow/SHEditorWindowManager.h"
 #include "Scripting/SHVSUtilities.h"
 #include "Scripting/SHScriptEngine.h"
+#include "Tools/Utilities/SHStringUtilities.h"
+#include <filesystem>
+#include <rttr/type>
 
 namespace SHADE
 {
@@ -27,6 +30,13 @@ namespace SHADE
   void SHAssetBrowser::Init()
   {
     SHEditorWindow::Init();
+    rttr::array_range<rttr::string_view> typeNames = typeEnumAlign.get_names();
+    
+    for(auto const& name : typeNames)
+    {
+        uint64_t val = typeEnumAlign.name_to_value(name).to_uint64();
+        typeFilters[val] = true;
+    }
   }
 
   void SHAssetBrowser::Update()
@@ -34,7 +44,10 @@ namespace SHADE
     SHEditorWindow::Update();
     if (Begin())
     {
-      RecursivelyDrawTree(rootFolder);
+      for(auto subFolder : rootFolder->subFolders)
+      {
+        RecursivelyDrawTree(subFolder);
+      }
       DrawMenuBar();
       DrawCurrentFolder();
       DrawAssetBeingCreated();
@@ -50,6 +63,11 @@ namespace SHADE
     refreshQueued = true;
   }
 
+  void SHAssetBrowser::SetScrollTo(AssetID assetid)
+  {
+    assetToScrollTo = assetid;
+  }
+
   void SHAssetBrowser::Refresh() noexcept
   {
     SHAssetManager::RefreshDirectory();
@@ -69,6 +87,7 @@ namespace SHADE
       {
         isAssetBeingCreated = true;
       }
+      DrawAssetBrowserFilter();
       ImGui::EndMenuBar();
     }
   }
@@ -81,13 +100,34 @@ namespace SHADE
     auto files = folder->files;
     const bool isSelected = std::ranges::find(selectedFolders, folder) != selectedFolders.end();
     ImGuiTreeNodeFlags flags = (subFolders.empty() && files.empty()) ? ImGuiTreeNodeFlags_Leaf : ImGuiTreeNodeFlags_OpenOnArrow;
+    if(!filter.empty() && (!subFolders.empty() || !files.empty()))
+    {
+      ImGui::SetNextItemOpen(true);
+    }
     if (isSelected)
       flags |= ImGuiTreeNodeFlags_Selected;
     if (folder == rootFolder)
       flags |= ImGuiTreeNodeFlags_DefaultOpen;
 
-    bool isOpen = ImGui::TreeNodeEx(folder, flags, "%s %s", ICON_MD_FOLDER, folder->name.data());
-    ImGuiID folderID = ImGui::GetItemID();
+    if(assetToScrollTo != 0)
+    {
+      if(auto asset = SHAssetManager::GetAsset(assetToScrollTo))
+      {
+        if(!asset->path.empty())
+        {
+          ImGui::SetNextItemOpen(SHStringUtilities::StringFindInsensitive(asset->path.string(), folder->name.data()) != std::string::npos);
+        }
+        else if(auto parent = SHAssetManager::GetAsset(asset->parent))
+        {
+          ImGui::SetNextItemOpen(SHStringUtilities::StringFindInsensitive(parent->path.string(), folder->name.data()) != std::string::npos);
+        }
+      }
+    }
+
+    bool isOpen = false;
+    if(filter.empty())
+      isOpen = ImGui::TreeNodeEx(folder, flags, "%s %s", ICON_MD_FOLDER, folder->name.data());
+
     const ImRect nodeRect = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
 
     //if (ImGui::BeginPopupContextItem())
@@ -101,7 +141,7 @@ namespace SHADE
       selectedFolders.push_back(folder);
     }
 
-    if (isOpen)
+    if (isOpen || !filter.empty())
     {
       const ImColor treeLineColor = ImGui::GetColorU32(ImGuiCol_CheckMark);
       const float horizontalOffset = 0.0f;
@@ -127,7 +167,8 @@ namespace SHADE
       }
       drawList->AddLine(vertLineStart, vertLineEnd, treeLineColor, 1);
 
-      ImGui::TreePop();
+      if(filter.empty())
+        ImGui::TreePop();
     }
     return nodeRect;
   }
@@ -167,8 +208,26 @@ namespace SHADE
     {
       ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_Leaf;
       static constexpr std::string_view icon = ICON_MD_FILE_PRESENT;
+      bool highlighted = false;
+      if (!filter.empty())
+      {
+        if (SHStringUtilities::StringFindInsensitive(file.name.data(), filter) == std::string::npos)
+        {
+          return ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
+        }
+        else
+        {
+          highlighted = true;
+          ImGui::PushStyleColor(ImGuiCol_Text, highlightedColor);
+        }
+      }
       ImGui::PushID(file.name.data());
+
       bool const isOpen = ImGui::TreeNodeEx(file.name.data(), flags, "%s %s%s", icon.data(), file.name.data(), file.ext.data());
+      if(highlighted)
+      {
+        ImGui::PopStyleColor();
+      }
       const ImRect nodeRect = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
       if(ImGui::BeginPopupContextItem())
       {
@@ -194,6 +253,27 @@ namespace SHADE
   {
     if (asset == nullptr)
       return ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
+
+    if (!typeFilters[static_cast<uint64_t>(asset->type)])
+    {
+      return ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
+    }
+
+    bool highlighted = false;
+    if(!filter.empty())
+    {
+      ImGui::SetNextItemOpen(true);
+      if(SHStringUtilities::StringFindInsensitive(asset->name.data(), filter) == std::string::npos)
+      {
+        return ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
+      }
+      else 
+      {
+        highlighted = true;
+        ImGui::PushStyleColor(ImGuiCol_Text, highlightedColor);
+      }
+    }
+
     const bool isSelected = std::ranges::find(selectedAssets, asset->id) != selectedAssets.end();
     ImGuiTreeNodeFlags flags = (!asset->subAssets.empty()) ? ImGuiTreeNodeFlags_OpenOnArrow : ImGuiTreeNodeFlags_Leaf;
     if (isSelected)
@@ -214,8 +294,34 @@ namespace SHADE
     case AssetType::MAX_COUNT: break;
     default:;
     }
+
+    if(assetToScrollTo != 0)
+    {
+      if(asset->id == assetToScrollTo)
+      {
+        ImGui::SetScrollHereY();
+        selectedAssets.clear();
+        selectedAssets.push_back(asset->id);
+        assetToScrollTo = 0;
+      }
+      else
+      {
+        for (auto const& subAsset : asset->subAssets)
+        {
+          if(subAsset->id == assetToScrollTo)
+          {
+            ImGui::SetNextItemOpen(true);
+          }
+        }
+      }
+    }
     
     bool const isOpen = ImGui::TreeNodeEx(asset, flags, "%s %s%s", icon.data(), asset->name.data(), ext.data());
+
+    if(highlighted)
+    {
+      ImGui::PopStyleColor();
+    }
     const ImRect nodeRect = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
     if (SHDragDrop::BeginSource())
     {
@@ -339,4 +445,43 @@ namespace SHADE
     //  QueueRefresh();
     //}
   }
+
+  void SHAssetBrowser::DrawAssetBrowserFilter()
+  {
+    if (ImGui::InputTextWithHint("##hierarchyPanelFilter", "Filter", &filter))
+    {
+    }
+    if (ImGui::Button("x"))
+    {
+      filter.clear();
+    }
+    if(ImGui::BeginMenu("Type"))
+    {
+      if (ImGui::Button("All"))
+      {
+        for (auto& [id, value] : typeFilters)
+          value = true;
+      }
+      ImGui::SameLine();
+      if (ImGui::Button("None"))
+      {
+        for (auto& [id, value] : typeFilters)
+          value = false;
+      }
+      for (auto& [id, value] : typeFilters)
+      {
+        if(ImGui::Checkbox(typeEnumAlign.value_to_name(id).data(), &value))
+        {
+
+        }
+        if(ImGui::IsItemClicked(ImGuiMouseButton_Right))
+        {
+          for (auto& [id2, value2] : typeFilters)
+            value2 = false;
+          value = true;
+        }
+      }
+      ImGui::EndMenu();
+    }
+  }
 }

SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.h

@@ -4,18 +4,21 @@
 #include "Assets/SHAsset.h"
 #include "Editor/EditorWindow/SHEditorWindow.h"
 #include "Filesystem/SHFolder.h"
+#include <rttr/enumeration.h>
 
 namespace SHADE
 {
   class SHAssetBrowser final : public SHEditorWindow
   {
   public:
+    static constexpr ImVec4 highlightedColor = ImVec4(0.f, 0.7f, 0.0f, 1.0f);
     SHAssetBrowser();
 
     void Init();
     void Update();
 
     void QueueRefresh() noexcept;
+    void SetScrollTo(AssetID assetid);    
   private:
     void DrawMenuBar();
     ImRect RecursivelyDrawTree(FolderPointer folder);
@@ -23,6 +26,7 @@ namespace SHADE
     ImRect DrawFile(SHFile& file) noexcept;
     ImRect DrawAsset(SHAsset const* const asset, FileExt const& ext = "") noexcept;
     void DrawAssetBeingCreated() noexcept;
+    void DrawAssetBrowserFilter();
 
     void Refresh() noexcept;
 
@@ -30,9 +34,13 @@ namespace SHADE
     std::vector<FolderPointer> selectedFolders;
     std::vector<AssetID> selectedAssets;
     static constexpr float tileWidth = 50.0f;
+    static constexpr std::string_view newAssetPopup = "Create New Asset";
+    std::string nameOfAssetBeingCreated, filter;
+    rttr::enumeration typeEnumAlign = rttr::type::get<AssetType>().get_enumeration();
+    std::unordered_map<uint64_t, bool> typeFilters; 
+
+    AssetID assetToScrollTo = 0;
     bool refreshQueued = false;
     bool isAssetBeingCreated = false;
-    static constexpr std::string_view newAssetPopup = "Create New Asset";
-    std::string nameOfAssetBeingCreated;
   };
 }

SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp

@@ -57,9 +57,13 @@ namespace SHADE
         skipFrame = false;
         return;
       }
-      DrawMenuBar();
       auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
-
+      DrawMenuBar();
+      if(wasFilterChanged && !filter.empty())
+      {
+        filterHighlightedEntities.clear();
+        filterOpenEntities.clear();
+      }
       if (const auto root = sceneGraph.GetRoot())
       {
         auto const& children = root->GetChildren();
@@ -67,7 +71,13 @@ namespace SHADE
         for (const auto child : children)
         {
           if (child)
+          {
+            if(wasFilterChanged && !filter.empty())
+            {
+              EntityFilterCheck(child);
+            }
             RecursivelyDrawEntityNode(child);
+          }
           if (skipFrame)
           {
             ImGui::End();
@@ -177,9 +187,10 @@ namespace SHADE
 
   void SHHierarchyPanel::DrawHierarchyPanelFilter() noexcept
   {
+    wasFilterChanged = false;
     if(ImGui::InputTextWithHint("##hierarchyPanelFilter", "Filter", &filter))
     {
-
+      wasFilterChanged = true;
     }
     ImGui::SameLine();
     if(ImGui::Button("x"))
@@ -199,29 +210,70 @@ namespace SHADE
     bool result = false;
     
     result |= SHStringUtilities::StringFindInsensitive(entity->name, filter) != std::string::npos;
-    
+
     if(SHStringUtilities::StringFindInsensitive(rttr::type::get<SHTransformComponent>().get_name().data(), filter) != std::string::npos)
     {
       result |= SHComponentManager::HasComponent<SHTransformComponent>(eid);
     }
-    //result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHColliderComponent>().get_name().data(), filter) != std::string::npos;
-    //result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHRigidBodyComponent>().get_name().data(), filter) != std::string::npos;
-    //result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHCameraComponent>().get_name().data(), filter) != std::string::npos;
-    //result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHCameraArmComponent>().get_name().data(), filter) != std::string::npos;
-    //result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHRenderable>().get_name().data(), filter) != std::string::npos;
-    //result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHLightComponent>().get_name().data(), filter) != std::string::npos;
-    //result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHTextRenderableComponent>().get_name().data(), filter) != std::string::npos;
-    //result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHUIComponent>().get_name().data(), filter) != std::string::npos;
-    //result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHButtonComponent>().get_name().data(), filter) != std::string::npos;
-    //result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHCanvasComponent>().get_name().data(), filter) != std::string::npos;
+    if(SHStringUtilities::StringFindInsensitive(rttr::type::get<SHColliderComponent>().get_name().data(), filter) != std::string::npos)
+    {
+      result |= SHComponentManager::HasComponent<SHColliderComponent>(eid);
+    }
+    if(SHStringUtilities::StringFindInsensitive(rttr::type::get<SHRigidBodyComponent>().get_name().data(), filter) != std::string::npos)
+    {
+      result |= SHComponentManager::HasComponent<SHRigidBodyComponent>(eid);
+    }
+    if(SHStringUtilities::StringFindInsensitive(rttr::type::get<SHCameraComponent>().get_name().data(), filter) != std::string::npos)
+    {
+      result |= SHComponentManager::HasComponent<SHCameraComponent>(eid);
+    }
+    if(SHStringUtilities::StringFindInsensitive(rttr::type::get<SHCameraArmComponent>().get_name().data(), filter) != std::string::npos)
+    {
+      result |= SHComponentManager::HasComponent<SHCameraArmComponent>(eid);
+    }
+    if(SHStringUtilities::StringFindInsensitive(rttr::type::get<SHRenderable>().get_name().data(), filter) != std::string::npos)
+    {
+      result |= SHComponentManager::HasComponent<SHRenderable>(eid);
+    }
+    if(SHStringUtilities::StringFindInsensitive(rttr::type::get<SHLightComponent>().get_name().data(), filter) != std::string::npos)
+    {
+      result |= SHComponentManager::HasComponent<SHLightComponent>(eid);
+    }
+    if(SHStringUtilities::StringFindInsensitive(rttr::type::get<SHTextRenderableComponent>().get_name().data(), filter) != std::string::npos)
+    {
+      result |= SHComponentManager::HasComponent<SHTextRenderableComponent>(eid);
+    }
+    if(SHStringUtilities::StringFindInsensitive(rttr::type::get<SHUIComponent>().get_name().data(), filter) != std::string::npos)
+    {
+      result |= SHComponentManager::HasComponent<SHUIComponent>(eid);
+    }
+    if(SHStringUtilities::StringFindInsensitive(rttr::type::get<SHButtonComponent>().get_name().data(), filter) != std::string::npos)
+    {
+      result |= SHComponentManager::HasComponent<SHButtonComponent>(eid);
+    }
+    if(SHStringUtilities::StringFindInsensitive(rttr::type::get<SHCanvasComponent>().get_name().data(), filter) != std::string::npos)
+    {
+      result |= SHComponentManager::HasComponent<SHCanvasComponent>(eid);
+    }
 
-    //std::vector<SHSceneNode*> const& children = entityNode->GetChildren();
-    
-    //for (auto const& child : children)
-    //{
-    //  result |= EntityFilterCheck(child);
-    //}
+    if(result)
+    {
+      filterHighlightedEntities.push_back(eid);
+    }
 
+    std::vector<SHSceneNode*> const& children = entityNode->GetChildren();
+
+    bool open = false;
+    for (auto const& child : children)
+    {
+      open |= EntityFilterCheck(child);
+    }
+    result |= open;
+
+    if(open)
+    {
+      filterOpenEntities.push_back(eid);
+    }
     return result;
   }
 
@@ -245,31 +297,27 @@ namespace SHADE
 
     const bool isSelected = (std::ranges::find(editor->selectedEntities, eid) != editor->selectedEntities.end());
 
-    bool highlighted = false;
-    //if(!filter.empty())
-    //{
-    //  highlighted = EntityFilterCheck(currentNode);
-    //  if (highlighted)
-    //  {
-    //    ImGui::PushStyleColor(ImGuiCol_Text, highlightedColor);
-    //    
-    //    ImGui::SetNextItemOpen(true);
-    //    
-    //    
-    //  }
-    //  else
-    //  {
-    //   
-    //  }
-    //}
+    bool highlighted = false, open = false;
+    if(!filter.empty())
+    {
+      highlighted = (std::ranges::find(filterHighlightedEntities, eid) != filterHighlightedEntities.end());
+      if(open = std::ranges::find(filterOpenEntities, eid) != filterOpenEntities.end())
+      {
+        ImGui::SetNextItemOpen(true);
+      }
+      
+      if(!open && !highlighted)
+      {
+         return ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
+      }
+      ImGui::PushStyleColor(ImGuiCol_Text, highlighted ? highlightedColor : ImVec4(0.5f, 0.5f, 0.5f, 1.f ));
+    }
 
     const ImGuiTreeNodeFlags nodeFlags = ((isSelected) ? ImGuiTreeNodeFlags_Selected : 0) | ((children.empty()) ? ImGuiTreeNodeFlags_Leaf : ImGuiTreeNodeFlags_OpenOnArrow);
-    
-
     //Draw Node
     bool isNodeOpen = ImGui::TreeNodeEx(reinterpret_cast<void*>(eid), nodeFlags, "%u: %s", SHEntityManager::GetEntityIndex(eid), entity->name.c_str());
 
-    if (highlighted)
+    if(!filter.empty())
     {
       ImGui::PopStyleColor();
     }

SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h

@@ -15,11 +15,11 @@
 namespace SHADE
 {
   class SHSceneNode;
-  constexpr ImVec4 highlightedColor = ImVec4(0.f, 0.7f, 0.0f, 1.0f);
 
   class SHHierarchyPanel final : public SHEditorWindow
   {
   public:
+    static constexpr ImVec4 highlightedColor = ImVec4(0.f, 0.7f, 0.0f, 1.0f);
     SHHierarchyPanel();
     void Init() override;
     void Update() override;
@@ -44,7 +44,8 @@ namespace SHADE
     std::string filter;
     bool isAnyNodeSelected = false;
     EntityID scrollTo = MAX_EID;
-    std::vector<EntityID> draggingEntities;
+    std::vector<EntityID> draggingEntities, filterOpenEntities, filterHighlightedEntities;
+    bool wasFilterChanged = false;
 
   };//class SHHierarchyPanel
 

SHADE_Engine/src/Editor/EditorWindow/InputBindings/SHInputBindingsPanel.cpp

@@ -0,0 +1,546 @@
+#include "SHpch.h"
+#include "SHInputBindingsPanel.h"
+#include "Input/SHInputManager.h"
+#include "Editor/SHEditorWidgets.hpp"
+
+namespace SHADE
+{
+  //Vectors containing data for elements for different bindings
+  static std::vector<std::string> bindingRenames;
+
+  //Flags to prevent unwanted editing of bindings
+  static size_t positiveKeyListeningFor;
+  static bool positiveKeyListening;
+
+  static size_t negativeKeyListeningFor;
+  static bool negativeKeyListening;
+
+  static size_t positiveControllerListeningFor;
+  static bool positiveControllerListening;
+
+  static size_t negativeControllerListeningFor;
+  static bool negativeControllerListening;
+
+  //Internal Helper function
+  void resizeVectors(size_t newSize)
+  {
+    bindingRenames.resize(newSize);
+    for (auto& s : bindingRenames)
+      s.clear();
+  }
+
+  //Internal Helper function
+  std::string labelConcat(char const* label, size_t entryNumber)
+  {
+    std::string concat = label;
+    concat += std::to_string(entryNumber);
+    return concat;
+  }
+
+  void SHInputBindingsPanel::Init()
+  {
+    SHEditorWindow::Init();
+  }
+
+  void SHInputBindingsPanel::Update()
+  {
+    if (SHEditorWindow::Begin())
+    {
+      //ImGui::ShowDemoWindow();
+
+      //Binding count
+      ImGui::Text("Binding Count: %d", SHInputManager::CountBindings());
+
+      //Binding file name
+      static std::string bindingFileName;
+      ImGui::InputText("Binding File Path", &bindingFileName);
+      if (ImGui::IsItemHovered())
+      {
+        ImGui::BeginTooltip();
+        ImGui::Text(".SHConfig will be appeneded to file name");
+        ImGui::Text("If no name is provided, saves to or loads from \"Assets/Bindings.SHConfig\"");
+        ImGui::EndTooltip();
+      }
+
+      //Save bindings to...
+      if (ImGui::Button("Save Bindings"))
+      {
+        if (bindingFileName.empty())
+        {
+          SHInputManager::SaveBindings();
+        }
+        else
+        {
+          std::string filePath = std::string(ASSET_ROOT);
+          filePath += "/";
+          filePath += bindingFileName;
+          filePath += ".SHConfig";
+          SHInputManager::SaveBindings(filePath);
+        }
+      }
+
+      //Load bindings from...
+      if (ImGui::Button("Load Bindings"))
+      {
+        if (bindingFileName.empty())
+        {
+          SHInputManager::LoadBindings();
+        }
+        else
+        {
+          std::string filePath = std::string(ASSET_ROOT);
+          filePath += "/";
+          filePath += bindingFileName;
+          filePath += ".SHConfig";
+          SHInputManager::LoadBindings(filePath);
+        }
+        resizeVectors(SHInputManager::CountBindings());
+      }
+
+      //Button to add new binding
+      if (ImGui::Button("Add New Binding"))
+      {
+        std::string newBindingName = "Binding" + std::to_string(SHInputManager::CountBindings());
+        SHInputManager::AddBinding(newBindingName);
+        resizeVectors(SHInputManager::CountBindings());
+      }
+      if (ImGui::IsItemHovered())
+      {
+        ImGui::BeginTooltip();
+        ImGui::Text("Add a new binding to the list");
+        ImGui::EndTooltip();
+      }
+
+      //Ensure unique label for entries
+      size_t entryNumber = 0;
+
+      //Listing for each binding
+      for (auto& binding : SHInputManager::GetBindings())
+      {
+        if (ImGui::CollapsingHeader(binding.first.c_str()))
+        {
+          //Modifiable binding name
+          ImGui::Text("Binding Name: %s", binding.first.c_str());
+          ImGui::InputText(labelConcat("##bindingModifyName", entryNumber).c_str(), &bindingRenames[entryNumber]);
+          ImGui::SameLine();
+          if (ImGui::Button(labelConcat("Rename##bindingRename", entryNumber).c_str()))
+          {
+            SHInputManager::RenameBinding(binding.first, bindingRenames[entryNumber]);
+            bindingRenames[entryNumber].clear();
+          }
+
+          if (ImGui::Button(labelConcat("Delete Binding##", entryNumber).c_str()))
+          {
+            SHInputManager::RemoveBinding(binding.first);
+            resizeVectors(SHInputManager::CountBindings());
+            ImGui::End();
+            return;
+          }
+          if (ImGui::IsItemHovered())
+          {
+            ImGui::BeginTooltip();
+            ImGui::Text("Delete this binding from the list");
+            ImGui::EndTooltip();
+          }
+
+          //Binding value test
+          ImGui::BeginDisabled();
+          float val = SHInputManager::GetBindingAxis(binding.first);
+          ImGui::SliderFloat(labelConcat("Value##", entryNumber).c_str(), &val, -1.0f, 1.0f);
+          ImGui::EndDisabled();
+          if (ImGui::IsItemHovered())
+          {
+            ImGui::BeginTooltip();
+            ImGui::Text("Test the current value of the binding");
+            ImGui::Text("For mouse movement/wheel inputs, will be multiplied by Sensitivity, with 0 being neutral (no input detected)");
+            ImGui::Text("Between -1 and 1 for other inputs, with 0 still being neutral (no input detected)");
+            ImGui::EndTooltip();
+          }
+          ImGui::BeginDisabled();
+          float rawVal = SHInputManager::GetBindingAxisRaw(binding.first);
+          ImGui::SliderFloat(labelConcat("Raw Value##", entryNumber).c_str(), &rawVal, -1.0f, 1.0f);
+          ImGui::EndDisabled();
+          if (ImGui::IsItemHovered())
+          {
+            ImGui::BeginTooltip();
+            ImGui::Text("Test the current value of the binding");
+            ImGui::Text("Raw value means it will be fixed among -1, 0 and 1 for non-mouse movement/wheel inputs");
+            ImGui::Text("No difference between this and Value for mouse movement/wheel inputs");
+            ImGui::Text("But for other inputs, does not consider smoothing options such as gravity and sensitivity");
+            ImGui::Text("If both positive and negative input is detected, returns neutral 0");
+            ImGui::EndTooltip();
+          }
+
+          //Binding Type Combo Box
+          int bindingType = static_cast<int>(SHInputManager::GetBindingType(binding.first));
+          if (ImGui::Combo(labelConcat("Input Type##", entryNumber).c_str(), &bindingType, "Keyboard / Mouse Buttons / Controller\0Mouse Horizontal\0Mouse Vertical\0Mouse Scroll Wheel"))
+            SHInputManager::SetBindingType(binding.first, static_cast<SHInputManager::SH_BINDINGTYPE>(bindingType));
+          if (ImGui::IsItemHovered())
+          {
+            ImGui::BeginTooltip();
+            ImGui::Text("Which of the four types the binding uses");
+            ImGui::Text("Keyboard / Mouse Buttons / Controller = Keys, mouse buttons and ALL controller inputs");
+            ImGui::Text("Mouse Horizontal = Horizontal movement of the mouse");
+            ImGui::Text("Mouse Vertical = Vertical movement of the mouse");
+            ImGui::Text("Mouse Scroll Wheel = The scroll wheel found at the middle of most mouses");
+            ImGui::EndTooltip();
+          }
+
+          //Inversion
+          bool bindingInvert = SHInputManager::GetBindingInverted(binding.first);
+          if (ImGui::Checkbox(labelConcat("Inverted##", entryNumber).c_str(), &bindingInvert))
+            SHInputManager::SetBindingInverted(binding.first, bindingInvert);
+          if (ImGui::IsItemHovered())
+          {
+            ImGui::BeginTooltip();
+            ImGui::Text("If inverted:");
+            ImGui::Text("Positive inputs mean negative value of the binding");
+            ImGui::Text("Negative inputs mean positive value of the binding");
+            ImGui::Text("Mouse moving up / right means negative value of the binding");
+            ImGui::Text("Scrolling the mouse wheel up means negative value of the binding");
+            ImGui::EndTooltip();
+          }
+
+          //Sensitivity
+          double bindingSensitivity = SHInputManager::GetBindingSensitivity(binding.first);
+          if (ImGui::InputDouble(labelConcat("Sensitivity##", entryNumber).c_str(), &bindingSensitivity))
+            SHInputManager::SetBindingSensitivity(binding.first, bindingSensitivity);
+          if (ImGui::IsItemHovered())
+          {
+            ImGui::BeginTooltip();
+            ImGui::Text("Value multiplier for mouse movement and scrolling");
+            ImGui::Text("For other digital inputs, serves as a rate of how fast axis value goes to maximum positive/negative");
+            //ImGui::Text("For other analog inputs, serves as a multiplier, but axis value magnitude will still be capped at 1");
+            ImGui::Text("Irrelevant for other analog inputs");
+            ImGui::EndTooltip();
+          }
+
+          //Below this section is only for KB/M type bindings
+          //Not relevant for mouse movement and scrolling
+          if (SHInputManager::GetBindingType(binding.first) == SHInputManager::SH_BINDINGTYPE::KB_MB_CONTROLLER)
+          {
+            //Dead
+            float bindingDead = static_cast<float>(SHInputManager::GetBindingDead(binding.first));
+            if (ImGui::SliderFloat(labelConcat("Deadzone##", entryNumber).c_str(), &bindingDead, 0.0f, 1.0f))
+              SHInputManager::SetBindingDead(binding.first, static_cast<double>(bindingDead));
+            if (ImGui::IsItemHovered())
+            {
+              ImGui::BeginTooltip();
+              ImGui::Text("Any positive or negative analog input with magnitude less than this will be registered as neutral");
+              ImGui::EndTooltip();
+            }
+
+            //Gravity
+            double bindingGravity = SHInputManager::GetBindingGravity(binding.first);
+            if (ImGui::InputDouble(labelConcat("Gravity##", entryNumber).c_str(), &bindingGravity))
+              SHInputManager::SetBindingGravity(binding.first, static_cast<double>(bindingGravity));
+            if (ImGui::IsItemHovered())
+            {
+              ImGui::BeginTooltip();
+              ImGui::Text("The rate at which the value moves to neutral if no input in the direction is read");
+              ImGui::TextColored(ImVec4{ 1.0f, 0.5f, 0.5f, 1.0f }, "Should be non-negative");
+              ImGui::EndTooltip();
+            }
+
+            //Snap
+            bool bindingSnap = SHInputManager::GetBindingSnap(binding.first);
+            if (ImGui::Checkbox(labelConcat("Snap##", entryNumber).c_str(), &bindingSnap))
+              SHInputManager::SetBindingSnap(binding.first, bindingSnap);
+            if (ImGui::IsItemHovered())
+            {
+              ImGui::BeginTooltip();
+              ImGui::Text("If no other input on the axis is present and a input is made in the opposite direction of the current value,");
+              ImGui::Text("the binding's value will jump to neutral 0 before resuming in the input direction");
+              ImGui::EndTooltip();
+            }
+
+            size_t keycodeIndex = 0;
+            //Positive key codes
+            ImGui::Separator();
+            ImGui::Text("Positive Key Codes:");
+            if (ImGui::IsItemHovered())
+            {
+              ImGui::BeginTooltip();
+              ImGui::Text("When this keyboard or mouse button is held, causes the value to go positive, or negative when inverted");
+              ImGui::EndTooltip();
+            }
+
+            ImGui::SameLine();
+            //Button to ask for inputs
+            if (!positiveKeyListening)
+            {
+              if (ImGui::Button(labelConcat("New##positiveKeyCode", entryNumber).c_str()))
+              {
+                positiveKeyListening = true;
+                positiveKeyListeningFor = entryNumber;
+              }
+            }
+            else
+            {
+              if (positiveKeyListeningFor == entryNumber)
+              {
+                //Listening for inputs
+                ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.8f, 0.4f, 0.4f, 1.0f));
+                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(1.0f, 0.5f, 0.5f, 1.0f));
+                ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.6f, 0.3f, 0.3f, 1.0f));
+                ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.0f, 0.0f, 0.0f, 1.0f));
+                ImGui::Button(labelConcat("PRESS##positiveKeyCode", entryNumber).c_str());
+                ImGui::PopStyleColor(4);
+
+                SHInputManager::SH_KEYCODE k;
+                if (SHInputManager::AnyKey(&k))
+                {
+                  positiveKeyListening = false;
+                  SHInputManager::AddBindingPositiveKeyCode(binding.first, k);
+                }
+              }
+              else
+              {
+                //Not listening
+                ImGui::BeginDisabled();
+                ImGui::Button(labelConcat("New##positiveKeyCode", entryNumber).c_str());
+                ImGui::EndDisabled();
+              }
+            }
+
+            //List and remove bindings
+            ImGui::Indent();
+            keycodeIndex = 0;
+            for (auto& k : binding.second.positiveKeyCodes)
+            {
+              //ImGui::Text("%d", static_cast<int>(k));
+              ImGui::Text(SHInputManager::GetKeyCodeName(k).c_str());
+              ImGui::SameLine();
+              std::string labelString = "X##KeyPositive";
+              labelString += binding.first;
+
+              //Delete button
+              if (ImGui::SmallButton(labelConcat(labelString.c_str(), keycodeIndex).c_str()))
+              {
+                SHInputManager::RemoveBindingPositiveKeyCode(binding.first, k);
+                break;
+              }
+              ++keycodeIndex;
+            }
+            ImGui::Unindent();
+
+
+            //Negative key codes
+            ImGui::Separator();
+            ImGui::Text("Negative Key Codes:");
+            if (ImGui::IsItemHovered())
+            {
+              ImGui::BeginTooltip();
+              ImGui::Text("When this keyboard or mouse button is held, causes the value to go negative, or positive when inverted");
+              ImGui::EndTooltip();
+            }
+
+            ImGui::SameLine();
+            //Button to ask for inputs
+            if (!negativeKeyListening)
+            {
+              if (ImGui::Button(labelConcat("New##negativeKeyCode", entryNumber).c_str()))
+              {
+                negativeKeyListening = true;
+                negativeKeyListeningFor = entryNumber;
+              }
+            }
+            else
+            {
+              if (negativeKeyListeningFor == entryNumber)
+              {
+                //Listening for inputs
+                ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.8f, 0.4f, 0.4f, 1.0f));
+                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(1.0f, 0.5f, 0.5f, 1.0f));
+                ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.6f, 0.3f, 0.3f, 1.0f));
+                ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.0f, 0.0f, 0.0f, 1.0f));
+                ImGui::Button(labelConcat("PRESS##negativeKeyCode", entryNumber).c_str());
+                ImGui::PopStyleColor(4);
+
+                SHInputManager::SH_KEYCODE k;
+                if (SHInputManager::AnyKey(&k))
+                {
+                  negativeKeyListening = false;
+                  SHInputManager::AddBindingNegativeKeyCode(binding.first, k);
+                }
+              }
+              else
+              {
+                //Not listening
+                ImGui::BeginDisabled();
+                ImGui::Button(labelConcat("New##negativeKeyCode", entryNumber).c_str());
+                ImGui::EndDisabled();
+              }
+            }
+
+            //List and remove bindings
+            ImGui::Indent();
+            keycodeIndex = 0;
+            for (auto& k : binding.second.negativeKeyCodes)
+            {
+              //ImGui::Text("%d", static_cast<int>(k));
+              ImGui::Text(SHInputManager::GetKeyCodeName(k).c_str());
+              ImGui::SameLine();
+              std::string labelString = "X##KeyNegative";
+              labelString += binding.first;
+
+              //Delete button
+              if (ImGui::SmallButton(labelConcat(labelString.c_str(), keycodeIndex).c_str()))
+              {
+                SHInputManager::RemoveBindingNegativeKeyCode(binding.first, k);
+                break;
+              }
+              ++keycodeIndex;
+            }
+            ImGui::Unindent();
+
+            //Positive controller codes
+            ImGui::Separator();
+            ImGui::Text("Positive Controller Codes:");
+            if (ImGui::IsItemHovered())
+            {
+              ImGui::BeginTooltip();
+              ImGui::Text("When this controller button is held, causes the value to go positive, or negative when inverted");
+              ImGui::EndTooltip();
+            }
+
+            ImGui::SameLine();
+            //Button to ask for inputs
+            if (!positiveControllerListening)
+            {
+              if (ImGui::Button(labelConcat("New##positiveControllerCode", entryNumber).c_str()))
+              {
+                positiveControllerListening = true;
+                positiveControllerListeningFor = entryNumber;
+              }
+            }
+            else
+            {
+              if (positiveControllerListeningFor == entryNumber)
+              {
+                //Listening for inputs
+                ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.8f, 0.4f, 0.4f, 1.0f));
+                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(1.0f, 0.5f, 0.5f, 1.0f));
+                ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.6f, 0.3f, 0.3f, 1.0f));
+                ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.0f, 0.0f, 0.0f, 1.0f));
+                ImGui::Button(labelConcat("PRESS##positiveControllerCode", entryNumber).c_str());
+                ImGui::PopStyleColor(4);
+
+                SHInputManager::SH_CONTROLLERCODE c;
+                if (SHInputManager::AnyControllerInput(&c))
+                {
+                  positiveControllerListening = false;
+                  SHInputManager::AddBindingPositiveControllerCode(binding.first, c);
+                }
+              }
+              else
+              {
+                //Not listening
+                ImGui::BeginDisabled();
+                ImGui::Button(labelConcat("New##positiveControllerCode", entryNumber).c_str());
+                ImGui::EndDisabled();
+              }
+            }
+
+            //List and remove bindings
+            ImGui::Indent();
+            keycodeIndex = 0;
+            for (auto& c : binding.second.positiveControllerCodes)
+            {
+              //ImGui::Text("%d", static_cast<int>(k));
+              ImGui::Text(SHInputManager::GetControllerCodeName(c).c_str());
+              ImGui::SameLine();
+              std::string labelString = "X##ControllerPositive";
+              labelString += binding.first;
+
+              //Delete button
+              if (ImGui::SmallButton(labelConcat(labelString.c_str(), keycodeIndex).c_str()))
+              {
+                SHInputManager::RemoveBindingPositiveControllerCode(binding.first, c);
+                break;
+              }
+              ++keycodeIndex;
+            }
+            ImGui::Unindent();
+
+            //Negative controller codes
+            ImGui::Separator();
+            ImGui::Text("Negative Controller Codes:");
+            if (ImGui::IsItemHovered())
+            {
+              ImGui::BeginTooltip();
+              ImGui::Text("When this controller button is pressed, causes the value to go negative, or positive when inverted");
+              ImGui::EndTooltip();
+            }
+
+            ImGui::SameLine();
+            //Button to ask for inputs
+            if (!negativeControllerListening)
+            {
+              if (ImGui::Button(labelConcat("New##negativeControllerCode", entryNumber).c_str()))
+              {
+                negativeControllerListening = true;
+                negativeControllerListeningFor = entryNumber;
+              }
+            }
+            else
+            {
+              if (negativeControllerListeningFor == entryNumber)
+              {
+                //Listening for inputs
+                ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.8f, 0.4f, 0.4f, 1.0f));
+                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(1.0f, 0.5f, 0.5f, 1.0f));
+                ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.6f, 0.3f, 0.3f, 1.0f));
+                ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.0f, 0.0f, 0.0f, 1.0f));
+                ImGui::Button(labelConcat("PRESS##negativeControllerCode", entryNumber).c_str());
+                ImGui::PopStyleColor(4);
+
+                SHInputManager::SH_CONTROLLERCODE c;
+                if (SHInputManager::AnyControllerInput(&c))
+                {
+                  negativeControllerListening = false;
+                  SHInputManager::AddBindingNegativeControllerCode(binding.first, c);
+                }
+              }
+              else
+              {
+                //Not listening
+                ImGui::BeginDisabled();
+                ImGui::Button(labelConcat("New##negativeControllerCode", entryNumber).c_str());
+                ImGui::EndDisabled();
+              }
+            }
+
+            //List and remove bindings
+            ImGui::Indent();
+            keycodeIndex = 0;
+            for (auto& c : binding.second.negativeControllerCodes)
+            {
+              //ImGui::Text("%d", static_cast<int>(k));
+              ImGui::Text(SHInputManager::GetControllerCodeName(c).c_str());
+              ImGui::SameLine();
+              std::string labelString = "X##ControllerNegative";
+              labelString += binding.first;
+
+              //Delete button
+              if (ImGui::SmallButton(labelConcat(labelString.c_str(), keycodeIndex).c_str()))
+              {
+                SHInputManager::RemoveBindingNegativeControllerCode(binding.first, c);
+                break;
+              }
+              ++keycodeIndex;
+            }
+            ImGui::Unindent();
+          }
+        }
+        ++entryNumber; //Next entry
+      }
+    }
+    ImGui::End();
+  }
+
+  void SHInputBindingsPanel::Exit()
+  {
+    SHEditorWindow::Exit();
+  }
+}

SHADE_Engine/src/Editor/EditorWindow/InputBindings/SHInputBindingsPanel.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "Editor/EditorWindow/SHEditorWindow.h"
+#include <imgui.h>
+
+namespace SHADE
+{
+  class SH_API SHInputBindingsPanel final : public SHEditorWindow
+  {
+   public:
+    SHInputBindingsPanel() : SHEditorWindow("Input Bindings Panel", ImGuiWindowFlags_MenuBar) {}
+
+    void Init() override;
+    void Update() override;
+    void Exit() override;
+  };
+}

SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp

@@ -22,6 +22,10 @@
 #include "Serialization/SHSerializationHelper.hpp"
 #include "Tools/Utilities/SHClipboardUtilities.h"
 #include "SHInspectorCommands.h"
+#include "Physics/Collision/SHCollisionTagMatrix.h"
+#include "Animation/SHAnimatorComponent.h"
+#include "../SHEditorWindowManager.h"
+#include "../AssetBrowser/SHAssetBrowser.h"
 namespace SHADE
 {
   template<typename T>
@@ -500,6 +504,15 @@ namespace SHADE
           SHResourceManager::FinaliseChanges();
         }, SHDragDrop::DRAG_RESOURCE);
 
+      if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
+      {
+        if(Handle<SHMesh> const& mesh = component->GetMesh())
+        {
+          AssetID assetID = SHResourceManager::GetAssetID<SHMesh>(mesh).value_or(0);
+          SHEditorWindowManager::GetEditorWindow<SHAssetBrowser>()->SetScrollTo(assetID);
+        }
+      }
+
       const auto MAT_NAME = mat ? SHResourceManager::GetAssetName<SHMaterial>(mat->GetBaseMaterial()).value_or("") : "";
       SHEditorWidgets::DragDropReadOnlyField<AssetID>("Material", MAT_NAME,
         [component]()
@@ -519,6 +532,15 @@ namespace SHADE
           auto gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
           component->SetMaterial(gfxSystem->AddOrGetBaseMaterialInstance(SHResourceManager::LoadOrGet<SHMaterial>(id)));
         }, SHDragDrop::DRAG_RESOURCE);
+      if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
+      {
+        if(Handle<SHMaterialInstance> const& mat = component->GetMaterial())
+        {
+          AssetID assetID = SHResourceManager::GetAssetID<SHMaterial>(mat->GetBaseMaterial()).value_or(0);
+          SHEditorWindowManager::GetEditorWindow<SHAssetBrowser>()->SetScrollTo(assetID);
+        }
+      }
+
     }
     else
     {
@@ -556,7 +578,14 @@ namespace SHADE
           component->SetFont(SHResourceManager::LoadOrGet<SHFont>(id));
           SHResourceManager::FinaliseChanges();
         }, SHDragDrop::DRAG_RESOURCE);
-
+      if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
+      {
+        if (Handle<SHFont> const& font = component->GetFont())
+        {
+          AssetID assetID = SHResourceManager::GetAssetID<SHFont>(font).value_or(0);
+          SHEditorWindowManager::GetEditorWindow<SHAssetBrowser>()->SetScrollTo(assetID);
+        }
+      }
       SHEditorWidgets::InputText("Text", 
         [component](void)
         {
@@ -574,4 +603,75 @@ namespace SHADE
     }
     ImGui::PopID();
   }
+
+  template<>
+  static void DrawComponent(SHAnimatorComponent* component)
+  {
+    if (!component)
+      return;
+    ImGui::PushID(SHFamilyID<SHComponent>::GetID<SHAnimatorComponent>());
+    const auto componentType = rttr::type::get(*component);
+    SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active");
+    ImGui::SameLine();
+    if (ImGui::CollapsingHeader(componentType.get_name().data()))
+    {
+      DrawContextMenu(component);
+      Handle<SHRig> const& rig = component->GetRig();
+      const auto RIG_NAME = rig ? SHResourceManager::GetAssetName<SHRig>(rig).value_or("") : "";
+      SHEditorWidgets::DragDropReadOnlyField<AssetID>("Rig", RIG_NAME, [component]()
+      {
+          Handle<SHRig> const& rig = component->GetRig();
+          return SHResourceManager::GetAssetID<SHRig>(rig).value_or(0);
+      },
+      [component](AssetID const& id)
+      {
+        if (SHAssetManager::GetType(id) != AssetType::MODEL)
+        {
+          SHLOG_WARNING("Attempted to assign non mesh asset to Renderable Mesh property!")
+            return;
+        }
+        component->SetRig(SHResourceManager::LoadOrGet<SHRig>(id));
+        SHResourceManager::FinaliseChanges();
+      }, SHDragDrop::DRAG_RESOURCE);
+      if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
+      {
+        if (Handle<SHRig> const& rig = component->GetRig())
+        {
+          AssetID assetID = SHResourceManager::GetAssetID<SHRig>(rig).value_or(0);
+          SHEditorWindowManager::GetEditorWindow<SHAssetBrowser>()->SetScrollTo(assetID);
+        }
+      }
+      Handle<SHAnimationClip> const& clip = component->GetCurrentClip();
+      const auto CLIP_NAME = clip ? SHResourceManager::GetAssetName<SHAnimationClip>(clip).value_or("") : "";
+      SHEditorWidgets::DragDropReadOnlyField<AssetID>("Clip", CLIP_NAME,
+      [component]()
+      {
+        Handle<SHAnimationClip> const& clip = component->GetCurrentClip();
+        return SHResourceManager::GetAssetID<SHAnimationClip>(clip).value_or(0);
+      },
+      [component](AssetID const& id)
+      {
+        if (SHAssetManager::GetType(id) != AssetType::MODEL)
+        {
+          SHLOG_WARNING("Attempted to assign non mesh asset to Renderable Mesh property!")
+            return;
+        }
+        component->SetClip(SHResourceManager::LoadOrGet<SHAnimationClip>(id));
+      }, SHDragDrop::DRAG_RESOURCE);
+      if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
+      {
+        if (Handle<SHAnimationClip> const& clip = component->GetCurrentClip())
+        {
+          AssetID assetID = SHResourceManager::GetAssetID<SHAnimationClip>(clip).value_or(0);
+          SHEditorWindowManager::GetEditorWindow<SHAssetBrowser>()->SetScrollTo(assetID);
+        }
+      }
+    }
+    else
+    {
+      DrawContextMenu(component);
+    }
+    ImGui::PopID();
+  }
+
 }

SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorInspector.cpp

@@ -28,6 +28,13 @@
 
 namespace SHADE
 {
+  template<typename Component>
+  void EnsureComponent(EntityID eid)
+  {
+      if(SHComponentManager::GetComponent_s<Component>(eid) == nullptr)
+        SHComponentManager::AddComponent<Component>(eid);
+  }
+
   template<typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
   bool DrawAddComponentButton(EntityID const& eid)
   {
@@ -49,9 +56,13 @@ namespace SHADE
     return selected;
   }
 
-  template <typename ComponentType, typename EnforcedComponent, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true, std::enable_if_t<std::is_base_of_v<SHComponent, EnforcedComponent>, bool> = true>
+  template <typename ComponentType, typename ... EnforcedComponents>
   bool DrawAddComponentWithEnforcedComponentButton(EntityID const& eid)
   {
+    // Only make sure components are passed here
+    static_assert(std::is_base_of_v<SHComponent, ComponentType>, "");
+    //(static_assert(std::is_base_of_v<SHComponent, EnforcedComponents>, ""), ...);
+
     bool selected = false;
     if (!SHComponentManager::HasComponent<ComponentType>(eid))
     {
@@ -59,9 +70,8 @@ namespace SHADE
 
       if(selected = ImGui::Selectable(std::format("Add {}", componentName).data()); selected)
       {
-        if(SHComponentManager::GetComponent_s<EnforcedComponent>(eid) == nullptr)
-          SHComponentManager::AddComponent<EnforcedComponent>(eid);
-
+        // Ensure that all required components are present
+        (EnsureComponent<EnforcedComponents>(eid), ...);
         SHComponentManager::AddComponent<ComponentType>(eid);
       }
       if(ImGui::IsItemHovered())
@@ -70,9 +80,8 @@ namespace SHADE
         ImGui::Text("Adds", componentName); ImGui::SameLine();
         ImGui::TextColored(ImGuiColors::green, "%s", componentName); ImGui::SameLine();
         ImGui::Text("to this entity", componentName);
-        ImGui::Text("Adds"); ImGui::SameLine();
-        ImGui::TextColored(ImGuiColors::red, "%s", rttr::type::get<EnforcedComponent>().get_name().data()); ImGui::SameLine();
-        ImGui::Text("if the entity does not already have it");
+        ImGui::Text("Adds the following components if the entity does not already have it: ");
+        (ImGui::TextColored(ImGuiColors::red, "%s", rttr::type::get<EnforcedComponents>().get_name().data()), ...);
         ImGui::EndTooltip();
       }
     }
@@ -118,6 +127,10 @@ namespace SHADE
         {
           DrawComponent(renderableComponent);
         }
+        if (auto animatorComponent = SHComponentManager::GetComponent_s<SHAnimatorComponent>(eid))
+        {
+          DrawComponent(animatorComponent);
+        }
         if(auto colliderComponent = SHComponentManager::GetComponent_s<SHColliderComponent>(eid))
         {
           DrawComponent(colliderComponent);
@@ -179,6 +192,7 @@ namespace SHADE
           DrawAddComponentWithEnforcedComponentButton<SHRigidBodyComponent, SHTransformComponent>(eid);
           DrawAddComponentWithEnforcedComponentButton<SHColliderComponent, SHTransformComponent>(eid);
           DrawAddComponentWithEnforcedComponentButton<SHTextRenderableComponent, SHTransformComponent>(eid);
+          DrawAddComponentWithEnforcedComponentButton<SHAnimatorComponent, SHTransformComponent, SHRenderable>(eid);
           
 
           ImGui::EndMenu();

SHADE_Engine/src/Editor/EditorWindow/MaterialInspector/SHMaterialInspector.cpp

@@ -1,8 +1,11 @@
 #include "SHpch.h"
+
+#include <memory>
+#include <imgui.h>
+
 #include "Serialization/SHSerializationHelper.hpp"
 #include "SHMaterialInspector.h"
 #include "Editor/SHImGuiHelpers.hpp"
-#include <imgui.h>
 
 #include "Assets/SHAssetManager.h"
 #include "Editor/IconsMaterialDesign.h"
@@ -89,11 +92,17 @@ namespace SHADE
           if (vertShader && fragShader && gfxSystem)
           {
             // - Retrieve pipeline from pipeline library
-            auto renderPass = gfxSystem->GetPrimaryRenderpass();
-            auto subPass = renderPass->GetSubpass(currentMatSpec->subpassName);
-            auto pipeline = renderPass->GetOrCreatePipeline({ vertShader, fragShader }, subPass);
-            // - Set Pipeline
-            matHandle->SetPipeline(pipeline);
+            auto subPass = gfxSystem->GetUsableSubpass(currentMatSpec->subpassName);
+            if (subPass)
+            {
+              // Set Pipeline if valid
+              auto pipeline = subPass->GetParentNode()->GetOrCreatePipeline({vertShader, fragShader}, subPass);
+              matHandle->SetPipeline(pipeline);
+            }
+            else
+            {
+              SHLOG_ERROR("[SHMaterialInspector] Failed to find material subpass of type \"{}\"", currentMatSpec->subpassName);
+            }
           }
         }
 
@@ -176,7 +185,7 @@ namespace SHADE
     const std::string VERT_SHADER_NAME = VERT_SHADER_INFO ? VERT_SHADER_INFO->name : "Unknown Shader";
     isDirty |= SHEditorWidgets::DragDropReadOnlyField<AssetID>
     (
-      "Fragment Shader", VERT_SHADER_NAME.data(),
+      "Vertex Shader", VERT_SHADER_NAME.data(),
       [this]() { return currentMatSpec->vertexShader; }, 
       [this](const AssetID& id) { currentMatSpec->vertexShader = id; },
       SHDragDrop::DRAG_RESOURCE
@@ -191,6 +200,37 @@ namespace SHADE
       SHDragDrop::DRAG_RESOURCE
     );
 
+    // Subpass
+    const auto& SP_NAMES = SHGraphicsConstants::RenderGraphEntityNames::USABLE_SUBPASSES;
+    ImGui::Text("Subpass");
+    ImGui::SameLine();
+    if (ImGui::BeginCombo("##", currentMatSpec->subpassName.data(), ImGuiComboFlags_None))
+    {
+      for (const auto& NAME : SP_NAMES)
+      {
+        const bool IS_SELECTED = currentMatSpec->subpassName == NAME;
+        if (ImGui::Selectable(NAME.data(), IS_SELECTED))
+        {
+          isDirty = true;
+          SHCommandManager::PerformCommand
+          (
+            std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<std::string>>
+            (
+              currentMatSpec->subpassName,
+              std::string(NAME),
+              [&](const std::string& newName){ currentMatSpec->subpassName = newName; }
+            )),
+            false
+          );
+        }
+        if (IS_SELECTED)
+        {
+          ImGui::SetItemDefaultFocus();
+        }
+      }
+      ImGui::EndCombo();
+    }
+
     // Load the shader to access it's data
     auto fragShader = SHResourceManager::LoadOrGet<SHVkShaderModule>(currentMatSpec->fragShader);
     if (!fragShader)
@@ -201,8 +241,8 @@ namespace SHADE
     // Get interface for the shader combination
     auto interface = fragShader->GetReflectedData().GetDescriptorBindingInfo().GetShaderBlockInterface
     (
-      mappings.at(SHPredefinedDescriptorTypes::MATERIALS),
-      SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA
+      mappings.at(SHPredefinedDescriptorTypes::PER_INSTANCE_BATCH),
+      SHGraphicsConstants::DescriptorSetBindings::PER_INST_MATERIAL_DATA
     );
     if (!interface)
       return;

SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowIncludes.h

@@ -6,4 +6,5 @@
 #include "ViewportWindow/SHEditorViewport.h"        //Editor Viewport
 #include "AssetBrowser/SHAssetBrowser.h"            //Asset Browser
 #include "MaterialInspector/SHMaterialInspector.h"  //Material Inspector
-#include "ColliderTagPanel/SHColliderTagPanel.h"    //Collider Tag Panel
+#include "ColliderTagPanel/SHColliderTagPanel.h"    //Collider Tag Panel
+#include "InputBindings/SHInputBindingsPanel.h"     //Input Bindings

SHADE_Engine/src/Editor/SHEditor.cpp

@@ -96,8 +96,10 @@ namespace SHADE
         SHLOG_CRITICAL("Failed to create ImGui Context")
       }
     }
-    
+
+#ifdef SHEDITOR
     editorConfig = &SHConfigurationManager::LoadEditorConfig();
+#endif
 
     //Add editor windows
     SHEditorWindowManager::CreateEditorWindow<SHEditorMenuBar>();
@@ -106,6 +108,7 @@ namespace SHADE
     SHEditorWindowManager::CreateEditorWindow<SHMaterialInspector>();
     SHEditorWindowManager::CreateEditorWindow<SHColliderTagPanel>();
     SHEditorWindowManager::CreateEditorWindow<SHHierarchyPanel>();
+    SHEditorWindowManager::CreateEditorWindow<SHInputBindingsPanel>();
     SHEditorWindowManager::CreateEditorWindow<SHEditorInspector>();
 
     SHEditorWindowManager::CreateEditorWindow<SHEditorViewport>();
@@ -130,8 +133,9 @@ namespace SHADE
 
     InitBackend();
 
+#ifdef SHEDITOR
     SetStyle(static_cast<Style>(editorConfig->style));
-    
+#endif // SHEDITOR
 
     for (const auto& window : SHEditorWindowManager::editorWindows | std::views::values)
     {
@@ -339,13 +343,18 @@ namespace SHADE
     ImGui_ImplSDL2_Shutdown();
     ImGui::DestroyContext();
     
+#ifdef SHEDITOR
     editorConfig->startMaximized = shWindow->GetWindowData().isMaximised;
     SHConfigurationManager::SaveEditorConfig();
+#endif // SHEDITOR
   }
 
   void SHEditor::SetStyle(Style style)
   {
+#ifdef SHEDITOR
     editorConfig->style = static_cast<uint32_t>(style);
+#endif // SHEDITOR
+
     switch (style)
     {
     default: 
@@ -549,7 +558,10 @@ namespace SHADE
 
       SHSceneManager::SetCurrentSceneName(newSceneName);
       SHSceneManager::SetCurrentSceneAssetID(SHAssetManager::CreateNewAsset(AssetType::SCENE, newSceneName));
+#ifdef SHEDITOR
       editorConfig->workingSceneID = SHSceneManager::GetCurrentSceneAssetID();
+#endif // SHEDITOR
+
     }
     //Get data, if data is null, asset doesn't exist, prompt for a name and create a new asset with the name
 
@@ -558,7 +570,10 @@ namespace SHADE
     {
       if(shWindow->IsUnsavedChanges())
         shWindow->ToggleUnsavedChanges();
+#ifdef SHEDITOR
       editorConfig->workingSceneID = SHSceneManager::GetCurrentSceneAssetID();
+#endif // SHEDITOR
+
       return true;
     }
     return false;
@@ -623,7 +638,11 @@ namespace SHADE
     editorState = SHEditor::State::STOP;
     SHCommandManager::SwapStacks();
     SHEventManager::BroadcastEvent<SHEditorStateChangeEvent>(STATE_CHANGE_EVENT, SH_EDITOR_ON_STOP_EVENT);
+
+#ifdef SHEDITOR
     LoadScene(editorConfig->workingSceneID);
+#endif // SHEDITOR
+
   }
 
   void SHEditor::ProcessShortcuts()
@@ -678,7 +697,9 @@ namespace SHADE
         if(width > 0 && height > 0)
         {
           auto [width, height] = shWindow->GetWindowSize();
+#ifdef SHEditor
           editorConfig->windowSize = { static_cast<float>(width), static_cast<float>(height) };
+#endif // SHEditor
         }
       });
   }

SHADE_Engine/src/Editor/SHEditor.h

@@ -127,8 +127,9 @@ namespace SHADE
     std::vector<EntityID> selectedEntities;
 
     State editorState = State::STOP;
-
+#ifdef SHEDITOR
     SHEditorConfig* editorConfig;
+#endif // SHEDITOR
 
   private:
     /**

SHADE_Engine/src/Editor/SHEditorUI.h

@@ -98,9 +98,9 @@ namespace SHADE
     static bool IsItemHovered();
 
     /*-----------------------------------------------------------------------------*/
-	/* ImGui Wrapper Functions - Menu                                              */
-	/*-----------------------------------------------------------------------------*/
-	static bool BeginMenu(const std::string& label);
+	  /* ImGui Wrapper Functions - Menu                                              */
+	  /*-----------------------------------------------------------------------------*/
+	  static bool BeginMenu(const std::string& label);
     static bool BeginMenu(const std::string& label, const char* icon);
     static void EndMenu();
     static void BeginTooltip();
@@ -164,8 +164,8 @@ namespace SHADE
     /// </summary>
     /// <param name="title">Text to display.</param>
     /// <returns>True if button was pressed.</returns>
-	static bool Button(const std::string& title);
-	static bool Selectable(const std::string& label);
+	  static bool Button(const std::string& title);
+	  static bool Selectable(const std::string& label);
     static bool Selectable(const std::string& label, const char* icon);
     /// <summary>
     /// Creates a checkbox widget for boolean input.

SHADE_Engine/src/Editor/SHEditorWidgets.hpp

@@ -424,7 +424,7 @@ namespace SHADE
       ImGui::BeginGroup();
       ImGui::PushID(label.data());
       TextLabel(label);
-      bool changed = ImGui::InputText("##inputText", &text, ImGuiInputTextFlags_ReadOnly, nullptr, nullptr);
+      bool changed = ImGui::InputText("##inputText", &text, ImGuiInputTextFlags_ReadOnly | ImGuiInputTextFlags_AutoSelectAll, nullptr, nullptr);
       if(SHDragDrop::BeginTarget())
       {
         if(T* payload = SHDragDrop::AcceptPayload<T>(dragDropTag))

SHADE_Engine/src/Filesystem/SHFileSystem.cpp

@@ -105,6 +105,12 @@ namespace SHADE
       std::vector<SHAsset> assets;
 
       // Get all subfolders/files in this current folder
+      if (!std::filesystem::exists(std::filesystem::path(folder->path)))
+      {
+        SHLOG_WARNING("[Asset Manager] Path to build directory does not exist!: {}", folder->path);
+        continue;
+      }
+
 			for (auto& dirEntry : std::filesystem::directory_iterator(folder->path))
 			{
         auto path = dirEntry.path();

SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDevice.h

@@ -10,6 +10,7 @@ namespace SHADE
   enum class SH_PHYSICAL_DEVICE_TYPE
   {
     BEST,
+    DEDICATED,
   };
 
   class SHVkPhysicalDevice

SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDeviceLibrary.cpp

@@ -160,9 +160,31 @@ namespace SHADE
       }
     }
 
+    
     return bestDevice;
   }
 
+  vk::PhysicalDevice SHVkPhysicalDeviceLibrary::GetFirstDedicatedDevice(uint32_t apiVersion /*= SHVulkanAPIVersion::V_1_2*/)
+  {
+    if (!queried || physicalDevices.empty())
+      return nullptr;
+
+    for (auto const& device : physicalDevices)
+    {
+      // Check for API version and device type. Ignore if queried device doesn't support version passed in
+      if (device.getProperties().apiVersion < static_cast<uint32_t>(apiVersion))
+        continue;
+
+      //VkDeviceSize biggestDeviceHeapSize = device.getMemoryProperties().;
+      if (device.getProperties().deviceType == vk::PhysicalDeviceType::eDiscreteGpu)
+        return device;
+
+    }
+
+
+    return nullptr;
+  }
+
   /***************************************************************************/
   /*!
   
@@ -181,10 +203,10 @@ namespace SHADE
     }
 
 		#ifdef DEBUG
-    SHLOG_TRACE("Successfully queried Physical Devices:");
+    SHLOG_INFO("Successfully queried Physical Devices:");
     for (auto const& device : physicalDevices)
     {
-      SHLOG_TRACE(std::string_view (std::string("\t-") + GetDeviceTypeName(device.getProperties().deviceType) + device.getProperties().deviceName.operator std::string()));
+      SHLOG_INFO(std::string_view (std::string("\t-") + GetDeviceTypeName(device.getProperties().deviceType) + device.getProperties().deviceName.operator std::string()));
     }
 		#endif
 

SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDeviceLibrary.h

@@ -26,6 +26,7 @@ namespace SHADE
     static void QueryPhysicalDevices(bool printInfo) noexcept;
     //static std::vector<std::shared_ptr<SHPhysicalDevice>> GetDevicesByType(VkPhysicalDeviceType gpuType, SHVulkanAPIVersion apiVersion = SHVulkanAPIVersion::V_1_2) noexcept;
     static vk::PhysicalDevice GetBestDevice(uint32_t apiVersion = VK_API_VERSION_1_3);
+    static vk::PhysicalDevice GetFirstDedicatedDevice(uint32_t apiVersion = VK_API_VERSION_1_3);
 
   };
 }

SHADE_Engine/src/Graphics/Instance/SHVkInstance.cpp

@@ -213,6 +213,8 @@ namespace SHADE
     {
     case SH_PHYSICAL_DEVICE_TYPE::BEST:
       return resourceManager.Create<SHVkPhysicalDevice>(SHVkPhysicalDeviceLibrary::GetBestDevice());
+    case SH_PHYSICAL_DEVICE_TYPE::DEDICATED:
+      return resourceManager.Create<SHVkPhysicalDevice>(SHVkPhysicalDeviceLibrary::GetFirstDedicatedDevice());
     default:
       return resourceManager.Create<SHVkPhysicalDevice>(SHVkPhysicalDeviceLibrary::GetBestDevice());
     }

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

@@ -29,48 +29,59 @@ of DigiPen Institute of Technology is prohibited.
 #include "Graphics/Descriptors/SHVkDescriptorPool.h"
 #include "Scene/SHSceneManager.h"
 #include "UI/SHUIComponent.h"
+#include "Animation/SHAnimatorComponent.h"
 
 namespace SHADE
 {
-  /*---------------------------------------------------------------------------------*/
-  /* SHBatch - Usage Functions                                                       */
-  /*---------------------------------------------------------------------------------*/
+  /*-----------------------------------------------------------------------------------*/
+  /* SHBatch - Constructors/Destructors                                                */
+  /*-----------------------------------------------------------------------------------*/
   SHBatch::SHBatch(Handle<SHVkPipeline> pipeline)
-    : pipeline{ pipeline }
+  : pipeline{ pipeline }
   {
     if (!pipeline)
       throw std::invalid_argument("Attempted to create a SHBatch with an invalid SHPipeline!");
 
+    // Check the pipeline and flag it depending on whether or not it is animated
+    isAnimated = checkIfIsAnimatedPipeline(pipeline);
+
     // Mark all as dirty
     setAllDirtyFlags();
   }
 
   SHBatch::SHBatch(SHBatch&& rhs)
-  : device                   { rhs.device                              }
-  , pipeline                 { rhs.pipeline                            }
-  , referencedMatInstances   { std::move(rhs.referencedMatInstances)   }
-  , matBufferDirty           { std::move(rhs.matBufferDirty)           }
-  , subBatches               { std::move(rhs.subBatches)               }
-  , isDirty                  { std::move(rhs.isDirty) }
-  , drawData                 { std::move(rhs.drawData)                 }
-  , transformData            { std::move(rhs.transformData)            }
-  , instancedIntegerData     { std::move(rhs.instancedIntegerData)     }
-  , matPropsData             { std::move(rhs.matPropsData)             }
-  , matPropsDataSize         { rhs.matPropsDataSize                    }
-  , singleMatPropAlignedSize { rhs.singleMatPropAlignedSize            }
-  , singleMatPropSize        { rhs.singleMatPropSize                   }
-  , isCPUBuffersDirty        { rhs.isCPUBuffersDirty                   }
-  , drawDataBuffer           { rhs.drawDataBuffer                      }
-  , transformDataBuffer      { rhs.transformDataBuffer                 }
-  , instancedIntegerBuffer   { rhs.instancedIntegerBuffer              }
-  , matPropsBuffer           { rhs.matPropsBuffer                      }
-  , matPropsDescSet          { rhs.matPropsDescSet                     }
+  : device                     { rhs.device                            }
+  , isAnimated                 { rhs.isAnimated                        }
+  , pipeline                   { rhs.pipeline                          }
+  , referencedMatInstances     { std::move(rhs.referencedMatInstances) }
+  , matBufferDirty             { std::move(rhs.matBufferDirty)         }
+  , subBatches                 { std::move(rhs.subBatches)             }
+  , isDirty                    { std::move(rhs.isDirty)                }
+  , drawData                   { std::move(rhs.drawData)               }
+  , transformData              { std::move(rhs.transformData)          }
+  , instancedIntegerData       { std::move(rhs.instancedIntegerData)   }
+  , matPropsData               { std::move(rhs.matPropsData)           }
+  , matPropsDataSize           { rhs.matPropsDataSize                  }
+  , singleMatPropAlignedSize   { rhs.singleMatPropAlignedSize          }
+  , singleMatPropSize          { rhs.singleMatPropSize                 }
+  , boneMatrixData             { std::move(rhs.boneMatrixData)         }
+  , boneMatrixIndices          { std::move(rhs.boneMatrixIndices)      }
+  , isCPUBuffersDirty          { rhs.isCPUBuffersDirty                 }
+  , drawDataBuffer             { rhs.drawDataBuffer                    }
+  , transformDataBuffer        { rhs.transformDataBuffer               }
+  , instancedIntegerBuffer     { rhs.instancedIntegerBuffer            }
+  , matPropsBuffer             { rhs.matPropsBuffer                    }
+  , boneMatrixBuffer           { rhs.boneMatrixBuffer                  }
+  , boneMatrixFirstIndexBuffer { rhs.boneMatrixFirstIndexBuffer        }
+  , instanceDataDescSet        { rhs.instanceDataDescSet               }
   {
-    rhs.drawDataBuffer         = {};
-    rhs.transformDataBuffer    = {};
-    rhs.instancedIntegerBuffer = {};
-    rhs.matPropsBuffer         = {};
-    rhs.matPropsDescSet        = {};
+    rhs.drawDataBuffer             = {};
+    rhs.transformDataBuffer        = {};
+    rhs.instancedIntegerBuffer     = {};
+    rhs.matPropsBuffer             = {};
+    rhs.boneMatrixBuffer           = {};
+    rhs.boneMatrixFirstIndexBuffer = {};
+    rhs.instanceDataDescSet        = {};
   }
 
   SHBatch& SHBatch::operator=(SHBatch&& rhs)
@@ -78,32 +89,39 @@ namespace SHADE
     if (this == &rhs)
       return *this;
     
-    device                   = rhs.device                           ;
-    pipeline                 = rhs.pipeline                         ;
-    referencedMatInstances   = std::move(rhs.referencedMatInstances);
-    matBufferDirty           = std::move(rhs.matBufferDirty)        ;
-    subBatches               = std::move(rhs.subBatches)            ;
-    isDirty                  = std::move(rhs.isDirty)               ;
-    drawData                 = std::move(rhs.drawData)              ;
-    transformData            = std::move(rhs.transformData)         ;
-    instancedIntegerData     = std::move(rhs.instancedIntegerData)  ;
-    matPropsData             = std::move(rhs.matPropsData)          ;
-    matPropsDataSize         = rhs.matPropsDataSize                 ;
-    singleMatPropAlignedSize = rhs.singleMatPropAlignedSize         ;
-    singleMatPropSize        = rhs.singleMatPropSize                ;
-    isCPUBuffersDirty        = rhs.isCPUBuffersDirty                ;
-    drawDataBuffer           = rhs.drawDataBuffer                   ;
-    transformDataBuffer      = rhs.transformDataBuffer              ;
-    instancedIntegerBuffer   = rhs.instancedIntegerBuffer           ;
-    matPropsBuffer           = rhs.matPropsBuffer                   ;
-    matPropsDescSet          = rhs.matPropsDescSet                  ;
+    device                     = rhs.device                           ;
+    isAnimated                 = rhs.isAnimated                       ;
+    pipeline                   = rhs.pipeline                         ;
+    referencedMatInstances     = std::move(rhs.referencedMatInstances);
+    matBufferDirty             = std::move(rhs.matBufferDirty)        ;
+    subBatches                 = std::move(rhs.subBatches)            ;
+    isDirty                    = std::move(rhs.isDirty)               ;
+    drawData                   = std::move(rhs.drawData)              ;
+    transformData              = std::move(rhs.transformData)         ;
+    instancedIntegerData       = std::move(rhs.instancedIntegerData)  ;
+    matPropsData               = std::move(rhs.matPropsData)          ;
+    matPropsDataSize           = rhs.matPropsDataSize                 ;
+    singleMatPropAlignedSize   = rhs.singleMatPropAlignedSize         ;
+    singleMatPropSize          = rhs.singleMatPropSize                ;
+    boneMatrixData             = std::move(rhs.boneMatrixData)        ;
+    boneMatrixIndices          = std::move(rhs.boneMatrixIndices)     ;
+    isCPUBuffersDirty          = rhs.isCPUBuffersDirty                ;
+    drawDataBuffer             = rhs.drawDataBuffer                   ;
+    transformDataBuffer        = rhs.transformDataBuffer              ;
+    instancedIntegerBuffer     = rhs.instancedIntegerBuffer           ;
+    matPropsBuffer             = rhs.matPropsBuffer                   ;
+    boneMatrixBuffer           = rhs.boneMatrixBuffer                 ;
+    boneMatrixFirstIndexBuffer = rhs.boneMatrixFirstIndexBuffer       ;
+    instanceDataDescSet        = rhs.instanceDataDescSet              ;
 
     // Unset values
-    rhs.drawDataBuffer         = {};
-    rhs.transformDataBuffer    = {};
-    rhs.instancedIntegerBuffer = {};
-    rhs.matPropsBuffer         = {};
-    rhs.matPropsDescSet        = {};
+    rhs.drawDataBuffer             = {};
+    rhs.transformDataBuffer        = {};
+    rhs.instancedIntegerBuffer     = {};
+    rhs.matPropsBuffer             = {};
+    rhs.boneMatrixBuffer           = {};
+    rhs.boneMatrixFirstIndexBuffer = {};
+    rhs.instanceDataDescSet        = {};
 
     return *this;
   }
@@ -121,11 +139,14 @@ namespace SHADE
         instancedIntegerBuffer[i].Free();
       if (matPropsBuffer[i])
         matPropsBuffer[i].Free();
-      if (matPropsDescSet[i])
-        matPropsDescSet[i].Free();
+      if (instanceDataDescSet[i])
+        instanceDataDescSet[i].Free();
     }
   }
 
+  /*-----------------------------------------------------------------------------------*/
+  /* SHBatch - Usage Functions                                                         */
+  /*-----------------------------------------------------------------------------------*/
   void SHBatch::Add(const SHRenderable* renderable)
   {
     // Ignore if null
@@ -285,7 +306,7 @@ namespace SHADE
       }
 
     // Transfer to GPU
-    rebuildMaterialBuffers(frameIndex, descPool);
+    rebuildDescriptorSetBuffers(frameIndex, descPool);
 
     // This frame is updated
     matBufferDirty[frameIndex] = false;
@@ -359,21 +380,86 @@ namespace SHADE
 
     // Populate on the CPU
     for (auto& subBatch : subBatches)
-      for (auto rendId : subBatch.Renderables)
+    for (auto rendId : subBatch.Renderables)
+    {
+      auto* renderable = SHComponentManager::GetComponent<SHRenderable>(rendId);
+      instancedIntegerData.emplace_back(SHInstancedIntegerData
       {
-        auto* renderable = SHComponentManager::GetComponent<SHRenderable>(rendId);
-        instancedIntegerData.emplace_back(SHInstancedIntegerData
-          {
-            rendId,
-            renderable->GetLightLayer()
-          }
-        );
-      }
+        rendId,
+        renderable->GetLightLayer()
+      });
+    }
 
     // Transfer to GPU
     if (instancedIntegerBuffer[frameIndex] && !drawData.empty())
       instancedIntegerBuffer[frameIndex]->WriteToMemory(instancedIntegerData.data(), static_cast<uint32_t>(instancedIntegerData.size() * sizeof(SHInstancedIntegerData)), 0, 0);
+  }
 
+  void SHBatch::UpdateAnimationBuffer(uint32_t frameIndex)
+  {
+    // Ignore if not animated batch
+    if (!isAnimated)
+      return;
+
+    // Frame Index check
+    if (frameIndex >= SHGraphicsConstants::NUM_FRAME_BUFFERS)
+    {
+      SHLOG_WARNING("[SHBatch] Attempted to update animation buffers with an invalid frame index.");
+      return;
+    }
+
+    // Reset Animation Matrix Data
+    boneMatrixData.clear();
+    boneMatrixIndices.clear();
+
+    // Add the first identity matrix into the bone matrix data
+    boneMatrixData.emplace_back(SHMatrix::Identity); // This kills the GPU
+
+    // Populate on the CPU
+    for (auto& subBatch : subBatches)
+    for (auto rendId : subBatch.Renderables)
+    {
+      // Get resources
+      auto animator = SHComponentManager::GetComponent_s<SHAnimatorComponent>(rendId);
+      auto renderable = SHComponentManager::GetComponent<SHRenderable>(rendId);
+      auto mesh = renderable->GetMesh();
+
+      // Mark start
+      boneMatrixIndices.emplace_back(static_cast<uint32_t>(boneMatrixData.size()));
+
+      // Add matrices
+      const int BONE_COUNT = static_cast<int>(mesh->BoneCount);
+      int extraMatricesToAdd = BONE_COUNT;
+      if (animator)
+      {
+        // Add matrices
+        const auto& MATRICES = animator->GetBoneMatrices();
+        if (MATRICES.size() <= BONE_COUNT)
+        {
+          boneMatrixData.insert(boneMatrixData.end(), MATRICES.cbegin(), MATRICES.cend());
+          extraMatricesToAdd = std::max({0, BONE_COUNT - static_cast<int>(MATRICES.size())});
+        }
+      }
+
+      // If we need to patch up with more matrices, add it
+      if (extraMatricesToAdd > 0)
+      {
+        boneMatrixData.insert(boneMatrixData.end(), extraMatricesToAdd, SHMatrix::Identity);
+      }
+    }
+
+    // Update GPU Buffers
+    if (!boneMatrixIndices.empty())
+    {
+      const uint32_t BMI_DATA_BYTES = static_cast<uint32_t>(boneMatrixIndices.size() * sizeof(uint32_t));
+      SHVkUtil::EnsureBufferAndCopyHostVisibleData
+      (
+        device, boneMatrixFirstIndexBuffer[frameIndex], boneMatrixIndices.data(), BMI_DATA_BYTES,
+        vk::BufferUsageFlagBits::eVertexBuffer,
+        "Batch Instance Bone Matrix First Index Buffer"
+      );
+    }
+    rebuildBoneMatrixDescSetBuffer(frameIndex);
   }
 
   void SHBatch::Build(Handle<SHVkLogicalDevice> _device, Handle<SHVkDescriptorPool> descPool, uint32_t frameIndex)
@@ -410,14 +496,23 @@ namespace SHADE
       // - EID data
       instancedIntegerData.reserve(numTotalElements);
       instancedIntegerData.clear();
+      // - Bone Data
+      if (isAnimated)
+      {
+        boneMatrixData.clear();
+        boneMatrixIndices.clear();
+        boneMatrixIndices.reserve(numTotalElements);
 
-      auto const& descMappings = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING);
+        // Add the first identity matrix into the bone matrix data
+        boneMatrixData.emplace_back(SHMatrix::Identity);
+      }
 
       // - Material Properties Data
+      auto const& descMappings = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING);
       const Handle<SHShaderBlockInterface> SHADER_INFO = pipeline->GetPipelineLayout()->GetShaderBlockInterface
       (
-        descMappings.at(SHPredefinedDescriptorTypes::MATERIALS),
-        SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA,
+        descMappings.at(SHPredefinedDescriptorTypes::PER_INSTANCE_BATCH),
+        SHGraphicsConstants::DescriptorSetBindings::PER_INST_MATERIAL_DATA,
         vk::ShaderStageFlagBits::eFragment
       );
       const bool EMPTY_MAT_PROPS = !SHADER_INFO;
@@ -444,13 +539,13 @@ namespace SHADE
         if (CURR_INSTANCES > 0)
         {
           drawData.emplace_back(vk::DrawIndexedIndirectCommand
-           {
-               .indexCount = subBatch.Mesh->IndexCount,
-               .instanceCount = CURR_INSTANCES,
-               .firstIndex = subBatch.Mesh->FirstIndex,
-               .vertexOffset = subBatch.Mesh->FirstVertex,
-               .firstInstance = nextInstanceIndex
-           });
+          {
+              .indexCount = subBatch.Mesh->IndexCount,
+              .instanceCount = CURR_INSTANCES,
+              .firstIndex = subBatch.Mesh->FirstIndex,
+              .vertexOffset = subBatch.Mesh->FirstVertex,
+              .firstInstance = nextInstanceIndex
+          });
         }
         nextInstanceIndex += CURR_INSTANCES;
 
@@ -503,9 +598,36 @@ namespace SHADE
             {
               SHLOG_WARNING("[SHBatch] Entity with a missing SHRenderable found!");
             }
-            //propsCurrPtr += singleMatPropAlignedSize;
             propsCurrPtr += singleMatPropSize;
           }
+
+          // Bone Data
+          if (isAnimated)
+          {
+            // Mark start
+            boneMatrixIndices.emplace_back(static_cast<uint32_t>(boneMatrixData.size()));
+
+            auto animator = SHComponentManager::GetComponent_s<SHAnimatorComponent>(rendId);
+            auto mesh = renderable->GetMesh();
+            const int BONE_COUNT = static_cast<int>(mesh->BoneCount);
+            int extraMatricesToAdd = BONE_COUNT;
+            if (animator)
+            {
+              // Add matrices
+              const auto& MATRICES = animator->GetBoneMatrices();
+              if (MATRICES.size() <= BONE_COUNT)
+              {
+                boneMatrixData.insert(boneMatrixData.end(), MATRICES.cbegin(), MATRICES.cend());
+                extraMatricesToAdd = std::max({0, BONE_COUNT - static_cast<int>(MATRICES.size())});
+              }
+            }
+
+            // If we need to patch up with more matrices, add it
+            if (extraMatricesToAdd > 0)
+            {
+              boneMatrixData.insert(boneMatrixData.end(), extraMatricesToAdd, SHMatrix::Identity);
+            }
+          }
         }
       }
 
@@ -540,8 +662,19 @@ namespace SHADE
         BuffUsage::eVertexBuffer,
         "Batch Instance Data Buffer"
       );
-      // - Material Properties Buffer
-      rebuildMaterialBuffers(frameIndex, descPool);
+      // - Bone Matrix Indices
+      if (isAnimated && !boneMatrixIndices.empty())
+      {
+        const uint32_t BMI_DATA_BYTES = static_cast<uint32_t>(boneMatrixIndices.size() * sizeof(uint32_t));
+        SHVkUtil::EnsureBufferAndCopyHostVisibleData
+        (
+          device, boneMatrixFirstIndexBuffer[frameIndex], boneMatrixIndices.data(), BMI_DATA_BYTES,
+          BuffUsage::eVertexBuffer,
+          "Batch Instance Bone Matrix First Index Buffer"
+        );
+      }
+      // - Material and bone buffers/descriptor sets
+      rebuildDescriptorSetBuffers(frameIndex, descPool);
     }
 
     // Mark this frame as no longer dirty
@@ -551,7 +684,7 @@ namespace SHADE
   /*---------------------------------------------------------------------------------*/
   /* SHBatch - Usage Functions                                                       */
   /*---------------------------------------------------------------------------------*/
-  void SHBatch::Draw(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex, bool bindBatchPipeline/* = true*/)
+  void SHBatch::Draw(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex, bool bindBatchPipeline)
   {
     if (frameIndex >= SHGraphicsConstants::NUM_FRAME_BUFFERS)
     {
@@ -564,7 +697,11 @@ namespace SHADE
       return;
 
     // Bind all required objects before drawing
-    static std::array<uint32_t, 1> dynamicOffset{ 0 };
+    std::vector<uint32_t> dynamicOffset{ 0 };
+    if (isAnimated && !boneMatrixData.empty())
+    {
+      dynamicOffset.emplace_back(0);
+    }
     cmdBuffer->BeginLabeledSegment("SHBatch for Pipeline #" + std::to_string(pipeline.GetId().Data.Index));
 
     if (bindBatchPipeline)
@@ -572,16 +709,24 @@ namespace SHADE
 
     cmdBuffer->BindVertexBuffer(SHGraphicsConstants::VertexBufferBindings::TRANSFORM, transformDataBuffer[frameIndex], 0);
     cmdBuffer->BindVertexBuffer(SHGraphicsConstants::VertexBufferBindings::INTEGER_DATA, instancedIntegerBuffer[frameIndex], 0);
-    if (matPropsDescSet[frameIndex])
+    if (isAnimated && boneMatrixFirstIndexBuffer[frameIndex])
     {
-      auto const& descMappings = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING);
+      cmdBuffer->BindVertexBuffer(SHGraphicsConstants::VertexBufferBindings::BONE_MATRIX_FIRST_INDEX, boneMatrixFirstIndexBuffer[frameIndex], 0);
+    }
+    else
+    {
+      // HACK: Bind the transform buffer instead since we won't use it anyways, but we must bind something
+      cmdBuffer->BindVertexBuffer(SHGraphicsConstants::VertexBufferBindings::BONE_MATRIX_FIRST_INDEX, transformDataBuffer[frameIndex], 0);
+    }
 
+    auto const& descMappings = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING);
+    if (instanceDataDescSet[frameIndex])
+    {
       cmdBuffer->BindDescriptorSet
-      (
-        matPropsDescSet[frameIndex],
+      ( 
+        instanceDataDescSet[frameIndex],
         SH_PIPELINE_TYPE::GRAPHICS,
-        //SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE,
-        descMappings.at(SHPredefinedDescriptorTypes::MATERIALS),
+        descMappings.at(SHPredefinedDescriptorTypes::PER_INSTANCE_BATCH),
         dynamicOffset
       );
     }
@@ -624,49 +769,128 @@ namespace SHADE
     isCPUBuffersDirty = true;
   }
 
-  void SHBatch::rebuildMaterialBuffers(uint32_t frameIndex, Handle<SHVkDescriptorPool> descPool)
+  void SHBatch::rebuildDescriptorSetBuffers(uint32_t frameIndex, Handle<SHVkDescriptorPool> descPool)
   {
-    if (matPropsData && !drawData.empty())
-    {
-      SHVkUtil::EnsureBufferAndCopyHostVisibleData
-      (
-        device, matPropsBuffer[frameIndex], matPropsData.get(), static_cast<uint32_t>(matPropsDataSize),
-        vk::BufferUsageFlagBits::eStorageBuffer,
-        "Batch Material Data"
-      );
+    // Using Declarations and constants
+    using BuffUsage = vk::BufferUsageFlagBits;
+    using PreDefDescLayoutType = SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes;
+    
 
-      if (!matPropsDescSet[frameIndex])
+    /* Create Descriptor Sets if Needed */
+    PreDefDescLayoutType layoutTypes = {};
+    if (matPropsData)
+    {
+      layoutTypes = PreDefDescLayoutType::MATERIALS;
+    }
+    if (!boneMatrixData.empty())
+    {
+      layoutTypes = PreDefDescLayoutType::MATERIAL_AND_BONES;
+    }
+
+    const bool MUST_BUILD_BONE_DESC = isAnimated && !boneMatrixData.empty();
+
+    if (matPropsData || MUST_BUILD_BONE_DESC)
+    {
+      // Make sure that we have a descriptor set if we don't already have one
+      if (!instanceDataDescSet[frameIndex])
       {
-        matPropsDescSet[frameIndex] = descPool->Allocate
+        instanceDataDescSet[frameIndex] = descPool->Allocate
         (
-          SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::MATERIALS),
+          SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(layoutTypes),
           { 0 }
         );
 #ifdef _DEBUG
-        const auto& DESC_SETS = matPropsDescSet[frameIndex]->GetVkHandle();
+        const auto& DESC_SETS = instanceDataDescSet[frameIndex]->GetVkHandle();
         for (auto descSet : DESC_SETS)
         {
           SET_VK_OBJ_NAME(device, vk::ObjectType::eDescriptorSet, descSet, "[Descriptor Set] Batch Material Data");
         }
 #endif
       }
+    }
 
-      static constexpr uint32_t MATERIAL_DESC_SET_INDEX = 0;
+    /* Material Data */
+    if (matPropsData && !drawData.empty())
+    {
+      // Update GPU buffer
+      SHVkUtil::EnsureBufferAndCopyHostVisibleData
+      (
+        device, matPropsBuffer[frameIndex], matPropsData.get(), static_cast<uint32_t>(matPropsDataSize),
+        BuffUsage::eStorageBuffer,
+        "Batch Material Data"
+      );
 
+      // Update descriptor set buffer
       std::array<Handle<SHVkBuffer>, 1>  bufferList = { matPropsBuffer[frameIndex] };
-      matPropsDescSet[frameIndex]->ModifyWriteDescBuffer
+      instanceDataDescSet[frameIndex]->ModifyWriteDescBuffer
       (
         MATERIAL_DESC_SET_INDEX,
-        SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA,
+        SHGraphicsConstants::DescriptorSetBindings::PER_INST_MATERIAL_DATA,
         bufferList,
         0, static_cast<uint32_t>(matPropsDataSize)
       );
-      matPropsDescSet[frameIndex]->UpdateDescriptorSetBuffer
+
+      // Update the descriptor set buffer
+      instanceDataDescSet[frameIndex]->UpdateDescriptorSetBuffer
       (
         MATERIAL_DESC_SET_INDEX,
-        SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA
+        SHGraphicsConstants::DescriptorSetBindings::PER_INST_MATERIAL_DATA
       );
     }
+
+    /* Animation Bone Data */
+    if (MUST_BUILD_BONE_DESC)
+    {
+      rebuildBoneMatrixDescSetBuffer(frameIndex);
+    }
   }
 
+  void SHBatch::rebuildBoneMatrixDescSetBuffer(uint32_t frameIndex)
+  {
+    using BuffUsage = vk::BufferUsageFlagBits;
+    // Update GPU Buffers
+    const uint32_t BONE_MTX_DATA_BYTES = static_cast<uint32_t>(boneMatrixData.size() * sizeof(SHMatrix));
+    SHVkUtil::EnsureBufferAndCopyHostVisibleData
+    (
+      device, boneMatrixBuffer[frameIndex], boneMatrixData.data(), BONE_MTX_DATA_BYTES,
+      BuffUsage::eStorageBuffer,
+      "Batch Bone Matrix Buffer"
+    );
+
+    // Update descriptor set buffer
+    std::array<Handle<SHVkBuffer>, 1>  bufferList = { boneMatrixBuffer[frameIndex] };
+    instanceDataDescSet[frameIndex]->ModifyWriteDescBuffer
+    (
+      MATERIAL_DESC_SET_INDEX,
+      SHGraphicsConstants::DescriptorSetBindings::PER_INST_BONE_DATA,
+      bufferList,
+      0, 
+      static_cast<uint32_t>(boneMatrixData.size() * sizeof(SHMatrix))
+    );
+
+    // Update the descriptor set buffer
+    instanceDataDescSet[frameIndex]->UpdateDescriptorSetBuffer
+    (
+      MATERIAL_DESC_SET_INDEX,
+      SHGraphicsConstants::DescriptorSetBindings::PER_INST_BONE_DATA
+    );
+  }
+
+  bool SHBatch::checkIfIsAnimatedPipeline(Handle<SHVkPipeline> pipeline)
+  {
+    if (!pipeline || !pipeline->GetPipelineLayout())
+      return false;
+
+    // Grab the pipeline descriptor set layouts
+    auto pipelineDescLayouts = pipeline->GetPipelineLayout()->GetDescriptorSetLayoutsPipeline();
+
+    // Check if they contain the material and bones layout, that indicates it is
+    using GfxPreDef     = SHGraphicsPredefinedData;
+    using GfxPreDefType = GfxPreDef::PredefinedDescSetLayoutTypes;
+    const Handle<SHVkDescriptorSetLayout> BONE_DESC_SET_LAYOUT = GfxPreDef::GetPredefinedDescSetLayouts(GfxPreDefType::MATERIAL_AND_BONES)[0];
+    return std::find_if(pipelineDescLayouts.begin(), pipelineDescLayouts.end(), [BONE_DESC_SET_LAYOUT](Handle<SHVkDescriptorSetLayout> layout)
+    {
+      return BONE_DESC_SET_LAYOUT == layout;
+    }) != pipelineDescLayouts.end();
+  }
 }

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

@@ -27,116 +27,132 @@ of DigiPen Institute of Technology is prohibited.
 
 namespace SHADE
 {
+  /*-----------------------------------------------------------------------------------*/
+  /* Forward Declarations                                                              */
+  /*-----------------------------------------------------------------------------------*/
+  class SHVkBuffer;
+  class SHVkCommandBuffer;
+  class SHVkPipeline;
+  class SHMesh;
+  class SHRenderable;
+  class SHVkLogicalDevice;
+  class SHMaterialInstance;
+  class SHVkDescriptorSetGroup;
+  class SHVkDescriptorPool;
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Type Definitions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+  /*************************************************************************************/
+  /*!
+    \brief
+      Describes a segment of the sub batch operation.
+  */
+  /*************************************************************************************/
+  struct SHSubBatch
+  {
+  public:
     /*---------------------------------------------------------------------------------*/
-    /* Forward Declarations                                                            */
+    /* Data Members                                                                    */
     /*---------------------------------------------------------------------------------*/
-    class SHVkBuffer;
-    class SHVkCommandBuffer;
-    class SHVkPipeline;
-    class SHMesh;
-    class SHRenderable;
-    class SHVkLogicalDevice;
-    class SHMaterialInstance;
-    class SHVkDescriptorSetGroup;
-    class SHVkDescriptorPool;
+    Handle<SHMesh> Mesh;
+    std::unordered_set<EntityID> Renderables;
+  };
+  /*************************************************************************************/
+  /*!
+    \brief
+      Describes a segment of the sub batch operation.
+  */
+  /*************************************************************************************/
+  class SHBatch
+  {
+  public:
+    /*---------------------------------------------------------------------------------*/
+    /* Constructor/Destructors                                                         */
+    /*---------------------------------------------------------------------------------*/
+    SHBatch(Handle<SHVkPipeline> pipeline);
+    SHBatch(const SHBatch&) = delete;
+    SHBatch(SHBatch&& rhs);
+    SHBatch& operator=(const SHBatch&) = delete;
+    SHBatch& operator=(SHBatch&& rhs);
+    ~SHBatch();
 
     /*---------------------------------------------------------------------------------*/
-    /* Type Definitions                                                                */
+    /* Usage Functions                                                                 */
     /*---------------------------------------------------------------------------------*/
-    /***********************************************************************************/
-    /*!
-      \brief
-        Describes a segment of the sub batch operation.
-    */
-    /***********************************************************************************/
-    struct SHSubBatch
-    {
-      public:
-        /*-----------------------------------------------------------------------------*/
-        /* Data Members                                                                */
-        /*-----------------------------------------------------------------------------*/
-        Handle<SHMesh> Mesh;
-        std::unordered_set<EntityID> Renderables;
-    };
-    /***********************************************************************************/
-    /*!
-      \brief
-        Describes a segment of the sub batch operation.
-    */
-    /***********************************************************************************/
-    class SHBatch
-    {
-      public:
-        /*-----------------------------------------------------------------------------*/
-        /* Constructor/Destructors                                                     */
-        /*-----------------------------------------------------------------------------*/
-        SHBatch(Handle<SHVkPipeline> pipeline);
-        SHBatch(const SHBatch&) = delete;
-        SHBatch(SHBatch&& rhs);
-        SHBatch& operator=(const SHBatch&) = delete;
-        SHBatch& operator=(SHBatch&& rhs);
-        ~SHBatch();
+    void Add(const SHRenderable* renderable);
+    void Remove(const SHRenderable* renderable);
+    void Clear();
+    void UpdateMaterialBuffer(uint32_t frameIndex, Handle<SHVkDescriptorPool> descPool);
+    void UpdateTransformBuffer(uint32_t frameIndex);
+    void UpdateInstancedIntegerBuffer(uint32_t frameIndex);
+    void UpdateAnimationBuffer(uint32_t frameIndex);
+    void Build(Handle<SHVkLogicalDevice> device, Handle<SHVkDescriptorPool> descPool, uint32_t frameIndex);
+    void Draw(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex, bool bindBatchPipeline);
 
-        /*-----------------------------------------------------------------------------*/
-        /* Usage Functions                                                             */
-        /*-----------------------------------------------------------------------------*/
-        void Add(const SHRenderable* renderable);
-        void Remove(const SHRenderable* renderable);
-        void Clear();
-        void UpdateMaterialBuffer(uint32_t frameIndex, Handle<SHVkDescriptorPool> descPool);
-        void UpdateTransformBuffer(uint32_t frameIndex);
-        void UpdateInstancedIntegerBuffer(uint32_t frameIndex);
-        void Build(Handle<SHVkLogicalDevice> device, Handle<SHVkDescriptorPool> descPool, uint32_t frameIndex)  ;
-        void Draw(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex, bool bindBatchPipeline = true);
+    /*---------------------------------------------------------------------------------*/
+    /* Getter Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    Handle<SHVkPipeline> GetPipeline() const noexcept { return pipeline; };
+    bool IsEmpty() const noexcept { return subBatches.empty(); }
+    Handle<SHVkBuffer> GetTransformBuffer(uint32_t frameIndex) const noexcept;
+    Handle<SHVkBuffer> GetMDIBuffer(uint32_t frameIndex) const noexcept;
+    bool IsAnimated() const noexcept { return isAnimated; }
 
-        /*-----------------------------------------------------------------------------*/
-        /* Getter Functions                                                            */
-        /*-----------------------------------------------------------------------------*/
-        Handle<SHVkPipeline> GetPipeline() const noexcept { return pipeline; };
-        bool IsEmpty() const noexcept { return subBatches.empty(); }
-        Handle<SHVkBuffer> GetTransformBuffer(uint32_t frameIndex) const noexcept;
-        Handle<SHVkBuffer> GetMDIBuffer(uint32_t frameIndex) const noexcept;
+  private:
+    /*---------------------------------------------------------------------------------*/
+    /* Type Definition                                                                 */
+    /*---------------------------------------------------------------------------------*/
+    using TripleBool    = std::array<bool, SHGraphicsConstants::NUM_FRAME_BUFFERS>;
+    using TripleBuffer  = std::array<Handle<SHVkBuffer>, SHGraphicsConstants::NUM_FRAME_BUFFERS>;
+    using TripleDescSet = std::array<Handle<SHVkDescriptorSetGroup>, SHGraphicsConstants::NUM_FRAME_BUFFERS>;
+    
+    /*---------------------------------------------------------------------------------*/
+    /* Constants                                                                       */
+    /*---------------------------------------------------------------------------------*/
+    static constexpr uint32_t MATERIAL_DESC_SET_INDEX = 0;
 
-    private:
-        /*-----------------------------------------------------------------------------*/
-        /* Type Definition                                                             */
-        /*-----------------------------------------------------------------------------*/
-        using TripleBool    = std::array<bool, SHGraphicsConstants::NUM_FRAME_BUFFERS>;
-        using TripleBuffer  = std::array<Handle<SHVkBuffer>, SHGraphicsConstants::NUM_FRAME_BUFFERS>;
-        using TripleDescSet = std::array<Handle<SHVkDescriptorSetGroup>, SHGraphicsConstants::NUM_FRAME_BUFFERS>;
+    /*---------------------------------------------------------------------------------*/
+    /* Data Members                                                                    */
+    /*---------------------------------------------------------------------------------*/
+    // Resources
+    Handle<SHVkLogicalDevice>                      device;
+    // Config
+    bool                                           isAnimated;                 // Whether the material supports animation
+    // Batch Properties
+    Handle<SHVkPipeline>                           pipeline;
+    std::unordered_set<Handle<SHMaterialInstance>> referencedMatInstances;
+    TripleBool                                     matBufferDirty;
+    // Batch Tree
+    std::vector<SHSubBatch>                        subBatches;
+    TripleBool                                     isDirty;
+    // CPU Buffers                                 
+    std::vector<vk::DrawIndexedIndirectCommand>    drawData;
+    std::vector<SHMatrix>                          transformData;
+    std::vector<SHInstancedIntegerData>            instancedIntegerData;
+    std::unique_ptr<char>                          matPropsData;
+    Byte                                           matPropsDataSize = 0;
+    Byte                                           singleMatPropAlignedSize = 0;
+    Byte                                           singleMatPropSize = 0;
+    std::vector<SHMatrix>                          boneMatrixData;             // 0th element is always an identity matrix
+    std::vector<uint32_t>                          boneMatrixIndices;
+    bool                                           isCPUBuffersDirty = true;
+    // GPU Buffers                                 
+    TripleBuffer                                   drawDataBuffer;
+    TripleBuffer                                   transformDataBuffer;
+    TripleBuffer                                   instancedIntegerBuffer;
+    TripleBuffer                                   matPropsBuffer;
+    TripleBuffer                                   boneMatrixBuffer;
+    TripleBuffer                                   boneMatrixFirstIndexBuffer; // Instanced buffer, indicates where the first bone matrix is
+    TripleDescSet                                  instanceDataDescSet;
 
-        /*-----------------------------------------------------------------------------*/
-        /* Data Members                                                                */
-        /*-----------------------------------------------------------------------------*/
-        // Resources
-        Handle<SHVkLogicalDevice>                      device;
-        // Batch Properties
-        Handle<SHVkPipeline>                           pipeline;
-        std::unordered_set<Handle<SHMaterialInstance>> referencedMatInstances;
-        TripleBool                                     matBufferDirty;
-        // Batch Tree
-        std::vector<SHSubBatch>                        subBatches;
-        TripleBool                                     isDirty;
-        // CPU Buffers                                 
-        std::vector<vk::DrawIndexedIndirectCommand>    drawData;
-        std::vector<SHMatrix>                          transformData;
-        std::vector<SHInstancedIntegerData>            instancedIntegerData;
-        std::unique_ptr<char>                          matPropsData;
-        Byte                                           matPropsDataSize          = 0;
-        Byte                                           singleMatPropAlignedSize  = 0;
-		    Byte                                           singleMatPropSize         = 0;
-        bool isCPUBuffersDirty                                                   = true;
-        // GPU Buffers                                 
-        TripleBuffer                                   drawDataBuffer;
-        TripleBuffer                                   transformDataBuffer;
-        TripleBuffer                                   instancedIntegerBuffer;
-        TripleBuffer                                   matPropsBuffer;
-        TripleDescSet                                  matPropsDescSet;
+    /*-----------------------------------------------------------------------------*/
+    /* Helper Functions                                                            */
+    /*-----------------------------------------------------------------------------*/
+    void setAllDirtyFlags();
+    void rebuildDescriptorSetBuffers(uint32_t frameIndex, Handle<SHVkDescriptorPool> descPool);
+    void rebuildBoneMatrixDescSetBuffer(uint32_t frameIndex);
+    static bool checkIfIsAnimatedPipeline(Handle<SHVkPipeline> pipeline);
 
-        /*-----------------------------------------------------------------------------*/
-        /* Helper Functions                                                            */
-        /*-----------------------------------------------------------------------------*/
-        void setAllDirtyFlags();
-        void rebuildMaterialBuffers(uint32_t frameIndex, Handle<SHVkDescriptorPool> descPool);
-    };
+  };
 }

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

@@ -94,6 +94,7 @@ namespace SHADE
     {
       batch.UpdateMaterialBuffer(frameIndex, descPool);
       batch.UpdateTransformBuffer(frameIndex);
+      batch.UpdateAnimationBuffer(frameIndex);
       batch.UpdateInstancedIntegerBuffer(frameIndex);
     }
   }

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

@@ -23,13 +23,19 @@ namespace SHADE
 
   void SHGraphicsPredefinedData::InitDescMappings(void) noexcept
   {
-
     perSystemData[SHUtilities::ConvertEnum(SystemType::BATCHING)].descMappings.AddMappings
     ({
-      {SHPredefinedDescriptorTypes::STATIC_DATA, 0},
-      {SHPredefinedDescriptorTypes::CAMERA,      1},
-      {SHPredefinedDescriptorTypes::MATERIALS,   2},
-    });
+      {SHPredefinedDescriptorTypes::STATIC_DATA,        0},
+      {SHPredefinedDescriptorTypes::CAMERA,             1},
+      {SHPredefinedDescriptorTypes::PER_INSTANCE_BATCH, 2},
+      });
+
+    perSystemData[SHUtilities::ConvertEnum(SystemType::BATCHING_ANIM)].descMappings.AddMappings
+    ({
+      {SHPredefinedDescriptorTypes::STATIC_DATA,             0},
+      {SHPredefinedDescriptorTypes::CAMERA,                  1},
+      {SHPredefinedDescriptorTypes::PER_INSTANCE_ANIM_BATCH, 2},
+      });
 
     perSystemData[SHUtilities::ConvertEnum(SystemType::TEXT_RENDERING)].descMappings.AddMappings
     ({
@@ -50,9 +56,13 @@ namespace SHADE
 
   void SHGraphicsPredefinedData::InitDummyPipelineLayouts(Handle<SHVkLogicalDevice> logicalDevice) noexcept
   {
-    perSystemData[SHUtilities::ConvertEnum(SystemType::BATCHING)].dummyPipelineLayout =       logicalDevice->CreatePipelineLayoutDummy(SHPipelineLayoutParamsDummy{ perSystemData[SHUtilities::ConvertEnum(SystemType::BATCHING)].descSetLayouts });
-    perSystemData[SHUtilities::ConvertEnum(SystemType::TEXT_RENDERING)].dummyPipelineLayout = logicalDevice->CreatePipelineLayoutDummy(SHPipelineLayoutParamsDummy{ perSystemData[SHUtilities::ConvertEnum(SystemType::TEXT_RENDERING)].descSetLayouts });
-    perSystemData[SHUtilities::ConvertEnum(SystemType::RENDER_GRAPH_NODE_COMPUTE)].dummyPipelineLayout = logicalDevice->CreatePipelineLayoutDummy(SHPipelineLayoutParamsDummy{ perSystemData[SHUtilities::ConvertEnum(SystemType::RENDER_GRAPH_NODE_COMPUTE)].descSetLayouts });
+    for (int i = 0; i < SYSTEM_TYPE_COUNT; ++i)
+    {
+      perSystemData[i].dummyPipelineLayout = logicalDevice->CreatePipelineLayoutDummy
+      (
+        SHPipelineLayoutParamsDummy { perSystemData[i].descSetLayouts }
+      );
+    }
   }
 
   /*-----------------------------------------------------------------------------------*/
@@ -124,8 +134,8 @@ namespace SHADE
     SHVkDescriptorSetLayout::Binding materialDataBinding
     {
       .Type = vk::DescriptorType::eStorageBufferDynamic,
-      .Stage = vk::ShaderStageFlagBits::eFragment | vk::ShaderStageFlagBits::eVertex,
-      .BindPoint = SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA,
+      .Stage = vk::ShaderStageFlagBits::eFragment,
+      .BindPoint = SHGraphicsConstants::DescriptorSetBindings::PER_INST_MATERIAL_DATA,
       .DescriptorCount = 1,
     };
     Handle<SHVkDescriptorSetLayout> materialDataPerInstanceLayout = logicalDevice->CreateDescriptorSetLayout({ materialDataBinding });
@@ -165,6 +175,17 @@ namespace SHADE
     // For global data (generic data and textures)
     Handle<SHVkDescriptorSetLayout> shadowMapDescLayout = logicalDevice->CreateDescriptorSetLayout({ shadowMapBinding });
     SET_VK_OBJ_NAME(logicalDevice, vk::ObjectType::eDescriptorSetLayout, shadowMapDescLayout->GetVkHandle(), "[Descriptor Set Layout] Shadow Maps");
+    
+    // For per instance data (transforms, materials, etc.)
+    SHVkDescriptorSetLayout::Binding boneDataBinding
+    {
+      .Type = vk::DescriptorType::eStorageBufferDynamic,
+      .Stage = vk::ShaderStageFlagBits::eVertex,
+      .BindPoint = SHGraphicsConstants::DescriptorSetBindings::PER_INST_BONE_DATA,
+      .DescriptorCount = 1,
+    };
+    Handle<SHVkDescriptorSetLayout> materialBoneDataPerInstanceLayout = logicalDevice->CreateDescriptorSetLayout({ materialDataBinding, boneDataBinding });
+    SET_VK_OBJ_NAME(logicalDevice, vk::ObjectType::eDescriptorSetLayout, materialBoneDataPerInstanceLayout->GetVkHandle(), "[Descriptor Set Layout] Material and Bone Globals");
 
     predefinedLayouts.push_back(staticGlobalLayout);
     predefinedLayouts.push_back(lightDataDescSetLayout);
@@ -172,6 +193,7 @@ namespace SHADE
     predefinedLayouts.push_back(materialDataPerInstanceLayout);
     predefinedLayouts.push_back(fontDataDescSetLayout);
     predefinedLayouts.push_back(shadowMapDescLayout);
+    predefinedLayouts.push_back(materialBoneDataPerInstanceLayout);
 
     perSystemData[SHUtilities::ConvertEnum(SystemType::BATCHING)].descSetLayouts = GetPredefinedDescSetLayouts
     (
@@ -180,6 +202,13 @@ namespace SHADE
       SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::MATERIALS
     );
 
+    perSystemData[SHUtilities::ConvertEnum(SystemType::BATCHING_ANIM)].descSetLayouts = GetPredefinedDescSetLayouts
+    (
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::STATIC_DATA |
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::CAMERA |
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::MATERIAL_AND_BONES
+    );
+
     perSystemData[SHUtilities::ConvertEnum(SystemType::TEXT_RENDERING)].descSetLayouts = GetPredefinedDescSetLayouts
     (
       SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::STATIC_DATA |
@@ -197,12 +226,15 @@ namespace SHADE
 
   void SHGraphicsPredefinedData::InitPredefinedVertexInputState(void) noexcept
   {
-    defaultVertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::FLOAT_3D) }); // positions at binding 0
-    defaultVertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::FLOAT_2D) }); // UVs at binding 1
-    defaultVertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::FLOAT_3D) }); // Normals at binding 2
-    defaultVertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::FLOAT_3D) }); // Tangents at binding 3
-    defaultVertexInputState.AddBinding(true, true,   { SHVertexAttribute(SHAttribFormat::MAT_4D)   }); // Transform at binding 4 - 7 (4 slots)
-    defaultVertexInputState.AddBinding(true, true,   { SHVertexAttribute(SHAttribFormat::UINT32_2D) }); // Instanced integer data at index 8
+    defaultVertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::FLOAT_3D)  }); // Attribute positions at binding 0
+    defaultVertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::FLOAT_2D)  }); // Attribute UVs at binding 1
+    defaultVertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::FLOAT_3D)  }); // Attribute Normals at binding 2
+    defaultVertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::FLOAT_3D)  }); // Attribute Tangents at binding 3
+    defaultVertexInputState.AddBinding(true , true , { SHVertexAttribute(SHAttribFormat::MAT_4D)    }); // Instanced Transform at binding 4 - 7 (4 slots)
+    defaultVertexInputState.AddBinding(true , true , { SHVertexAttribute(SHAttribFormat::UINT32_2D) }); // Instanced integer data at index 8
+    defaultVertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::UINT32_4D) }); // Attribute bone indices at index 9
+    defaultVertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::FLOAT_4D)  }); // Attribute bone weights at index 10
+    defaultVertexInputState.AddBinding(true , true , { SHVertexAttribute(SHAttribFormat::UINT32_1D) }); // Instance bone matrix first index at index 11
 
     shadowMapVertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::FLOAT_3D)});
     shadowMapVertexInputState.AddBinding(true, true, { SHVertexAttribute(SHAttribFormat::MAT_4D) }, 4, 4); // Transform at binding 4 - 7 (4 slots)
@@ -256,12 +288,24 @@ namespace SHADE
     return static_cast<SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes>(static_cast<uint64_t>(lhs) | static_cast<uint64_t>(rhs));
   }
 
+  SHADE::SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes& operator|=(SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes& lhs, SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes rhs) noexcept
+  {
+    lhs = lhs | rhs;
+    return lhs;
+  }
+
   SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes operator&(SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes lhs, SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes rhs) noexcept
   {
     return static_cast<SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes>(static_cast<uint64_t>(lhs) & static_cast<uint64_t>(rhs));
 
   }
 
+  SHADE::SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes& operator&=(SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes& lhs, SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes rhs) noexcept
+  {
+    lhs = lhs & rhs;
+    return lhs;
+  }
+
   //SHGraphicsPredefinedData::PerSystem const& SHGraphicsPredefinedData::GetBatchingSystemData(void) noexcept
   //{
   //  return batchingSystemData;

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

@@ -23,21 +23,24 @@ namespace SHADE
     // This enum is mainly to initialize a bit field to retrieve bit fields from SHPRedefinedData
     enum class PredefinedDescSetLayoutTypes : uint64_t
     {
-      STATIC_DATA = 0x01,
-      LIGHTS = 0x02,
-      CAMERA = 0x04,
-      MATERIALS = 0x08,
-      FONT = 0x10,
-      SHADOW = 0x20,
+      STATIC_DATA          = 0b00000001,
+      LIGHTS               = 0b00000010,
+      CAMERA               = 0b00000100,
+      MATERIALS            = 0b00001000,
+      FONT                 = 0b00010000,
+      SHADOW               = 0b00100000,
+      MATERIAL_AND_BONES   = 0b01000000
     };
 
     enum class SystemType
     {
       BATCHING = 0,
+      BATCHING_ANIM,
       TEXT_RENDERING,
       RENDER_GRAPH_NODE_COMPUTE,
       NUM_TYPES
     };
+    static constexpr int SYSTEM_TYPE_COUNT = static_cast<int>(SystemType::NUM_TYPES);
 
     struct PerSystem
     {
@@ -103,5 +106,7 @@ namespace SHADE
 
   };
   SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes operator| (SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes lhs, SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes rhs) noexcept;
+  SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes& operator|=(SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes& lhs, SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes rhs) noexcept;
   SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes operator& (SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes lhs, SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes rhs) noexcept;
+  SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes& operator&=(SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes& lhs, SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes rhs) noexcept;
 }

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

@@ -11,7 +11,8 @@ namespace SHADE
     STATIC_DATA,
     LIGHTS,
     CAMERA,
-    MATERIALS,
+    PER_INSTANCE_BATCH,
+    PER_INSTANCE_ANIM_BATCH,
     FONT,
     RENDER_GRAPH_NODE_COMPUTE_RESOURCE,
     RENDER_GRAPH_RESOURCE,

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

@@ -14,7 +14,7 @@ of DigiPen Institute of Technology is prohibited.
 // STL Includes
 #include <algorithm>
 // Project Includes
-#include "Assets/Asset Types/SHModelAsset.h"
+#include "Assets/Asset Types/Models/SHModelAsset.h"
 #include "../Meshes/SHPrimitiveGenerator.h"
 #include "ECS_Base/Managers/SHSystemManager.h"
 #include "SHGraphicsSystem.h"

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

@@ -13,6 +13,7 @@ of DigiPen Institute of Technology is prohibited.
 
 // STL Includes
 #include <cstdint>
+#include <string>
 
 namespace SHADE
 {
@@ -114,7 +115,14 @@ namespace SHADE
       static constexpr std::string_view DEFERRED_COMPOSITE_COMPUTE = "Deferred Composite";
 
 
+      static constexpr std::string_view GBUFFER_WRITE_SUBPASS = "G-Buffer Write";
+      static constexpr std::string_view UI_SUBPASS = "UI";
 
+      static constexpr std::array USABLE_SUBPASSES = 
+      {
+        GBUFFER_WRITE_SUBPASS,
+        UI_SUBPASS
+      };
     };
 
     struct DescriptorSetBindings
@@ -161,7 +169,15 @@ namespace SHADE
           DescriptorSet binding for per instance material values.
       */
       /***************************************************************************/
-      static constexpr uint32_t BATCHED_PER_INST_DATA = 0;
+      static constexpr uint32_t PER_INST_MATERIAL_DATA = 0;
+
+      /***************************************************************************/
+      /*!
+        \brief
+          DescriptorSet binding for per instance bone values.
+      */
+      /***************************************************************************/
+      static constexpr uint32_t PER_INST_BONE_DATA = 1;
 
       /***************************************************************************/
       /*!
@@ -191,6 +207,14 @@ namespace SHADE
       static constexpr uint32_t SHADOW_MAP_IMAGE_SAMPLER_DATA = 0;
 
 
+      /***************************************************************************/
+      /*!
+        \brief
+          Descriptor set binding for bone matrix data.
+
+      */
+      /***************************************************************************/
+      static constexpr uint32_t BONE_MATRIX_DATA = 1;
     };
 
     struct VertexBufferBindings
@@ -237,6 +261,27 @@ namespace SHADE
       */
       /***************************************************************************/
       static constexpr uint32_t INTEGER_DATA = 5;
+      /***************************************************************************/
+      /*!
+        \brief
+          Vertex buffer bindings for the bone indices buffer.
+      */
+      /***************************************************************************/
+      static constexpr uint32_t BONE_INDICES = 6;
+      /***************************************************************************/
+      /*!
+        \brief
+          Vertex buffer bindings for the bone weights buffer.
+      */
+      /***************************************************************************/
+      static constexpr uint32_t BONE_WEIGHTS = 7;
+      /***************************************************************************/
+      /*!
+        \brief
+          Vertex buffer bindings for the bone matrix first index buffer.
+      */
+      /***************************************************************************/
+      static constexpr uint32_t BONE_MATRIX_FIRST_INDEX = 8;
 
       static constexpr uint32_t CALCULATED_GLYPH_POSITION = 0;
       static constexpr uint32_t GLYPH_INDEX = 1;

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

@@ -65,7 +65,7 @@ namespace SHADE
     #endif
 
     // Get Physical Device 
-    physicalDevice = SHVkInstance::CreatePhysicalDevice(SH_PHYSICAL_DEVICE_TYPE::BEST);
+    physicalDevice = SHVkInstance::CreatePhysicalDevice(SH_PHYSICAL_DEVICE_TYPE::DEDICATED);
     if (!physicalDevice->GetVkPhysicalDevice())
     {
       throw std::runtime_error("[Graphics System] No supported Vulkan 1.3 compatible GPU was detected!");
@@ -127,15 +127,19 @@ namespace SHADE
 
     SHFreetypeInstance::Init();
 
-    SHAssetManager::CompileAsset("../../Assets/Shaders/DeferredComposite_CS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/SSAO_CS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/SSAOBlur_CS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/PureCopy_CS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/TestCube_VS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/TestCube_FS.glsl", false);
+    //SHAssetManager::CompileAsset("../../Assets/Shaders/DeferredComposite_CS.glsl", false);
+    //SHAssetManager::CompileAsset("../../Assets/Shaders/SSAO_CS.glsl", false);
+    //SHAssetManager::CompileAsset("../../Assets/Shaders/SSAOBlur_CS.glsl", false);
+    //SHAssetManager::CompileAsset("../../Assets/Shaders/PureCopy_CS.glsl", false);
+    //SHAssetManager::CompileAsset("../../Assets/Shaders/TestCube_VS.glsl", false);
+    //SHAssetManager::CompileAsset("../../Assets/Shaders/TestCube_FS.glsl", false);
+    //SHAssetManager::CompileAsset("../../Assets/Shaders/UI_VS.glsl", false);
+    //SHAssetManager::CompileAsset("../../Assets/Shaders/UI_FS.glsl", false);
+    //SHAssetManager::CompileAsset("../../Assets/Shaders/Text_VS.glsl", false);
 
     // Load Built In Shaders
     static constexpr AssetID VS_DEFAULT    = 39210065;  defaultVertShader       = SHResourceManager::LoadOrGet<SHVkShaderModule>(VS_DEFAULT);
+    static constexpr AssetID VS_ANIM       = 47911992;  animtVertShader         = SHResourceManager::LoadOrGet<SHVkShaderModule>(VS_ANIM);
     static constexpr AssetID FS_DEFAULT    = 46377769;  defaultFragShader       = SHResourceManager::LoadOrGet<SHVkShaderModule>(FS_DEFAULT);
     static constexpr AssetID VS_DEBUG      = 48002439;  debugVertShader         = SHResourceManager::LoadOrGet<SHVkShaderModule>(VS_DEBUG);
     static constexpr AssetID FS_DEBUG      = 36671027;  debugFragShader         = SHResourceManager::LoadOrGet<SHVkShaderModule>(FS_DEBUG);
@@ -231,7 +235,7 @@ namespace SHADE
     /*-----------------------------------------------------------------------*/
     /* G-BUFFER SUBPASS INIT                                                 */
     /*-----------------------------------------------------------------------*/
-    auto gBufferSubpass = gBufferNode->AddSubpass("G-Buffer Write", worldViewport, worldRenderer);
+    auto gBufferSubpass = gBufferNode->AddSubpass(SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_WRITE_SUBPASS.data(), worldViewport, worldRenderer);
     gBufferSubpass->AddColorOutput("Position");
     gBufferSubpass->AddColorOutput("Entity ID");
     gBufferSubpass->AddColorOutput("Light Layer Indices");
@@ -240,6 +244,7 @@ namespace SHADE
     gBufferSubpass->AddColorOutput("Position World Space");
     gBufferSubpass->AddDepthOutput("Depth Buffer", SH_RENDER_GRAPH_RESOURCE_FLAGS::DEPTH_STENCIL);
 
+    usableSubpassesMapping.emplace (std::string (SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_WRITE_SUBPASS.data()), gBufferSubpass);
 
     /*-----------------------------------------------------------------------*/
     /* SSAO PASS AND DATA INIT                                               */
@@ -318,7 +323,7 @@ namespace SHADE
     /* SCREEN SPACE PASS                                                     */
     /*-----------------------------------------------------------------------*/
     auto screenSpaceNode = renderGraph->AddNode(SHGraphicsConstants::RenderGraphEntityNames::SCREEN_SPACE_PASS.data(), {"Scene", "Entity ID"}, {SHGraphicsConstants::RenderGraphEntityNames::DEFERRED_COMPOSITE_PASS.data(), SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_PASS.data(), SHGraphicsConstants::RenderGraphEntityNames::DEBUG_DRAW.data()});
-    auto uiSubpass = screenSpaceNode->AddSubpass("UI", worldViewport, screenRenderer);
+    auto uiSubpass = screenSpaceNode->AddSubpass(SHGraphicsConstants::RenderGraphEntityNames::UI_SUBPASS.data(), worldViewport, screenRenderer);
     uiSubpass->AddColorOutput("Scene");
     uiSubpass->AddColorOutput("Entity ID");
     uiSubpass->AddExteriorDrawCalls([=](Handle<SHVkCommandBuffer> cmdBuffer, Handle<SHRenderer> renderer, uint32_t frameIndex)
@@ -326,6 +331,8 @@ namespace SHADE
         textRenderingSubSystem->Render(cmdBuffer, renderer, frameIndex);
       });
 
+    usableSubpassesMapping.emplace(SHGraphicsConstants::RenderGraphEntityNames::UI_SUBPASS.data(), uiSubpass);
+
     /*-----------------------------------------------------------------------*/
     /* RENDER TO SWAPCHAIN IMAGE FOR PRESENT PASS                            */
     /*-----------------------------------------------------------------------*/
@@ -415,12 +422,12 @@ namespace SHADE
           .addressMode = vk::SamplerAddressMode::eClampToBorder,
         })
       );
-
+      
     textRenderingSubSystem = resourceManager.Create<SHTextRenderingSubSystem>();
 
     // initialize the text renderer
     auto uiNode = renderGraph->GetNode(SHGraphicsConstants::RenderGraphEntityNames::SCREEN_SPACE_PASS.data());
-    textRenderingSubSystem->Init(device, uiNode->GetRenderpass(), uiNode->GetSubpass("UI"), descPool, textVS, textFS);
+    textRenderingSubSystem->Init(device, uiNode->GetRenderpass(), uiNode->GetSubpass(SHGraphicsConstants::RenderGraphEntityNames::UI_SUBPASS), descPool, textVS, textFS);
 
     SHGlobalDescriptorSets::SetLightingSubSystem(lightingSubSystem);
 
@@ -447,9 +454,15 @@ namespace SHADE
     defaultMaterial = AddMaterial
     (
       defaultVertShader, defaultFragShader, 
-      renderGraph->GetNode(SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_PASS.data())->GetSubpass("G-Buffer Write")
+      renderGraph->GetNode(SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_PASS.data())->GetSubpass(SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_WRITE_SUBPASS)
     );
     defaultMaterial->SetProperty("data.textureIndex", defaultTexture->TextureArrayIndex);
+    defaultAnimMaterial = AddMaterial
+    (
+      animtVertShader, defaultFragShader,
+      renderGraph->GetNode("G-Buffer")->GetSubpass("G-Buffer Write")
+    );
+    defaultAnimMaterial->SetProperty("data.textureIndex", defaultTexture->TextureArrayIndex);
   }
 
 
@@ -525,6 +538,8 @@ namespace SHADE
       std::make_pair(meshLibrary.GetVertexTexCoordsBuffer(), SHGraphicsConstants::VertexBufferBindings::TEX_COORD),
       std::make_pair(meshLibrary.GetVertexNormalsBuffer(), SHGraphicsConstants::VertexBufferBindings::NORMAL),
       std::make_pair(meshLibrary.GetVertexTangentsBuffer(), SHGraphicsConstants::VertexBufferBindings::TANGENT),
+      std::make_pair(meshLibrary.GetVertexBoneIndicesBuffer(), SHGraphicsConstants::VertexBufferBindings::BONE_INDICES),
+      std::make_pair(meshLibrary.GetVertexBoneWeightsBuffer(), SHGraphicsConstants::VertexBufferBindings::BONE_WEIGHTS),
       std::make_pair(meshLibrary.GetIndexBuffer(), 0),
     };
 
@@ -564,32 +579,24 @@ namespace SHADE
       else
         renderer->UpdateData(frameIndex);
 #else
-      renderers[renIndex]->UpdateDataAndBind(frameIndex);
+      renderer->UpdateData(frameIndex);
 #endif
     }
 
-    if (SHInputManager::GetKeyDown(SHInputManager::SH_KEYCODE::B))
-    {
-      auto& lightComps = SHComponentManager::GetDense<SHLightComponent>();
-      for (auto& comp : lightComps)
-      {
-      	comp.SetEnableShadow(true);
-      }
-    }
+    //if (SHInputManager::GetKeyDown(SHInputManager::SH_KEYCODE::B))
+    //{
+    //  auto& lightComps = SHComponentManager::GetDense<SHLightComponent>();
+    //  for (auto& comp : lightComps)
+    //  {
+    //  	comp.SetEnableShadow(true);
+    //  }
+    //}
 
     renderGraph->Begin(frameIndex);
     auto cmdBuffer = renderGraph->GetCommandBuffer(frameIndex);
 
-    // Bind all the buffers required for meshes
-    for (auto& [buffer, bindingPoint] : MESH_DATA)
-    {
-      if (buffer->GetUsageBits() & vk::BufferUsageFlagBits::eVertexBuffer)
-        cmdBuffer->BindVertexBuffer(bindingPoint, buffer, 0);
-      else if (buffer->GetUsageBits() & vk::BufferUsageFlagBits::eIndexBuffer)
-        cmdBuffer->BindIndexBuffer(buffer, 0);
-    }
 
-    renderGraph->Execute(frameIndex, descPool);
+    renderGraph->Execute(frameIndex, descPool, MESH_DATA);
     renderGraph->End(frameIndex);
 
     graphicsQueue->SubmitCommandBuffer
@@ -765,7 +772,7 @@ namespace SHADE
     auto const&       EVENT_DATA       = reinterpret_cast<const SHEventSpec<SHLightEnableShadowEvent>*>(eventPtr.get())->data;
     auto*             lightComp        = SHComponentManager::GetComponent<SHLightComponent>(EVENT_DATA->lightEntity);
     std::string       resourceName     = "ShadowMap " + std::to_string(EVENT_DATA->lightEntity);
-    Handle<SHSubpass> companionSubpass = renderGraph->GetNode(SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_PASS.data())->GetSubpass("G-Buffer Write");
+    Handle<SHSubpass> companionSubpass = renderGraph->GetNode(SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_PASS.data())->GetSubpass(SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_WRITE_SUBPASS);
 
     if (EVENT_DATA->generateRenderer)
     {
@@ -800,7 +807,12 @@ namespace SHADE
       rasterState.cull_mode = vk::CullModeFlagBits::eBack;
 
       tempLibrary.Init(device);
-      tempLibrary.CreateGraphicsPipelines({ shadowMapVS, {} }, shadowMapNode->GetRenderpass(), newSubpass, SHGraphicsPredefinedData::GetShadowMapViState(), rasterState);
+      tempLibrary.CreateGraphicsPipelines
+      (
+        { shadowMapVS, {} }, shadowMapNode->GetRenderpass(), newSubpass, 
+        SHGraphicsPredefinedData::SystemType::BATCHING, 
+        SHGraphicsPredefinedData::GetShadowMapViState(), rasterState
+      );
       shadowMapPipeline = tempLibrary.GetGraphicsPipeline({ shadowMapVS, {} });
     }
     newSubpass->SetCompanionSubpass(companionSubpass, shadowMapPipeline); // set companion subpass and pipeline 
@@ -865,9 +877,9 @@ namespace SHADE
   /*---------------------------------------------------------------------------------*/
   /* Mesh Registration Functions                                                     */
   /*---------------------------------------------------------------------------------*/
-  SHADE::Handle<SHADE::SHMesh> SHGraphicsSystem::AddMesh(uint32_t vertexCount, const SHMesh::VertexPosition* const positions, const SHMesh::VertexTexCoord* const texCoords, const SHMesh::VertexTangent* const tangents, const SHMesh::VertexNormal* const normals, uint32_t indexCount, const SHMesh::Index* const indices)
+  SHADE::Handle<SHADE::SHMesh> SHGraphicsSystem::AddMesh(uint32_t vertexCount, const SHMesh::VertexPosition* const positions, const SHMesh::VertexTexCoord* const texCoords, const SHMesh::VertexTangent* const tangents, const SHMesh::VertexNormal* const normals, uint32_t indexCount, const SHMesh::Index* const indices, const SHMesh::VertexBoneIndices* const boneIndices, const SHMesh::VertexWeights* const boneWeights, uint32_t boneCount)
   {
-    return meshLibrary.AddMesh(vertexCount, positions, texCoords, tangents, normals, indexCount, indices);
+    return meshLibrary.AddMesh(vertexCount, positions, texCoords, tangents, normals, boneIndices, boneWeights, indexCount, indices, boneCount);
   }
 
   void SHGraphicsSystem::RemoveMesh(Handle<SHMesh> mesh)
@@ -1182,6 +1194,16 @@ namespace SHADE
     return fontLibrary;
   }
 
+  Handle <SHSubpass> SHGraphicsSystem::GetUsableSubpass(std::string const& subpassName) const noexcept
+  {
+    if (usableSubpassesMapping.contains(subpassName))
+    {
+      return usableSubpassesMapping.at (subpassName);
+    }
+    else
+      return {};
+  }
+
   Handle<SHVkPipeline> SHGraphicsSystem::createDebugDrawPipeline(Handle<SHVkRenderpass> renderPass, Handle<SHSubpass> subpass, bool filled, bool triMesh, bool instanced)
   {
     auto pipelineLayout = resourceManager.Create<SHVkPipelineLayout>

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

@@ -230,7 +230,7 @@ namespace SHADE
         
     */ 
     /*******************************************************************************/
-    Handle<SHMesh> AddMesh(uint32_t vertexCount, const SHMesh::VertexPosition* const positions, const SHMesh::VertexTexCoord* const texCoords, const SHMesh::VertexTangent* const tangents, const SHMesh::VertexNormal* const normals, uint32_t indexCount, const SHMesh::Index* const indices);
+    Handle<SHMesh> AddMesh(uint32_t vertexCount, const SHMesh::VertexPosition* const positions, const SHMesh::VertexTexCoord* const texCoords, const SHMesh::VertexTangent* const tangents, const SHMesh::VertexNormal* const normals, uint32_t indexCount, const SHMesh::Index* const indices, const SHMesh::VertexBoneIndices* const boneIndices = nullptr, const SHMesh::VertexWeights* const boneWeights = nullptr, uint32_t boneCount = 0);
     /*******************************************************************************/
     /*!
 
@@ -399,6 +399,7 @@ namespace SHADE
     uint32_t                            GetCurrentFrameIndex(void) const noexcept { return renderContext.GetCurrentFrame(); }
     SHFontLibrary const&                GetFontLibrary (void) const noexcept;
     const SHMeshLibrary&                GetMeshLibrary() const noexcept { return meshLibrary; };
+    Handle <SHSubpass> GetUsableSubpass(std::string const& subpassName) const noexcept;
 
     /*-----------------------------------------------------------------------------*/
     /* Getters                                                                     */
@@ -455,6 +456,7 @@ namespace SHADE
 
     // Built-In Shaders
     Handle<SHVkShaderModule>                                  defaultVertShader;
+    Handle<SHVkShaderModule>                                  animtVertShader;
     Handle<SHVkShaderModule>                                  defaultFragShader;
     Handle<SHVkShaderModule>                                  debugVertShader;
     Handle<SHVkShaderModule>                                  debugFragShader;
@@ -473,6 +475,7 @@ namespace SHADE
 
     // Built-In Materials
     Handle<SHMaterial>                                        defaultMaterial;
+    Handle<SHMaterial>                                        defaultAnimMaterial;
     Handle<SHVkPipeline>                                      debugDrawPipeline;
     Handle<SHVkPipeline>                                      debugDrawDepthPipeline;
     Handle<SHVkPipeline>                                      debugDrawLineMeshPipeline;
@@ -507,6 +510,8 @@ namespace SHADE
     uint32_t                                                  resizeHeight = 1;
     bool                                                      restoredFromMinimize = false;
 
+    std::unordered_map<std::string, Handle<SHSubpass>>        usableSubpassesMapping{};
+
     /*---------------------------------------------------------------------------------*/
     /* Helper Functions                                                                */
     /*---------------------------------------------------------------------------------*/

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

@@ -100,9 +100,9 @@ namespace SHADE
     auto const& mappings = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING);
     return pipeline->GetPipelineLayout()->GetShaderBlockInterface
     (
-      mappings.at (SHPredefinedDescriptorTypes::MATERIALS),
+      mappings.at (SHPredefinedDescriptorTypes::PER_INSTANCE_BATCH),
       //SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE,
-      SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA,
+      SHGraphicsConstants::DescriptorSetBindings::PER_INST_MATERIAL_DATA,
       vk::ShaderStageFlagBits::eFragment
     );
   }

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

@@ -81,9 +81,9 @@ namespace SHADE
   {
     return baseMaterial->GetPipeline()->GetPipelineLayout()->GetShaderBlockInterface
     (
-      SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING).at(SHPredefinedDescriptorTypes::MATERIALS),
+      SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING).at(SHPredefinedDescriptorTypes::PER_INSTANCE_BATCH),
       //SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE,
-      SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA,
+      SHGraphicsConstants::DescriptorSetBindings::PER_INST_MATERIAL_DATA,
       vk::ShaderStageFlagBits::eFragment
     );
   }

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

@@ -3,7 +3,7 @@
 \author         Tng Kah Wei, kahwei.tng, 390009620
 \par            email: kahwei.tng\@digipen.edu
 \date           Aug 30, 2022
-\brief          Contains definitions for all of the functions of the classes that deal 
+\brief          Contains definitions for all of the functions of the classes that deal
                 with storage and management of vertex and index buffers of meshes.
 
 Copyright (C) 2022 DigiPen Institute of Technology.
@@ -20,187 +20,252 @@ of DigiPen Institute of Technology is prohibited.
 
 namespace SHADE
 {
-	SHADE::Handle<SHADE::SHMesh> SHMeshLibrary::AddMesh(uint32_t vertexCount, const SHMesh::VertexPosition* const positions, const SHMesh::VertexTexCoord* const texCoords, const SHMesh::VertexTangent* const tangents, const SHMesh::VertexNormal* const normals, uint32_t indexCount, const SHMesh::Index* const indices)
-	{
-		isDirty = true;
+  SHADE::Handle<SHADE::SHMesh> SHMeshLibrary::AddMesh
+  (
+    uint32_t vertexCount, const SHMesh::VertexPosition* const positions,
+    const SHMesh::VertexTexCoord* const texCoords,
+    const SHMesh::VertexTangent* const tangents,
+    const SHMesh::VertexNormal* const normals,
+    const SHMesh::VertexBoneIndices* const boneIndices,
+    const SHMesh::VertexWeights* const boneWeights,
+    uint32_t indexCount, const SHMesh::Index* const indices,
+    uint32_t boneCount)
+  {
+    isDirty = true;
 
-		auto handle = meshes.Create();
-        meshAddJobs.emplace_back( MeshAddJob
-        {
-            vertexCount,
-            positions,
-            texCoords,
-            tangents,
-            normals,
-            indexCount,
-            indices,
-            handle
-        });
-		return handle;
-	}
-
-	void SHMeshLibrary::RemoveMesh(Handle<SHMesh> mesh)
+    auto handle = meshes.Create();
+    meshAddJobs.emplace_back(MeshAddJob
     {
-        if (!mesh)
-            throw std::invalid_argument("Attempted to remove a Mesh that did not belong to the Mesh Library!");
-        
-        meshRemoveJobs.emplace_back(mesh);
-        isDirty = true;
+      vertexCount,
+      positions,
+      texCoords,
+      tangents,
+      normals,
+      boneIndices,
+      boneWeights,
+      indexCount,
+      indices,
+      boneCount,
+      handle
+    });
+    return handle;
+  }
+
+  void SHMeshLibrary::RemoveMesh(Handle<SHMesh> mesh)
+  {
+    if (!mesh)
+      throw std::invalid_argument("Attempted to remove a Mesh that did not belong to the Mesh Library!");
+
+    meshRemoveJobs.emplace_back(mesh);
+    isDirty = true;
+  }
+
+  void SHMeshLibrary::BuildBuffers(Handle<SHVkLogicalDevice> device, Handle<SHVkCommandBuffer> cmdBuffer)
+  {
+    // No changes
+    if (!isDirty)
+      return;
+
+    // Remove
+    if (!meshRemoveJobs.empty())
+    {
+      // - Remove from order list
+      for (const auto& meshToRemove : meshRemoveJobs)
+      {
+        auto searchResult = std::find(meshOrder.begin(), meshOrder.end(), meshToRemove);
+        // Shouldn't happen, ignore
+        if (searchResult == meshOrder.end())
+          continue;
+
+        // Remove from mesh list
+        meshOrder.erase(searchResult);
+      }
+      meshRemoveJobs.clear();
+      // - Shift existing elements in to close up the gaps
+      int32_t nextVertInsertPoint = 0;
+      uint32_t nextIdxInsertPoint = 0;
+      for (auto& mesh : meshOrder)
+      {
+        // Check if already in the correct place
+        if (nextVertInsertPoint != mesh->FirstVertex)
+        {
+          /* There's a gap, we need to shift */
+          // Vertices
+          vertPosStorage.erase(vertPosStorage.begin() + nextVertInsertPoint, vertPosStorage.begin() + mesh->FirstVertex);
+          vertTexCoordStorage.erase(vertTexCoordStorage.begin() + nextVertInsertPoint, vertTexCoordStorage.begin() + mesh->FirstVertex);
+          vertTangentStorage.erase(vertTangentStorage.begin() + nextVertInsertPoint, vertTangentStorage.begin() + mesh->FirstVertex);
+          vertNormalStorage.erase(vertNormalStorage.begin() + nextVertInsertPoint, vertNormalStorage.begin() + mesh->FirstVertex);
+          vertBoneIdxStorage.erase(vertBoneIdxStorage.begin() + nextVertInsertPoint, vertBoneIdxStorage.begin() + mesh->FirstVertex);
+          vertBoneWeightStorage.erase(vertBoneWeightStorage.begin() + nextVertInsertPoint, vertBoneWeightStorage.begin() + mesh->FirstVertex);
+          // - Update mesh data
+          mesh->FirstVertex = nextVertInsertPoint;
+
+          // Indices
+          indexStorage.erase(indexStorage.begin() + nextIdxInsertPoint, indexStorage.begin() + mesh->FirstIndex);
+          // - Update mesh data
+          mesh->FirstIndex = nextIdxInsertPoint;
+
+          // Prepare for next
+          nextVertInsertPoint += mesh->VertexCount;
+          nextIdxInsertPoint += mesh->IndexCount;
+        }
+      }
     }
 
-    void SHMeshLibrary::BuildBuffers(Handle<SHVkLogicalDevice> device, Handle<SHVkCommandBuffer> cmdBuffer)
+    // Add
+    if (!meshAddJobs.empty())
     {
-        // No changes
-        if (!isDirty)
-            return;
-
-        // Remove
-        if (!meshRemoveJobs.empty())
+      // - Compute updated size
+      size_t newVertElems = vertPosStorage.size();
+      size_t newIdxElems = indexStorage.size();
+      for (const auto& addJob : meshAddJobs)
+      {
+        newVertElems += addJob.VertexCount;
+        newIdxElems += addJob.IndexCount;
+      }
+      // - Reserve new memory
+      vertPosStorage.reserve(newVertElems);
+      vertTexCoordStorage.reserve(newVertElems);
+      vertTangentStorage.reserve(newVertElems);
+      vertNormalStorage.reserve(newVertElems);
+      vertBoneIdxStorage.reserve(newVertElems);
+      vertBoneWeightStorage.reserve(newVertElems);
+      indexStorage.reserve(newIdxElems);
+      // - Append new data
+      for (auto& addJob : meshAddJobs)
+      {
+        // Update handle
+        SHMesh& meshData = *addJob.Handle;
+        meshData = SHMesh
         {
-            // - Remove from order list
-            for (const auto& meshToRemove : meshRemoveJobs)
-            {
-                auto searchResult = std::find(meshOrder.begin(), meshOrder.end(), meshToRemove);
-                // Shouldn't happen, ignore
-                if (searchResult == meshOrder.end())
-                    continue;
+            .FirstVertex = static_cast<int32_t>(vertPosStorage.size()),
+            .VertexCount = static_cast<uint32_t>(addJob.VertexCount),
+            .FirstIndex = static_cast<uint32_t>(indexStorage.size()),
+            .IndexCount = static_cast<uint32_t>(addJob.IndexCount),
+            .BoneCount = addJob.BoneCount
+        };
 
-                // Remove from mesh list
-                meshOrder.erase(searchResult);
-            }
-            meshRemoveJobs.clear();
-            // - Shift existing elements in to close up the gaps
-             int32_t nextVertInsertPoint = 0;
-            uint32_t nextIdxInsertPoint  = 0;
-            for (auto& mesh : meshOrder)
-            {
-                // Check if already in the correct place
-                if (nextVertInsertPoint != mesh->FirstVertex)
-                {
-                    /* There's a gap, we need to shift */
-					// Vertices
-					vertPosStorage.erase(vertPosStorage.begin() + nextVertInsertPoint, vertPosStorage.begin() + mesh->FirstVertex);
-					vertTexCoordStorage.erase(vertTexCoordStorage.begin() + nextVertInsertPoint, vertTexCoordStorage.begin() + mesh->FirstVertex);
-					vertTangentStorage.erase(vertTangentStorage.begin() + nextVertInsertPoint, vertTangentStorage.begin() + mesh->FirstVertex);
-					vertNormalStorage.erase(vertNormalStorage.begin() + nextVertInsertPoint, vertNormalStorage.begin() + mesh->FirstVertex);
-					// - Update mesh data
-                    mesh->FirstVertex = nextVertInsertPoint;
-
-                    // Indices
-                    indexStorage.erase(indexStorage.begin() + nextIdxInsertPoint, indexStorage.begin() + mesh->FirstIndex);
-                    // - Update mesh data
-                    mesh->FirstIndex = nextIdxInsertPoint;
-
-                    // Prepare for next
-                    nextVertInsertPoint += mesh->VertexCount;
-                    nextIdxInsertPoint += mesh->IndexCount;
-                }
-            }
-        }
-
-        // Add
-        if (!meshAddJobs.empty())
+        // Copy into storage
+        vertPosStorage.insert
+        (
+          vertPosStorage.end(),
+          addJob.VertexPositions, addJob.VertexPositions + addJob.VertexCount
+        );
+        vertTexCoordStorage.insert
+        (
+          vertTexCoordStorage.end(),
+          addJob.VertexTexCoords, addJob.VertexTexCoords + addJob.VertexCount
+        );
+        vertTangentStorage.insert
+        (
+          vertTangentStorage.end(),
+          addJob.VertexTangents, addJob.VertexTangents + addJob.VertexCount
+        );
+        vertNormalStorage.insert
+        (
+          vertNormalStorage.end(),
+          addJob.VertexNormals, addJob.VertexNormals + addJob.VertexCount
+        );
+        if (addJob.VertexBoneIndices)
         {
-            // - Compute updated size
-            size_t newVertElems = vertPosStorage.size();
-            size_t newIdxElems = indexStorage.size();
-            for (const auto& addJob : meshAddJobs)
-            {
-                newVertElems += addJob.VertexCount;
-                newIdxElems += addJob.IndexCount;
-            }
-            // - Reserve new memory
-            vertPosStorage     .reserve(newVertElems);
-			vertTexCoordStorage.reserve(newVertElems);
-			vertTangentStorage .reserve(newVertElems);
-			vertNormalStorage  .reserve(newVertElems);
-			indexStorage       .reserve(newIdxElems);
-            // - Append new data
-            for (auto& addJob : meshAddJobs)
-            {
-                // Update handle
-                SHMesh& meshData = *addJob.Handle;
-                meshData = SHMesh
-                {
-                    .FirstVertex = static_cast<int32_t>(vertPosStorage.size()),
-                    .VertexCount = static_cast<uint32_t>(addJob.VertexCount),
-                    .FirstIndex  = static_cast<uint32_t>(indexStorage.size()),
-                    .IndexCount  = static_cast<uint32_t>(addJob.IndexCount),
-                };
-
-				// Copy into storage
-				vertPosStorage.insert
-                (
-                    vertPosStorage.end(), 
-                    addJob.VertexPositions, addJob.VertexPositions + addJob.VertexCount
-                );
-				vertTexCoordStorage.insert
-                (
-                    vertTexCoordStorage.end(),
-                    addJob.VertexTexCoords, addJob.VertexTexCoords + addJob.VertexCount
-                );
-				vertTangentStorage.insert
-                (
-                    vertTangentStorage.end(),
-                    addJob.VertexTangents, addJob.VertexTangents + addJob.VertexCount
-                );
-				vertNormalStorage.insert
-                (
-                    vertNormalStorage.end(),
-                    addJob.VertexNormals, addJob.VertexNormals + addJob.VertexCount
-                );
-                indexStorage.insert
-                (
-                    indexStorage.end(),
-                    addJob.Indices, addJob.Indices + addJob.IndexCount
-                );
-            }
-            meshAddJobs.clear();
+          vertBoneIdxStorage.insert
+          (
+            vertBoneIdxStorage.end(),
+            addJob.VertexBoneIndices, addJob.VertexBoneIndices + addJob.VertexCount
+          );
         }
-
-        // Send to GPU
-		using BuffUsage = vk::BufferUsageFlagBits;
-		SHVkUtil::EnsureBufferAndCopyData
-		(
-			device, cmdBuffer, vertPosBuffer,
-			vertPosStorage.data(),
-			static_cast<uint32_t>(vertPosStorage.size()) * sizeof(SHMesh::VertexPosition),
-            BuffUsage::eVertexBuffer,
-            "Mesh Library Vertex Positions"
-		);
-		SHVkUtil::EnsureBufferAndCopyData
-		(
-			device, cmdBuffer, vertTexCoordBuffer,
-			vertTexCoordStorage.data(),
-			static_cast<uint32_t>(vertTexCoordStorage.size()) * sizeof(SHMesh::VertexTexCoord),
-			BuffUsage::eVertexBuffer,
-            "Mesh Library Vertex TexCoords"
-		);
-		SHVkUtil::EnsureBufferAndCopyData
-		(
-			device, cmdBuffer, vertTangentBuffer,
-			vertTangentStorage.data(),
-			static_cast<uint32_t>(vertTangentStorage.size()) * sizeof(SHMesh::VertexTangent),
-			BuffUsage::eVertexBuffer,
-            "Mesh Library Vertex Tangents"
-		);
-		SHVkUtil::EnsureBufferAndCopyData
-		(
-			device, cmdBuffer, vertNormalBuffer,
-			vertNormalStorage.data(),
-			static_cast<uint32_t>(vertNormalStorage.size()) * sizeof(SHMesh::VertexNormal),
-			BuffUsage::eVertexBuffer,
-            "Mesh Library Vertex Normals"
-		);
-		SHVkUtil::EnsureBufferAndCopyData
-		(
-			device, cmdBuffer, indexBuffer,
-			indexStorage.data(),
-			static_cast<uint32_t>(indexStorage.size()) * sizeof(SHMesh::Index),
-			BuffUsage::eIndexBuffer,
-            "Mesh Library Indices"
-		);
-
-        isDirty = false;
+        else
+        {
+          vertBoneIdxStorage.resize(vertBoneIdxStorage.size() + addJob.VertexCount);
+        }
+        if (addJob.VertexBoneWeights)
+        {
+          vertBoneWeightStorage.insert
+          (
+            vertBoneWeightStorage.end(),
+            addJob.VertexBoneWeights, addJob.VertexBoneWeights + addJob.VertexCount
+          );
+        }
+        else
+        {
+          const auto OG_SIZE = vertBoneWeightStorage.size();
+          vertBoneWeightStorage.resize(vertBoneWeightStorage.size() + addJob.VertexCount);
+          std::fill_n(vertBoneWeightStorage.begin() + OG_SIZE, addJob.VertexCount, SHVec4(1.0f, 0.0f, 0.0f, 0.0f));
+        }
+        indexStorage.insert
+        (
+          indexStorage.end(),
+          addJob.Indices, addJob.Indices + addJob.IndexCount
+        );
+      }
+      meshAddJobs.clear();
     }
+
+    // Send to GPU
+    using BuffUsage = vk::BufferUsageFlagBits;
+    SHVkUtil::EnsureBufferAndCopyData
+    (
+      device, cmdBuffer, vertPosBuffer,
+      vertPosStorage.data(),
+      static_cast<uint32_t>(vertPosStorage.size()) * sizeof(SHMesh::VertexPosition),
+      BuffUsage::eVertexBuffer,
+      "Mesh Library Vertex Positions"
+    );
+    SHVkUtil::EnsureBufferAndCopyData
+    (
+      device, cmdBuffer, vertTexCoordBuffer,
+      vertTexCoordStorage.data(),
+      static_cast<uint32_t>(vertTexCoordStorage.size()) * sizeof(SHMesh::VertexTexCoord),
+      BuffUsage::eVertexBuffer,
+      "Mesh Library Vertex TexCoords"
+    );
+    SHVkUtil::EnsureBufferAndCopyData
+    (
+      device, cmdBuffer, vertTangentBuffer,
+      vertTangentStorage.data(),
+      static_cast<uint32_t>(vertTangentStorage.size()) * sizeof(SHMesh::VertexTangent),
+      BuffUsage::eVertexBuffer,
+      "Mesh Library Vertex Tangents"
+    );
+    SHVkUtil::EnsureBufferAndCopyData
+    (
+      device, cmdBuffer, vertNormalBuffer,
+      vertNormalStorage.data(),
+      static_cast<uint32_t>(vertNormalStorage.size()) * sizeof(SHMesh::VertexNormal),
+      BuffUsage::eVertexBuffer,
+      "Mesh Library Vertex Normals"
+    );
+    if (!vertBoneIdxStorage.empty())
+    {
+      SHVkUtil::EnsureBufferAndCopyData
+      (
+        device, cmdBuffer, vertBoneIdxBuffer,
+        vertBoneIdxStorage.data(),
+        static_cast<uint32_t>(vertBoneIdxStorage.size()) * sizeof(SHMesh::VertexBoneIndices),
+        BuffUsage::eVertexBuffer,
+        "Mesh Library Vertex Bone Indices"
+      );
+    }
+    if (!vertBoneWeightStorage.empty())
+    {
+      SHVkUtil::EnsureBufferAndCopyData
+      (
+        device, cmdBuffer, vertBoneWeightBuffer,
+        vertBoneWeightStorage.data(),
+        static_cast<uint32_t>(vertBoneWeightStorage.size()) * sizeof(SHMesh::VertexWeights),
+        BuffUsage::eVertexBuffer,
+        "Mesh Library Vertex Bone Weights"
+      );
+    }
+    SHVkUtil::EnsureBufferAndCopyData
+    (
+      device, cmdBuffer, indexBuffer,
+      indexStorage.data(),
+      static_cast<uint32_t>(indexStorage.size()) * sizeof(SHMesh::Index),
+      BuffUsage::eIndexBuffer,
+      "Mesh Library Indices"
+    );
+
+    isDirty = false;
+  }
 }

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

@@ -19,170 +19,191 @@ of DigiPen Institute of Technology is prohibited.
 #include "Resource/SHResourceLibrary.h"
 #include "Math/Vector/SHVec2.h"
 #include "Math/Vector/SHVec3.h"
+#include "Math/Vector/SHVec4.h"
+#include "Math/Vector/SHVec4U.h"
 
 namespace SHADE
 {
-    /*---------------------------------------------------------------------------------*/
-    /* Forward Declarations                                                            */
-    /*---------------------------------------------------------------------------------*/
-    class SHVkBuffer;
-    class SHVkLogicalDevice;
-    class SHVkCommandBuffer;
+  /*---------------------------------------------------------------------------------*/
+  /* Forward Declarations                                                            */
+  /*---------------------------------------------------------------------------------*/
+  class SHVkBuffer;
+  class SHVkLogicalDevice;
+  class SHVkCommandBuffer;
 
-    /*---------------------------------------------------------------------------------*/
-    /* Type Definitions                                                                */
-    /*---------------------------------------------------------------------------------*/
-    /***********************************************************************************/
+  /*---------------------------------------------------------------------------------*/
+  /* Type Definitions                                                                */
+  /*---------------------------------------------------------------------------------*/
+  /***********************************************************************************/
+  /*!
+    \brief
+      Represents a single mesh that is stored in a SHMeshLibrary.
+  */
+  /***********************************************************************************/
+  class SHMesh
+  {
+  public:
+    /*-----------------------------------------------------------------------------*/
+    /* Type Definitions                                                            */
+    /*-----------------------------------------------------------------------------*/
+    using Index             = uint32_t;
+    using VertexPosition    = SHVec3;
+    using VertexTexCoord    = SHVec2;
+    using VertexTangent     = SHVec3;
+    using VertexNormal      = SHVec3;
+    using VertexBoneIndices = SHVec4U;
+    using VertexWeights     = SHVec4;
+
+    /*-----------------------------------------------------------------------------*/
+    /* Data Members                                                                */
+    /*-----------------------------------------------------------------------------*/
+    int32_t  FirstVertex;
+    uint32_t VertexCount;
+    uint32_t FirstIndex;
+    uint32_t IndexCount;
+    uint32_t BoneCount;
+  };
+  /***********************************************************************************/
+  /*!
+    \brief
+      Manages storage for all Meshes in the Graphics System as a single set of Vertex
+      and Index Buffers.
+  */
+  /***********************************************************************************/
+  class SHMeshLibrary
+  {
+  public:
+    /*-----------------------------------------------------------------------------*/
+    /* Usage Functions                                                             */
+    /*-----------------------------------------------------------------------------*/
+    /*******************************************************************************/
     /*!
-      \brief
-        Represents a single mesh that is stored in a SHMeshLibrary.
-    */
-    /***********************************************************************************/
-    class SHMesh
-    {
-	public:
-		/*-----------------------------------------------------------------------------*/
-		/* Type Definitions                                                            */
-		/*-----------------------------------------------------------------------------*/
-		using Index = uint32_t;
-		using VertexPosition = SHVec3;
-		using VertexTexCoord = SHVec2;
-		using VertexTangent  = SHVec3;
-		using VertexNormal   = SHVec3;
 
-        /*-----------------------------------------------------------------------------*/
-        /* Data Members                                                                */
-        /*-----------------------------------------------------------------------------*/
-         int32_t FirstVertex;
-        uint32_t VertexCount;
-        uint32_t FirstIndex;
-        uint32_t IndexCount;
-    };
-    /***********************************************************************************/
+     \brief
+       Adds a mesh to the Mesh Library. But this does not mean that the meshes have
+       been added yet. A call to "BuildBuffers()" is required to transfer all
+       meshes into the GPU.
+
+     \param vertexCount
+       Number of vertices in this Mesh.
+     \param positions
+       Pointer to the first in a contiguous array of SHMathVec3s that define vertex
+       positions.
+     \param texCoords
+       Pointer to the first in a contiguous array of SHMathVec2s that define vertex
+       texture coordinates.
+     \param tangents
+       Pointer to the first in a contiguous array of SHMathVec3s that define vertex
+       tangents.
+     \param normals
+       Pointer to the first in a contiguous array of SHMathVec3s that define vertex
+       normals.
+     \param indexCount
+       Number of indices in this mesh.
+     \param indices
+       Pointer to the first in a contiguous array of uint32_ts that define mesh
+       indicies.
+
+      \return
+       Handle to the created Mesh. This is not valid to be used until a call to
+       BuildBuffers().
+
+    */
+    /*******************************************************************************/
+    Handle<SHMesh> AddMesh(uint32_t vertexCount, const SHMesh::VertexPosition* const positions, 
+                                                 const SHMesh::VertexTexCoord* const texCoords,
+                                                 const SHMesh::VertexTangent* const tangents,
+                                                 const SHMesh::VertexNormal* const normals,
+                                                 const SHMesh::VertexBoneIndices* const boneIndices,
+                                                 const SHMesh::VertexWeights* const boneWeights,
+                           uint32_t indexCount,  const SHMesh::Index* const indices,
+                           uint32_t boneCount);
+    /*******************************************************************************/
     /*!
-      \brief
-        Manages storage for all Meshes in the Graphics System as a single set of Vertex
-        and Index Buffers.
+
+     \brief
+       Removes a mesh from the MeshLibrary. But this does not mean that the meshes
+       have been removed yet.  A call to "BuildBuffers()" is required to finalise all
+       changes.
+
+     \param mesh
+       Handle to the mesh to remove.
+
     */
-    /***********************************************************************************/
-    class SHMeshLibrary
+    /*******************************************************************************/
+    void RemoveMesh(Handle<SHMesh> mesh);
+    /***************************************************************************/
+    /*!
+
+     \brief
+       Finalises all changes to the MeshLibrary 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 BuildBuffers(Handle<SHVkLogicalDevice> device, Handle<SHVkCommandBuffer> cmdBuffer);
+
+    /*-----------------------------------------------------------------------------*/
+    /* Getter Functions                                                            */
+    /*-----------------------------------------------------------------------------*/
+    Handle<SHVkBuffer> GetVertexPositionsBuffer()   const noexcept { return vertPosBuffer; }
+    Handle<SHVkBuffer> GetVertexTexCoordsBuffer()   const noexcept { return vertTexCoordBuffer; }
+    Handle<SHVkBuffer> GetVertexTangentsBuffer()    const noexcept { return vertTangentBuffer; }
+    Handle<SHVkBuffer> GetVertexNormalsBuffer()     const noexcept { return vertNormalBuffer; }
+    Handle<SHVkBuffer> GetVertexBoneIndicesBuffer() const noexcept { return vertBoneIdxBuffer; }
+    Handle<SHVkBuffer> GetVertexBoneWeightsBuffer() const noexcept { return vertBoneWeightBuffer; }
+    Handle<SHVkBuffer> GetIndexBuffer()             const noexcept { return indexBuffer; }
+
+  private:
+    /*-----------------------------------------------------------------------------*/
+    /* Type Definition                                                             */
+    /*-----------------------------------------------------------------------------*/
+    struct MeshAddJob
     {
-	  public:
-        /*-----------------------------------------------------------------------------*/
-        /* Usage Functions                                                             */
-        /*-----------------------------------------------------------------------------*/
-        /*******************************************************************************/
-        /*!
-        
-		 \brief
-		   Adds a mesh to the Mesh Library. But this does not mean that the meshes have
-		   been added yet. A call to "BuildBuffers()" is required to transfer all
-		   meshes into the GPU.
-        
-         \param vertexCount
-           Number of vertices in this Mesh.
-         \param positions
-           Pointer to the first in a contiguous array of SHMathVec3s that define vertex
-           positions.
-		 \param texCoords
-		   Pointer to the first in a contiguous array of SHMathVec2s that define vertex
-		   texture coordinates.
-		 \param tangents
-		   Pointer to the first in a contiguous array of SHMathVec3s that define vertex
-		   tangents.
-		 \param normals
-		   Pointer to the first in a contiguous array of SHMathVec3s that define vertex
-		   normals.
-         \param indexCount
-           Number of indices in this mesh.
-         \param indices
-           Pointer to the first in a contiguous array of uint32_ts that define mesh
-           indicies.
-        
-		 \return
-		  Handle to the created Mesh. This is not valid to be used until a call to
-		  BuildBuffers().
-        
-        */ 
-        /*******************************************************************************/
-        Handle<SHMesh> AddMesh(uint32_t vertexCount, const SHMesh::VertexPosition* const positions, const SHMesh::VertexTexCoord* const texCoords, const SHMesh::VertexTangent* const tangents, const SHMesh::VertexNormal* const normals, uint32_t indexCount, const SHMesh::Index* const indices);
-        /*******************************************************************************/
-        /*! 
-         
-         \brief
-           Removes a mesh from the MeshLibrary. But this does not mean that the meshes
-           have been removed yet.  A call to "BuildBuffers()" is required to finalise all
-           changes.
-
-         \param mesh
-           Handle to the mesh to remove.
-
-        */ 
-        /*******************************************************************************/
-        void RemoveMesh(Handle<SHMesh> mesh);
-        /***************************************************************************/
-        /*! 
-         
-         \brief
-           Finalises all changes to the MeshLibrary 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 BuildBuffers(Handle<SHVkLogicalDevice> device, Handle<SHVkCommandBuffer> cmdBuffer);
-
-        /*-----------------------------------------------------------------------------*/
-        /* Getter Functions                                                            */
-		/*-----------------------------------------------------------------------------*/
-		Handle<SHVkBuffer> GetVertexPositionsBuffer() const noexcept { return vertPosBuffer; }
-		Handle<SHVkBuffer> GetVertexTexCoordsBuffer() const noexcept { return vertTexCoordBuffer; }
-		Handle<SHVkBuffer> GetVertexTangentsBuffer() const noexcept { return vertTangentBuffer; }
-		Handle<SHVkBuffer> GetVertexNormalsBuffer() const noexcept { return vertNormalBuffer; }
-        Handle<SHVkBuffer> GetIndexBuffer() const { return indexBuffer; }
-
-      private:
-        /*-----------------------------------------------------------------------------*/
-        /* Type Definition                                                             */
-        /*-----------------------------------------------------------------------------*/
-        struct MeshAddJob
-		{
-            uint32_t                      VertexCount    = 0;
-			const SHMesh::VertexPosition* VertexPositions = nullptr;
-			const SHMesh::VertexTexCoord* VertexTexCoords = nullptr;
-			const SHMesh::VertexTangent * VertexTangents = nullptr;
-			const SHMesh::VertexNormal  * VertexNormals = nullptr;
-            uint32_t                      IndexCount      = 0;
-            const SHMesh::Index         * Indices         = nullptr;
-            Handle<SHMesh>                Handle;
-        };
-        /*-----------------------------------------------------------------------------*/
-        /* Data Members                                                                */
-        /*-----------------------------------------------------------------------------*/
-        // Manipulation Queues
-        std::vector<MeshAddJob> meshAddJobs;
-        std::vector<Handle<SHMesh>> meshRemoveJobs;
-        // Tracking
-		SHResourceLibrary<SHMesh> meshes{};
-        std::vector<Handle<SHMesh>> meshOrder;
-		// CPU Storage
-		std::vector<SHMesh::VertexPosition> vertPosStorage;
-		std::vector<SHMesh::VertexTexCoord> vertTexCoordStorage;
-		std::vector<SHMesh::VertexTangent>  vertTangentStorage;
-		std::vector<SHMesh::VertexNormal>   vertNormalStorage;
-        std::vector<SHMesh::Index>          indexStorage;
-        // GPU Storage
-		Handle<SHVkBuffer> vertPosBuffer{};
-		Handle<SHVkBuffer> vertTexCoordBuffer{};
-		Handle<SHVkBuffer> vertTangentBuffer{};
-		Handle<SHVkBuffer> vertNormalBuffer{};
-        Handle<SHVkBuffer> indexBuffer {};
-        // Flags
-        bool isDirty = true;
+      uint32_t                         VertexCount       = 0;
+      const SHMesh::VertexPosition*    VertexPositions   = nullptr;
+      const SHMesh::VertexTexCoord*    VertexTexCoords   = nullptr;
+      const SHMesh::VertexTangent*     VertexTangents    = nullptr;
+      const SHMesh::VertexNormal*      VertexNormals     = nullptr;
+      const SHMesh::VertexBoneIndices* VertexBoneIndices = nullptr;
+      const SHMesh::VertexWeights*     VertexBoneWeights = nullptr;
+      uint32_t                         IndexCount        = 0;
+      const SHMesh::Index*             Indices           = nullptr;
+      uint32_t                         BoneCount         = 0;
+      Handle<SHMesh>                   Handle;
     };
+    /*-----------------------------------------------------------------------------*/
+    /* Data Members                                                                */
+    /*-----------------------------------------------------------------------------*/
+    // Manipulation Queues
+    std::vector<MeshAddJob>     meshAddJobs;
+    std::vector<Handle<SHMesh>> meshRemoveJobs;
+    // Tracking
+    SHResourceLibrary<SHMesh>   meshes;
+    std::vector<Handle<SHMesh>> meshOrder;
+    // CPU Storage
+    std::vector<SHMesh::VertexPosition>    vertPosStorage;
+    std::vector<SHMesh::VertexTexCoord>    vertTexCoordStorage;
+    std::vector<SHMesh::VertexTangent>     vertTangentStorage;
+    std::vector<SHMesh::VertexNormal>      vertNormalStorage;
+    std::vector<SHMesh::VertexBoneIndices> vertBoneIdxStorage;    // Must be in multiples of 4
+    std::vector<SHMesh::VertexWeights>     vertBoneWeightStorage;
+    std::vector<SHMesh::Index>             indexStorage;
+    // GPU Storage
+    Handle<SHVkBuffer> vertPosBuffer{};
+    Handle<SHVkBuffer> vertTexCoordBuffer{};
+    Handle<SHVkBuffer> vertTangentBuffer{};
+    Handle<SHVkBuffer> vertNormalBuffer{};
+    Handle<SHVkBuffer> vertBoneIdxBuffer{};
+    Handle<SHVkBuffer> vertBoneWeightBuffer{};
+    Handle<SHVkBuffer> indexBuffer{};
+    // Flags
+    bool isDirty = true;
+  };
 }

SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.cpp

@@ -25,18 +25,18 @@ namespace SHADE
   /*-----------------------------------------------------------------------------------*/
   /* Static Member Definitions                                                         */
   /*-----------------------------------------------------------------------------------*/
-  SHMeshData SHPrimitiveGenerator::cubeMesh;
-  SHMeshData SHPrimitiveGenerator::sphereMesh;
-  SHMeshData SHPrimitiveGenerator::lineCubeMesh;
-  SHMeshData SHPrimitiveGenerator::lineCircleMesh;
-  SHMeshData SHPrimitiveGenerator::lineCapsuleCapMesh;
+  SHMeshAsset SHPrimitiveGenerator::cubeMesh;
+  SHMeshAsset SHPrimitiveGenerator::sphereMesh;
+  SHMeshAsset SHPrimitiveGenerator::lineCubeMesh;
+  SHMeshAsset SHPrimitiveGenerator::lineCircleMesh;
+  SHMeshAsset SHPrimitiveGenerator::lineCapsuleCapMesh;
 
   /*-----------------------------------------------------------------------------------*/
   /* Primitive Generation Functions                                                    */
   /*-----------------------------------------------------------------------------------*/
-  SHMeshData SHPrimitiveGenerator::Cube() noexcept
+  SHMeshAsset SHPrimitiveGenerator::Cube() noexcept
   {
-    SHMeshData mesh;
+    SHMeshAsset mesh;
 
     mesh.VertexPositions = 
     {
@@ -221,9 +221,9 @@ namespace SHADE
     return addMeshDataTo(cubeMesh, gfxSystem);
   }
 
-  SHMeshData SHPrimitiveGenerator::Sphere() noexcept
+  SHMeshAsset SHPrimitiveGenerator::Sphere() noexcept
   {
-    SHMeshData meshData;
+    SHMeshAsset meshData;
 
     const int LAT_SLICES = 12;
     const int LONG_SLICES = 12;
@@ -288,9 +288,9 @@ namespace SHADE
     return addMeshDataTo(sphereMesh, gfxSystem);
   }
 
-  SHMeshData SHPrimitiveGenerator::LineCube() noexcept
+  SHMeshAsset SHPrimitiveGenerator::LineCube() noexcept
   {
-    SHMeshData mesh;
+    SHMeshAsset mesh;
 
     mesh.VertexPositions = 
     {
@@ -347,9 +347,9 @@ namespace SHADE
     return addMeshDataTo(lineCubeMesh, gfxSystem);
   }
 
-  SHMeshData SHPrimitiveGenerator::LineCircle() noexcept
+  SHMeshAsset SHPrimitiveGenerator::LineCircle() noexcept
   {
-    SHMeshData mesh;
+    SHMeshAsset mesh;
 
     // Generate points of the circle
     static constexpr int SPLITS = 36;
@@ -393,9 +393,9 @@ namespace SHADE
     return addMeshDataTo(lineCircleMesh, gfxSystem);
   }
 
-  SHADE::SHMeshData SHPrimitiveGenerator::LineCapsuleCap() noexcept
+  SHMeshAsset SHPrimitiveGenerator::LineCapsuleCap() noexcept
   {
-    SHMeshData mesh;
+    SHMeshAsset mesh;
 
     // Have multiple semi-circles for the cap
     static constexpr int SPLITS = 36;
@@ -454,7 +454,7 @@ namespace SHADE
   /*-----------------------------------------------------------------------------------*/
   /* Helper Functions                                                                  */
   /*-----------------------------------------------------------------------------------*/
-  SHADE::Handle<SHADE::SHMesh> SHPrimitiveGenerator::addMeshDataTo(const SHMeshData& meshData, SHMeshLibrary& meshLibrary) noexcept
+  SHADE::Handle<SHADE::SHMesh> SHPrimitiveGenerator::addMeshDataTo(const SHMeshAsset& meshData, SHMeshLibrary& meshLibrary) noexcept
   {
     return meshLibrary.AddMesh
     (
@@ -463,12 +463,15 @@ namespace SHADE
       meshData.VertexTexCoords.data(),
       meshData.VertexTangents.data(),
       meshData.VertexNormals.data(),
+      nullptr,
+      nullptr,
       static_cast<uint32_t>(meshData.Indices.size()),
-      meshData.Indices.data()
+      meshData.Indices.data(),
+      0
     );
   }
 
-  SHADE::Handle<SHADE::SHMesh> SHPrimitiveGenerator::addMeshDataTo(const SHMeshData& meshData, SHGraphicsSystem& gfxSystem) noexcept
+  SHADE::Handle<SHADE::SHMesh> SHPrimitiveGenerator::addMeshDataTo(const SHMeshAsset& meshData, SHGraphicsSystem& gfxSystem) noexcept
   {
     return gfxSystem.AddMesh
     (

SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.h

@@ -12,10 +12,11 @@ of DigiPen Institute of Technology is prohibited.
 #pragma once
 
 // Project Includes
-#include "Math/SHMath.h"
-#include "Assets/Asset Types/SHModelAsset.h"
-#include "Graphics/MiddleEnd/Interface/SHMeshLibrary.h"
 #include "SH_API.h"
+#include "Math/SHMath.h"
+#include "Assets/Asset Types/Models/SHModelAsset.h"
+#include "Assets/Asset Types/Models/SHMeshAsset.h"
+#include "Graphics/MiddleEnd/Interface/SHMeshLibrary.h"
 
 namespace SHADE
 {
@@ -47,13 +48,13 @@ namespace SHADE
     /***********************************************************************************/
     /*!
       \brief
-        Produces a cube and stores the data in a SHMeshData object.
+        Produces a cube and stores the data in a SHMeshAsset object.
 
       \return
-        SHMeshData object containing vertex data for the cube.
+        SHMeshAsset object containing vertex data for the cube.
     */
     /***********************************************************************************/
-    [[nodiscard]] static SHMeshData Cube() noexcept;
+    [[nodiscard]] static SHMeshAsset Cube() noexcept;
     /***********************************************************************************/
     /*!
       \brief
@@ -83,13 +84,13 @@ namespace SHADE
     /***********************************************************************************/
     /*!
       \brief
-        Produces a sphere and stores the data in a SHMeshData object.
+        Produces a sphere and stores the data in a SHMeshAsset object.
 
       \return
-        SHMeshData object containing vertex data for the sphere.
+        SHMeshAsset object containing vertex data for the sphere.
     */
     /***********************************************************************************/
-    [[nodiscard]] static SHMeshData Sphere() noexcept;
+    [[nodiscard]] static SHMeshAsset Sphere() noexcept;
     /***********************************************************************************/
     /*!
       \brief
@@ -120,13 +121,13 @@ namespace SHADE
     /*!
       \brief
         Produces a cube that is comprised only of lines with no diagonal lines and store
-        the data in a SHMeshData object.
+        the data in a SHMeshAsset object.
 
       \return
-        SHMeshData object containing vertex data for the line cube.
+        SHMeshAsset object containing vertex data for the line cube.
     */
     /***********************************************************************************/
-    [[nodiscard]] static SHMeshData LineCube() noexcept;
+    [[nodiscard]] static SHMeshAsset LineCube() noexcept;
     /***********************************************************************************/
     /*!
       \brief
@@ -158,13 +159,13 @@ namespace SHADE
     /*!
       \brief
         Produces a circle that is comprised only of lines with no diagonal lines and 
-        store the data in a SHMeshData object.
+        store the data in a SHMeshAsset object.
 
       \return
-        SHMeshData object containing vertex data for the line circle.
+        SHMeshAsset object containing vertex data for the line circle.
     */
     /***********************************************************************************/
-    [[nodiscard]] static SHMeshData LineCircle() noexcept;
+    [[nodiscard]] static SHMeshAsset LineCircle() noexcept;
     /***********************************************************************************/
     /*!
       \brief
@@ -204,7 +205,7 @@ namespace SHADE
         SHMeshData object containing vertex data for the line circle.
     */
     /***********************************************************************************/
-    [[nodiscard]] static SHMeshData LineCapsuleCap() noexcept;
+    [[nodiscard]] static SHMeshAsset LineCapsuleCap() noexcept;
     /***********************************************************************************/
     /*!
       \brief
@@ -239,16 +240,16 @@ namespace SHADE
     /*---------------------------------------------------------------------------------*/
     /* Helper Functions                                                                */
     /*---------------------------------------------------------------------------------*/
-    static Handle<SHMesh> addMeshDataTo(const SHMeshData& meshData, SHMeshLibrary& meshLibrary) noexcept;
-    static Handle<SHMesh> addMeshDataTo(const SHMeshData& meshData, SHGraphicsSystem& gfxSystem) noexcept;
+    static Handle<SHMesh> addMeshDataTo(const SHMeshAsset& meshData, SHMeshLibrary& meshLibrary) noexcept;
+    static Handle<SHMesh> addMeshDataTo(const SHMeshAsset& meshData, SHGraphicsSystem& gfxSystem) noexcept;
 
     /*---------------------------------------------------------------------------------*/
     /* Data Members                                                                    */
     /*---------------------------------------------------------------------------------*/
-    static SHMeshData cubeMesh;
-    static SHMeshData sphereMesh;
-    static SHMeshData lineCubeMesh;
-    static SHMeshData lineCircleMesh;
-    static SHMeshData lineCapsuleCapMesh;
+    static SHMeshAsset cubeMesh;
+    static SHMeshAsset sphereMesh;
+    static SHMeshAsset lineCubeMesh;
+    static SHMeshAsset lineCircleMesh;
+    static SHMeshAsset lineCapsuleCapMesh;
   };
 }

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

@@ -7,7 +7,7 @@
 namespace SHADE
 {
   
-  Handle<SHVkPipeline> SHPipelineLibrary::CreateGraphicsPipelines(std::pair<Handle<SHVkShaderModule>, Handle<SHVkShaderModule>> const& vsFsPair, Handle<SHVkRenderpass> renderpass, Handle<SHSubpass> subpass, SHVertexInputState const& viState/* = SHGraphicsPredefinedData::GetDefaultViState()*/, SHRasterizationState const& rasterState) noexcept
+  Handle<SHVkPipeline> SHPipelineLibrary::CreateGraphicsPipelines(std::pair<Handle<SHVkShaderModule>, Handle<SHVkShaderModule>> const& vsFsPair, Handle<SHVkRenderpass> renderpass, Handle<SHSubpass> subpass, SHGraphicsPredefinedData::SystemType systemType, SHVertexInputState const& viState, SHRasterizationState const& rasterState) noexcept
   {
     std::vector<Handle<SHVkShaderModule>> modules{};
     if (vsFsPair.first)
@@ -17,8 +17,8 @@ namespace SHADE
 
     SHPipelineLayoutParams params
     {
-      .shaderModules = std::move(modules),
-      .predefinedDescSetLayouts = SHGraphicsPredefinedData::GetSystemData(SHGraphicsPredefinedData::SystemType::BATCHING).descSetLayouts
+      .shaderModules = {vsFsPair.first, vsFsPair.second},
+      .predefinedDescSetLayouts = SHGraphicsPredefinedData::GetSystemData(systemType).descSetLayouts
     };
 
     // Create the pipeline layout

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

@@ -34,6 +34,7 @@ namespace SHADE
                                                      std::pair<Handle<SHVkShaderModule>, Handle<SHVkShaderModule>> const& vsFsPair,
                                                      Handle<SHVkRenderpass>                                               renderpass,
                                                      Handle<SHSubpass>                                                    subpass,
+                                                     SHGraphicsPredefinedData::SystemType                                 systemType,
                                                      SHVertexInputState const&                                            viState = SHGraphicsPredefinedData::GetDefaultViState(),
                                                      SHRasterizationState const&                                          rasterState = SHRasterizationState{}
                                                     ) noexcept;

SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp

@@ -565,7 +565,7 @@ namespace SHADE
 
   // 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, Handle<SHVkDescriptorPool> descPool) noexcept
+  void SHRenderGraph::Execute(uint32_t frameIndex, Handle<SHVkDescriptorPool> descPool, const std::initializer_list<std::pair<Handle<SHVkBuffer>, uint32_t>> MESH_DATA) noexcept
   {
     auto cmdBuffer = commandBuffers[frameIndex];
     cmdBuffer->BeginLabeledSegment(name);
@@ -577,6 +577,7 @@ namespace SHADE
     cmdBuffer->ForceSetPipelineLayout(batchingSystemData.dummyPipelineLayout, SH_PIPELINE_TYPE::COMPUTE);
 
     auto const& descMappings = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING);
+
     
     for (auto& node : nodes)
     {
@@ -585,6 +586,15 @@ namespace SHADE
         // bind static global data 
         SHGlobalDescriptorSets::BindStaticGlobalData(cmdBuffer, SH_PIPELINE_TYPE::GRAPHICS, descMappings.at(SHPredefinedDescriptorTypes::STATIC_DATA));
 
+        // Bind all the buffers required for meshes
+        for (auto& [buffer, bindingPoint] : MESH_DATA)
+        {
+          if (buffer->GetUsageBits() & vk::BufferUsageFlagBits::eVertexBuffer)
+            cmdBuffer->BindVertexBuffer(bindingPoint, buffer, 0);
+          else if (buffer->GetUsageBits() & vk::BufferUsageFlagBits::eIndexBuffer)
+            cmdBuffer->BindIndexBuffer(buffer, 0);
+        }
+
         node->Execute(cmdBuffer, descPool, frameIndex);
       }
     }