.editorconfig

@@ -0,0 +1,5 @@
+root = true
+
+[*.{c,cpp,h,hpp}]
+indent_style = space
+indent_size = 2

.gitignore

@@ -362,3 +362,5 @@ MigrationBackup/
 *.csproj
 
 *.filters
+
+Assets/Editor/Layouts/UserLayout.ini

Assets/Cube.003.shmesh.shmeta

@@ -0,0 +1,3 @@
+Name: Cube.003
+ID: 71245919
+Type: 4

Assets/Cube.012.shmesh.shmeta

@@ -0,0 +1,3 @@
+Name: Cube.012
+ID: 80365422
+Type: 4

Assets/Editor/Layouts/Default.ini

@@ -0,0 +1,115 @@
+[Window][MainStatusBar]
+Pos=0,1060
+Size=1920,20
+Collapsed=0
+
+[Window][SHEditorMenuBar]
+Pos=0,48
+Size=1920,1012
+Collapsed=0
+
+[Window][Hierarchy Panel]
+Pos=0,197
+Size=308,863
+Collapsed=0
+DockId=0x00000004,0
+
+[Window][Debug##Default]
+Pos=60,60
+Size=400,400
+Collapsed=0
+
+[Window][Inspector]
+Pos=1528,48
+Size=392,1012
+Collapsed=0
+DockId=0x00000006,0
+
+[Window][Profiler]
+Pos=0,48
+Size=308,147
+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=310,48
+Size=1216,715
+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=310,765
+Size=1216,295
+Collapsed=0
+DockId=0x0000000C,0
+
+[Docking][Data]
+DockSpace           ID=0xC5C9B8AB Window=0xBE4044E9 Pos=8,79 Size=1920,1012 Split=X
+  DockNode          ID=0x00000005 Parent=0xC5C9B8AB SizeRef=1526,1036 Split=X
+    DockNode        ID=0x00000001 Parent=0x00000005 SizeRef=308,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=1216,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,715 CentralNode=1 Selected=0xB41284E7
+          DockNode  ID=0x0000000C Parent=0x00000009 SizeRef=1501,295 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=392,1036 Selected=0xE7039252
+

Assets/RaccoonBag_Color_Ver4.shtex.shmeta

@@ -0,0 +1,3 @@
+Name: RaccoonBag_Color_Ver4
+ID: 58303057
+Type: 3

Assets/RaccoonPreTexturedVer1_Base9.shtex.shmeta

@@ -0,0 +1,3 @@
+Name: RaccoonPreTexturedVer1_Base9
+ID: 64651793
+Type: 3

Assets/Shaders/DeferredComposite_CS.glsl

@@ -0,0 +1,83 @@
+#version 450
+
+struct DirectionalLightStruct
+{
+  vec3 direction;
+  uint isActive;
+  uint cullingMask;
+  vec4 diffuseColor;
+};
+
+struct AmbientLightStruct
+{
+  vec4 ambientColor;
+  float strength;
+  uint isActive;
+  uint cullingMask;
+};
+
+layout(local_size_x = 16, local_size_y = 16) in;
+layout(set = 4, binding = 0, rgba32f) uniform image2D positions;
+layout(set = 4, binding = 1, rgba32f) uniform image2D normals;
+layout(set = 4, binding = 2, rgba8) uniform image2D albedo;
+layout(set = 4, binding = 3, r32ui) uniform uimage2D lightLayerData;
+layout(set = 4, binding = 4, rgba8) uniform image2D targetImage;
+
+layout(set = 1, binding = 0) uniform LightCounts
+{
+  uint directionalLights;
+  uint pointLights;
+  uint spotLights;
+  uint ambientLights;
+
+} lightCounts;
+
+layout(std430, set = 1, binding = 1) buffer DirectionalLightData
+{
+  DirectionalLightStruct dLightData[];
+} DirLightData;
+
+layout(std430, set = 1, binding = 4) buffer AmbientLightData
+{
+  AmbientLightStruct aLightData[];
+} AmbLightData;
+
+void main()
+{ 
+  // convenient variables
+  ivec2 globalThread = ivec2(gl_GlobalInvocationID);
+
+  // Get the diffuse color of the pixel
+  vec3 pixelDiffuse = imageLoad (albedo, globalThread).rgb;
+
+  // Get position of fragment in world space
+  vec3 positionWorld = imageLoad (positions, globalThread).rgb;
+
+  // normal of fragment
+  vec3 normalWorld = imageLoad(normals, globalThread).rgb;
+
+  vec3 fragColor = vec3 (0.0f);
+
+  for (int i = 0; i < lightCounts.directionalLights; ++i)
+  {
+    // get normalized direction of light 
+    vec3 dLightNormalized = normalize (DirLightData.dLightData[i].direction);
+
+    // Get diffuse strength
+    float diffuseStrength = max (0, dot (dLightNormalized, normalWorld));
+
+    // Calculate the fragment color
+    fragColor += DirLightData.dLightData[i].diffuseColor.rgb * diffuseStrength.rrr * pixelDiffuse;
+  }
+
+  for (int i = 0; i < lightCounts.ambientLights; ++i)
+  {
+    // Just do some add
+    //fragColor += pixelDiffuse.rgb * AmbLightData.aLightData[i].ambientColor.rgb * vec3 (0.5f);
+    fragColor += pixelDiffuse.rgb * AmbLightData.aLightData[i].ambientColor.rgb * vec3 (AmbLightData.aLightData[i].strength);
+  }
+
+  // store result into result image
+  imageStore(targetImage, ivec2(gl_GlobalInvocationID.xy), vec4(fragColor, 1.0f));
+
+}

Assets/Shaders/DeferredComposite_CS.shshaderb.shmeta

@@ -0,0 +1,3 @@
+Name: DeferredComposite_CS
+ID: 42814284
+Type: 2

Assets/Shaders/Kirsch_CS.glsl

@@ -0,0 +1,167 @@
+//#version 450
+//
+//layout(local_size_x = 16, local_size_y = 16) in;
+//layout(set = 4, binding = 0, rgba8) uniform image2D targetImage;
+//
+//
+//void main()
+//{
+//  ivec2 imageSize = imageSize (targetImage);
+//
+//  if (gl_GlobalInvocationID.x >= imageSize.x && gl_GlobalInvocationID.y >= imageSize.y)
+//    return;
+//
+//  // load the image
+//  vec4 color = imageLoad (targetImage, ivec2 (gl_GlobalInvocationID));
+//  
+//  // get the average
+//  float average = 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
+//
+//  // store result into result image
+//  imageStore(targetImage, ivec2(gl_GlobalInvocationID), vec4(average, average, average, 1.0f));
+//
+//}
+//
+//
+//
+//
+
+/* Start Header *****************************************************************/
+
+/*! \file (e.g. kirsch.comp)
+
+     \author William Zheng, william.zheng, 60001906. Brandon Mak, brandon.hao 390003920.
+
+     \par william.zheng\@digipen.edu. brandon.hao\@digipen.edu.
+
+     \date Sept 20, 2022
+
+     \brief Copyright (C) 20xx 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. */
+
+  /* End Header *******************************************************************/
+
+#version 450
+
+#define MASK_WIDTH 3
+#define HALF_M_WIDTH MASK_WIDTH / 2
+#define SHM_WIDTH 18
+#define NUM_MASKS 8
+
+layout(local_size_x = 16, local_size_y = 16) in;
+layout(set = 4, binding = 0, rgba8) uniform image2D inputImage;
+layout(set = 4, binding = 1, rgba8) uniform image2D resultImage;
+
+const    float kirsch[8][3][3] = {
+        {
+         {5, 5, 5},
+         {-3, 0, -3},           /*rotation 1 */
+         {-3, -3, -3}
+         },
+        {
+         {5, 5, -3},
+         {5, 0, -3},            /*rotation 2 */
+         {-3, -3, -3}
+         },
+        {
+         {5, -3, -3},
+         {5, 0, -3},            /*rotation 3 */
+         {5, -3, -3}
+         },
+        {
+         {-3, -3, -3},
+         {5, 0, -3},            /*rotation 4 */
+         {5, 5, -3}
+         },
+        {
+         {-3, -3, -3},
+         {-3, 0, -3},           /*rotation 5 */
+         {5, 5, 5}
+         },
+        {
+         {-3, -3, -3},
+         {-3, 0, 5},            /*rotation 6 */
+         {-3, 5, 5}
+         },
+        {
+         {-3, -3, 5},
+         {-3, 0, 5},            /*rotation 7 */
+         {-3, -3, 5}
+         },
+        {
+         {-3, 5, 5},
+         {-3, 0, 5},            /*rotation 8 */
+         {-3, -3, -3}
+         }
+};
+
+vec3 GetImageValues(ivec2 uv, ivec2 inputImageSize)
+{
+  if (uv.x >= 0 && uv.y >= 0 && uv.x < inputImageSize.x && uv.y < inputImageSize.y)
+  {
+    return imageLoad(inputImage, uv).rgb;
+  }
+  else
+    return vec3(0.0f);
+}
+
+//two extra row/col
+shared vec3 sData[16 + 2][16 + 2];
+
+void main()
+{
+  // convenient variables
+  ivec3 globalThread = ivec3(gl_GlobalInvocationID);
+  ivec3 localThread = ivec3(gl_LocalInvocationID);
+  ivec2 inputImageSize = imageSize(inputImage);
+
+  // load shared memory
+  ivec2 start = ivec2(gl_WorkGroupID) * ivec2(gl_WorkGroupSize) - ivec2(HALF_M_WIDTH);
+  for (int i = localThread.x; i < SHM_WIDTH; i += int(gl_WorkGroupSize.x))
+  {
+    for (int j = localThread.y; j < SHM_WIDTH; j += int(gl_WorkGroupSize.y))
+    {
+      // get from source image (either real values or 0)
+      vec3 sourceValue = GetImageValues(start + ivec2(i, j), inputImageSize);
+      sData[i][j] = sourceValue;
+    }
+  }
+
+  // wait for shared memory to finish loading
+  barrier();
+
+  // max (between all 8 masks)
+  vec3 maxSum = vec3(0.0f);
+
+  // loop through all masks 
+  for (int i = 0; i < NUM_MASKS; ++i)
+  {
+    vec3 sum = vec3(0.0f);
+
+    // start of shared memory
+    ivec2 shmStart = ivec2(localThread + HALF_M_WIDTH);
+    for (int j = -1; j < HALF_M_WIDTH + 1; ++j)
+    {
+      for (int k = -1; k < HALF_M_WIDTH + 1; ++k)
+      {
+        // Perform convolution using shared_memory
+        sum += sData[shmStart.x + j][shmStart.y + k] * kirsch[i][j + 1][k + 1];
+      }
+    }
+
+    // Get highest sum
+    maxSum = max(sum, maxSum);
+  }
+
+  // average the max sum
+  maxSum = min(max(maxSum / 8, 0), 1.0f);
+
+  // store result into result image
+  imageStore(resultImage, ivec2(gl_GlobalInvocationID.xy), vec4(maxSum, 1.0f));
+
+}
+
+
+
+

Assets/Shaders/Kirsch_CS.shshaderb.shmeta

@@ -0,0 +1,3 @@
+Name: Kirsch_CS
+ID: 39301863
+Type: 2

Assets/Shaders/PureCopy_CS.glsl

@@ -0,0 +1,67 @@
+//#version 450
+//
+//layout(local_size_x = 16, local_size_y = 16) in;
+//layout(set = 4, binding = 0, rgba8) uniform image2D targetImage;
+//
+//
+//void main()
+//{
+//  ivec2 imageSize = imageSize (targetImage);
+//
+//  if (gl_GlobalInvocationID.x >= imageSize.x && gl_GlobalInvocationID.y >= imageSize.y)
+//    return;
+//
+//  // load the image
+//  vec4 color = imageLoad (targetImage, ivec2 (gl_GlobalInvocationID));
+//  
+//  // get the average
+//  float average = 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
+//
+//  // store result into result image
+//  imageStore(targetImage, ivec2(gl_GlobalInvocationID), vec4(average, average, average, 1.0f));
+//
+//}
+//
+//
+//
+//
+
+/* Start Header *****************************************************************/
+
+/*! \file (e.g. kirsch.comp)
+
+     \author William Zheng, william.zheng, 60001906. Brandon Mak, brandon.hao 390003920.
+
+     \par william.zheng\@digipen.edu. brandon.hao\@digipen.edu.
+
+     \date Sept 20, 2022
+
+     \brief Copyright (C) 20xx 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. */
+
+  /* End Header *******************************************************************/
+
+#version 450
+
+
+layout(local_size_x = 16, local_size_y = 16) in;
+layout(set = 4, binding = 0, rgba8) uniform image2D inputImage;
+layout(set = 4, binding = 1, rgba8) uniform image2D targetImage;
+
+
+void main()
+{
+  // convenient variables
+  ivec2 globalThread = ivec2(gl_GlobalInvocationID);
+
+  vec3 color = imageLoad (inputImage, globalThread).rgb;
+
+  // store result into result image
+  imageStore(targetImage, ivec2(gl_GlobalInvocationID.xy), vec4(color, 1.0f));
+
+}
+
+
+
+

Assets/Shaders/PureCopy_CS.shshaderb.shmeta

@@ -0,0 +1,3 @@
+Name: PureCopy_CS
+ID: 34987209
+Type: 2

Assets/Shaders/TestCube_FS.glsl

@@ -0,0 +1,50 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+#extension GL_EXT_nonuniform_qualifier : require
+
+struct MatPropData
+{
+  vec4 color;
+  int textureIndex;
+  float alpha;
+  vec3 beta;
+};
+
+layout(location = 0) in struct
+{
+  vec4 vertPos; // location 0
+  vec2 uv; // location = 1
+  vec4 normal; // location = 2
+
+} In;
+
+// material stuff
+layout(location = 3) flat in struct
+{
+  int materialIndex;
+  uint eid;
+  uint lightLayerIndex;
+} In2;
+
+layout (set = 0, binding = 1) uniform sampler2D textures[]; // for textures (global)
+layout (std430, set = 3, binding = 0) buffer MaterialProperties     // For materials 
+{
+  MatPropData data[];
+} MatProp;
+
+layout(location = 0) out vec4 position;
+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) + MatProp.data[In2.materialIndex].color / MatProp.data[In2.materialIndex].alpha;
+
+  outEntityID = In2.eid;
+  lightLayerIndices = In2.lightLayerIndex;
+}

Assets/Shaders/TestCube_FS.shshaderb.shmeta

@@ -0,0 +1,3 @@
+Name: TestCube_FS
+ID: 37450402
+Type: 2

Assets/Shaders/TestCube_VS.glsl

@@ -3,24 +3,30 @@
 
 //#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 = 0) out struct
 {
-  vec4 vertColor; // location 0
+  vec4 vertPos; // location 0
   vec2 uv; // location = 1
+  vec4 normal; // location = 2
 
 } Out;
 
 // material stuff
-layout(location = 2) out struct
+layout(location = 3) out struct
 {
   int materialIndex;
+  uint eid;
+  uint lightLayerIndex;
+
 } Out2;
 
 layout(set = 2, binding = 0) uniform CameraData
@@ -31,8 +37,14 @@ layout(set = 2, binding = 0) uniform CameraData
 
 void main()
 {
-  Out.uv = aUV;
+
   Out2.materialIndex = gl_InstanceIndex;
+  Out2.eid             = integerData[0];
+  Out2.lightLayerIndex = integerData[1];
+
+  Out.vertPos = worldTransform * vec4(aVertexPos, 1.0f);
+  Out.uv = aUV;
+  Out.normal.rgb = mat3(transpose(inverse(worldTransform))) * aNormal.rgb;
+  Out.normal.rgb = normalize (Out.normal.rgb);
   gl_Position = cameraData.vpMat * worldTransform * vec4 (aVertexPos, 1.0f);
-  Out.vertColor = vec4 (aVertexPos, 1.0f);
 }

Assets/Shaders/TestCube_VS.shshaderb.shmeta

@@ -0,0 +1,3 @@
+Name: TestCube_VS
+ID: 41688429
+Type: 2

Assets/TD_Checker_Base_Color.shtex.shmeta

@@ -0,0 +1,3 @@
+Name: TD_Checker_Base_Color
+ID: 51995224
+Type: 3

SHADE_Application/premake5.lua

@@ -30,13 +30,15 @@ project "SHADE_Application"
   
   externalincludedirs
   {
-	"%{IncludeDir.spdlog}/include",
+  "%{IncludeDir.RTTR}\\include",
-	"%{IncludeDir.VULKAN}/include",
-	"%{IncludeDir.VMA}/include",
-	"%{IncludeDir.VULKAN}/Source/SPIRV-Reflect",
-  "%{IncludeDir.tinyddsloader}",
   "%{IncludeDir.fmod}/include",
-  "%{IncludeDir.RTTR}\\include"
+	"%{IncludeDir.VULKAN}/Source/SPIRV-Reflect",
+	"%{IncludeDir.VMA}/include",
+	"%{IncludeDir.VULKAN}/include",
+	"%{IncludeDir.spdlog}/include",
+  "%{IncludeDir.tinyddsloader}",
+  "%{IncludeDir.reactphysics3d}\\include",
+  "%{IncludeDir.yamlcpp}"
   }
     
   externalwarnings "Off"
@@ -50,6 +52,7 @@ project "SHADE_Application"
   {
     "SHADE_Engine",
     "SHADE_Managed",
+    "yaml-cpp",
     "SDL2.lib",
     "SDL2main.lib"
   }
@@ -57,7 +60,7 @@ project "SHADE_Application"
   libdirs
   {
     "%{IncludeDir.spdlog}/lib",
-    "%{IncludeDir.SDL}/lib",
+    "%{IncludeDir.SDL}/lib"
   }
   
   defines
@@ -67,9 +70,16 @@ project "SHADE_Application"
 
   disablewarnings
   {
-    "4251"
+    "4251",
+    "26812",
+    "26439",
+    "26451",
+    "26437",
+    "4275"
   }
 
+  linkoptions { "-IGNORE:4006" }
+
   warnings 'Extra'
   
   filter "configurations:Debug"

SHADE_Application/src/Application/SBApplication.cpp

@@ -4,7 +4,7 @@
 
 //#define SHEDITOR
 #ifdef SHEDITOR
-#include "Editor/SHEditor.hpp"
+#include "Editor/SHEditor.h"
 //#include "Scenes/SBEditorScene.h"
 #endif // SHEDITOR
 
@@ -14,21 +14,30 @@
 #include <chrono>
 #include <ratio>
 #include <ctime>
-#define SDL_HINT_VIDEO_FOREIGN_WINDOW_VULKAN 1
 #include <SDL.h>
 
-#include "Scripting/SHScriptEngine.h"
+
 #include "Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.h"
+
+// Managers
 #include "ECS_Base/Managers/SHEntityManager.h"
-#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
 #include "Scene/SHSceneManager.h"
+
+// Systems
+#include "Scripting/SHScriptEngine.h"
+#include "Physics/SHPhysicsSystem.h"
 #include "Math/Transform/SHTransformSystem.h"
-#include "Input/SHInputManagerSystem.h"
+#include "Input/SHInputManager.h"
 #include "FRC/SHFramerateController.h"
-//#include "AudioSystem/SHAudioSystem.h"
+#include "AudioSystem/SHAudioSystem.h"
+#include "Camera/SHCameraSystem.h"
+
+// Components
+#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
+#include "Math/Transform/SHTransformComponent.h"
 
 #include "Scenes/SBTestScene.h"
-#include "Math/Transform/SHTransformComponent.h"
+
 
 #include "Assets/SHAssetManager.h"
 
@@ -47,66 +56,72 @@ namespace Sandbox
     _In_      INT       nCmdShow
   )
   {
-	  // Set working directory
+    // Set working directory
-	  SHADE::SHFileUtilities::SetWorkDirToExecDir();
+    SHFileUtilities::SetWorkDirToExecDir();
 
     window.Create(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
 
     // Create Systems
-    SHADE::SHSystemManager::CreateSystem<SHADE::SHGraphicsSystem>();
+    SHSystemManager::CreateSystem<SHGraphicsSystem>();
-    SHADE::SHSystemManager::CreateSystem<SHADE::SHScriptEngine>();
+    SHSystemManager::CreateSystem<SHScriptEngine>();
-    // TODO(Diren): Create Physics System here
+    SHSystemManager::CreateSystem<SHPhysicsSystem>();
-    SHADE::SHSystemManager::CreateSystem<SHADE::SHTransformSystem>();
+    SHSystemManager::CreateSystem<SHTransformSystem>();
-    SHADE::SHGraphicsSystem* graphicsSystem = static_cast<SHADE::SHGraphicsSystem*>(SHADE::SHSystemManager::GetSystem<SHADE::SHGraphicsSystem>());
+    SHGraphicsSystem* graphicsSystem = static_cast<SHGraphicsSystem*>(SHSystemManager::GetSystem<SHGraphicsSystem>());
-    SHADE::SHSystemManager::CreateSystem<SHADE::SHInputManagerSystem>();
+    SHSystemManager::CreateSystem<SHAudioSystem>();
-    //SHADE::SHSystemManager::CreateSystem<SHADE::SHAudioSystem>();
+    SHSystemManager::CreateSystem<SHCameraSystem>();
+    
+#ifdef SHEDITOR
+    SDL_Init(SDL_INIT_VIDEO);
+    sdlWindow = SDL_CreateWindowFrom(window.GetHWND());
+    SHSystemManager::CreateSystem<SHEditor>();
+    SHSystemManager::GetSystem<SHEditor>()->SetSDLWindow(sdlWindow);
+#endif
     
     // Create Routines
-    SHADE::SHSystemManager::RegisterRoutine<SHADE::SHScriptEngine, SHADE::SHScriptEngine::FrameSetUpRoutine>();
+    SHSystemManager::RegisterRoutine<SHScriptEngine, SHScriptEngine::FrameSetUpRoutine>();
-    SHADE::SHSystemManager::RegisterRoutine<SHADE::SHScriptEngine, SHADE::SHScriptEngine::UpdateRoutine>();
+    SHSystemManager::RegisterRoutine<SHScriptEngine, SHScriptEngine::UpdateRoutine>();
-    SHADE::SHSystemManager::RegisterRoutine<SHADE::SHScriptEngine, SHADE::SHScriptEngine::LateUpdateRoutine>();
+    SHSystemManager::RegisterRoutine<SHScriptEngine, SHScriptEngine::LateUpdateRoutine>();
-    SHADE::SHSystemManager::RegisterRoutine<SHADE::SHScriptEngine, SHADE::SHScriptEngine::FrameCleanUpRoutine>();
+    SHSystemManager::RegisterRoutine<SHScriptEngine, SHScriptEngine::FrameCleanUpRoutine>();
 
-    // TODO(Diren): Register Physics System & Routines here
+    SHSystemManager::RegisterRoutine<SHTransformSystem, SHTransformSystem::TransformPostLogicUpdate>();
 
-    SHADE::SHSystemManager::RegisterRoutine<SHADE::SHTransformSystem, SHADE::SHTransformSystem::TransformUpdateRoutine>();
+    SHSystemManager::RegisterRoutine<SHPhysicsSystem, SHPhysicsSystem::PhysicsPreUpdate>();
-    SHADE::SHComponentManager::CreateComponentSparseSet<SHADE::SHTransformComponent>();
+    SHSystemManager::RegisterRoutine<SHPhysicsSystem, SHPhysicsSystem::PhysicsFixedUpdate>();
+    SHSystemManager::RegisterRoutine<SHPhysicsSystem, SHPhysicsSystem::PhysicsPostUpdate>();
 
-    SHADE::SHSystemManager::RegisterRoutine<SHADE::SHGraphicsSystem, SHADE::SHGraphicsSystem::BatcherDispatcherRoutine>();
+    SHSystemManager::RegisterRoutine<SHTransformSystem, SHTransformSystem::TransformPostPhysicsUpdate>();
-    SHADE::SHSystemManager::RegisterRoutine<SHADE::SHGraphicsSystem, SHADE::SHGraphicsSystem::BeginRoutine>();
-    SHADE::SHSystemManager::RegisterRoutine<SHADE::SHGraphicsSystem, SHADE::SHGraphicsSystem::RenderRoutine>();
-    SHADE::SHSystemManager::RegisterRoutine<SHADE::SHGraphicsSystem, SHADE::SHGraphicsSystem::EndRoutine>();
 
-    SHADE::SHComponentManager::CreateComponentSparseSet<SHADE::SHRenderable>();
+    SHSystemManager::RegisterRoutine<SHGraphicsSystem, SHGraphicsSystem::BatcherDispatcherRoutine>();
-    SHADE::SHComponentManager::CreateComponentSparseSet<SHADE::SHTransformComponent>();
+    SHSystemManager::RegisterRoutine<SHGraphicsSystem, SHGraphicsSystem::BeginRoutine>();
 
-    SHADE::SHSystemManager::RegisterRoutine<SHADE::SHInputManagerSystem, SHADE::SHInputManagerSystem::InputManagerRoutine>();
+    //SHSystemManager::RegisterRoutine<SHCameraSystem, SHCameraSystem::EditorCameraUpdate>();
+    SHSystemManager::RegisterRoutine<SHCameraSystem, SHCameraSystem::CameraSystemUpdate>();
+    
+#ifdef SHEDITOR
+    SHSystemManager::RegisterRoutine<SHEditor, SHEditor::EditorRoutine>();
+#endif
 
-    //TODO: REMOVE AFTER PRESENTATION
+    SHSystemManager::RegisterRoutine<SHGraphicsSystem, SHGraphicsSystem::RenderRoutine>();
-    SHADE::SHAssetManager::LoadDataTemp("../../Assets/racoon.gltf");
+    SHSystemManager::RegisterRoutine<SHGraphicsSystem, SHGraphicsSystem::EndRoutine>();
-    SHADE::SHAssetManager::LoadDataTemp("../../Assets/RaccoonBag_Color_Ver4.dds");
-    SHADE::SHAssetManager::LoadDataTemp("../../Assets/RaccoonPreTexturedVer1_Base9.dds");
-    SHADE::SHAssetManager::LoadDataTemp("../../Assets/TD_Checker_Base_Color.dds");
 
+    SHComponentManager::CreateComponentSparseSet<SHRigidBodyComponent>();
+    SHComponentManager::CreateComponentSparseSet<SHColliderComponent>();
+    SHComponentManager::CreateComponentSparseSet<SHTransformComponent>();
+    SHComponentManager::CreateComponentSparseSet<SHRenderable>();
+    SHComponentManager::CreateComponentSparseSet<SHCameraComponent>();
+
+    SHAssetManager::Load();
 
     auto id = SHFamilyID<SHSystem>::GetID<SHGraphicsSystem>();
     auto id2 = SHFamilyID<SHSystem>::GetID<SHGraphicsSystem>();
     auto id3 = SHFamilyID<SHSystem>::GetID<SHGraphicsSystem>();
-    //TODO: REMOVE AFTER PRESENTATION
     
-    //SHADE::SHSystemManager::RegisterRoutine<SHADE::SHAudioSystem, SHADE::SHAudioSystem::AudioRoutine>();
+    SHSystemManager::RegisterRoutine<SHAudioSystem, SHAudioSystem::AudioRoutine>();
 
     // Set up graphics system and windows
     graphicsSystem->SetWindow(&window);
     
-    SHADE::SHSystemManager::Init();
+    SHSystemManager::Init();
-	#ifdef SHEDITOR
-    SDL_Init(SDL_INIT_VIDEO);
-    sdlWindow = SDL_CreateWindowFrom(window.GetHWND());
-    SHADE::SHEditor::Initialise(sdlWindow);
-	#else
-	#endif
-
 
     SHSceneManager::InitSceneManager<SBTestScene>("TestScene");
     
@@ -115,39 +130,36 @@ namespace Sandbox
 
   void SBApplication::Update(void)
   {
-    SHADE::SHGraphicsSystem* graphicsSystem = static_cast<SHADE::SHGraphicsSystem*>(SHADE::SHSystemManager::GetSystem<SHADE::SHGraphicsSystem>());
+    SHGraphicsSystem* graphicsSystem = SHADE::SHSystemManager::GetSystem<SHGraphicsSystem>();
+    SHEditor* editor = SHADE::SHSystemManager::GetSystem<SHEditor>();
     //TODO: Change true to window is open
     while (!window.WindowShouldClose())
     {
       SHFrameRateController::UpdateFRC();
+      SHInputManager::UpdateInput(SHFrameRateController::GetRawDeltaTime());
       SHSceneManager::UpdateSceneManager();
-      SHSceneManager::SceneUpdate(1/60.0f);
+#ifdef SHEDITOR
-      //#ifdef SHEDITOR
+      if(editor->editorState == SHEditor::State::PLAY)
-      //#endif
+        SHSceneManager::SceneUpdate(0.016f);
-      graphicsSystem->BeginRender();
+#endif
-			
+      SHSystemManager::RunRoutines(editor->editorState != SHEditor::State::PLAY, 0.016f);
-      #ifdef SHEDITOR
+      editor->PollPicking();
-      SHADE::SHEditor::Update(0.16f);
-			#endif
-
-      graphicsSystem->Run(1.0f);
-      graphicsSystem->EndRender();
-	  
-      SHADE::SHSystemManager::RunRoutines(false, 0.016f);
     }
+    // Finish all graphics jobs first
+    graphicsSystem->AwaitGraphicsExecution();
   }
 
 
   void SBApplication::Exit(void)
   {
-	#ifdef SHEDITOR
+  #ifdef SHEDITOR
-    SHADE::SHEditor::Exit();
     SDL_DestroyWindow(sdlWindow);
     SDL_Quit();
-    #endif
+  #endif
 
     SHSceneManager::Exit();
-    SHADE::SHSystemManager::Exit();
+    SHSystemManager::Exit();
+    SHAssetManager::Exit();
   }
 }
 

SHADE_Application/src/Scenes/SBTestScene.cpp

@@ -1,4 +1,4 @@
-#include "SBpch.h"
+ #include "SBpch.h"
 #include "SBTestScene.h"
 
 #include "ECS_Base/Managers/SHSystemManager.h"
@@ -10,17 +10,22 @@
 #include "Scripting/SHScriptEngine.h"
 #include "Math/Transform/SHTransformComponent.h"
 #include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h"
+#include "Physics/Components/SHRigidBodyComponent.h"
+#include "Physics/Components/SHColliderComponent.h"
+#include "Graphics/MiddleEnd/Lights/SHLightComponent.h"
 
 #include "Assets/SHAssetManager.h"
+#include "Camera/SHCameraComponent.h"
+#include "Resource/SHResourceManager.h"
 
 using namespace SHADE;
 
 namespace Sandbox
 {
 
-  void SBTestScene::WindowFocusFunc([[maybe_unused]]void* window, int focused)
+  void SBTestScene::WindowFocusFunc([[maybe_unused]] void* window, int focused)
   {
-    if(focused)
+    if (focused)
     {
     }
     else
@@ -38,144 +43,155 @@ namespace Sandbox
     const auto CUBE_MESH = SHADE::SHPrimitiveGenerator::Cube(*graphicsSystem);
 
     //Test Racoon mesh
-    auto meshes = SHADE::SHAssetManager::GetAllMeshes();
     std::vector<Handle<SHMesh>> handles;
-    for (auto const& mesh : meshes)
+    std::vector<Handle<SHTexture>> texHandles;
+    for (const auto& asset : SHAssetManager::GetAllAssets())
     {
-      if (mesh.meshName == "Cube.012")
+      switch (asset.type)
       {
-			handles.push_back(graphicsSystem->AddMesh(
+        case AssetType::MESH:
-	        mesh.header.vertexCount,
+          if (asset.name == "Cube.012")
-	        mesh.vertexPosition.data(),
+          handles.emplace_back(SHResourceManager::LoadOrGet<SHMesh>(asset.id));
-	        mesh.texCoords.data(),
+          break;
-	        mesh.vertexTangent.data(),
+        case AssetType::TEXTURE:
-	        mesh.vertexNormal.data(),
+          if (asset.name == "RaccoonPreTexturedVer1_Base9")
-	        mesh.header.indexCount,
+          texHandles.emplace_back(SHResourceManager::LoadOrGet<SHTexture>(asset.id));
-	        mesh.indices.data()
+          break;
-	      ));
       }
     }
-    graphicsSystem->BuildMeshBuffers();
+    SHResourceManager::FinaliseChanges();
-
-    // Load Textures
-    auto textures = SHADE::SHAssetManager::GetAllTextures();
-    std::vector<Handle<SHTexture>> texHandles;
-    for (const auto& tex : textures)
-    {
-        auto texture = graphicsSystem->Add(tex);
-        texHandles.push_back(texture);
-    }
-    graphicsSystem->BuildTextures();
 
     // Create Materials
     auto matInst = graphicsSystem->AddOrGetBaseMaterialInstance();
     auto customMat = graphicsSystem->AddMaterialInstanceCopy(matInst);
     customMat->SetProperty("data.color", SHVec4(0.0f, 1.0f, 1.0f, 1.0f));
-    customMat->SetProperty("data.textureIndex", 1);
+    customMat->SetProperty("data.textureIndex", 0);
     customMat->SetProperty("data.alpha", 0.1f);
 
     // Create Stress Test Objects
-    static const SHVec3 TEST_OBJ_SCALE = { 0.05f, 0.05f, 0.05f };
+    static const SHVec3 TEST_OBJ_SCALE = SHVec3::One;
-    constexpr int NUM_ROWS = 100;
+    constexpr int NUM_ROWS = 3;
-    constexpr int NUM_COLS = 100;
+    constexpr int NUM_COLS = 1;
-    static const SHVec3 TEST_OBJ_SPACING = { 0.05f, 0.05f, 0.05f };
+    static const SHVec3 TEST_OBJ_SPACING = { 0.1f, 0.1f, 0.1f };
-    static const SHVec3 TEST_OBJ_START_POS = { - (NUM_COLS / 2 * TEST_OBJ_SPACING.x ) + 1.0f, -2.0f, -1.0f };
+    static const SHVec3 TEST_OBJ_START_POS = { -(NUM_COLS / 2 * TEST_OBJ_SPACING.x) + 1.0f, -2.0f, -1.0f };
 
     for (int y = 0; y < NUM_ROWS; ++y)
-    for (int x = 0; x < NUM_COLS; ++x)
+      for (int x = 0; x < NUM_COLS; ++x)
-    {
+      {
-        auto entity      = SHEntityManager::CreateEntity<SHRenderable, SHTransformComponent>();
+        auto entity = SHEntityManager::CreateEntity<SHRenderable, SHTransformComponent, SHRigidBodyComponent, SHColliderComponent>();
         auto& renderable = *SHComponentManager::GetComponent_s<SHRenderable>(entity);
-        auto& transform  = *SHComponentManager::GetComponent_s<SHTransformComponent>(entity);
+        auto& transform = *SHComponentManager::GetComponent_s<SHTransformComponent>(entity);
+        auto& collider = *SHComponentManager::GetComponent_s<SHColliderComponent>(entity);
 
-        renderable.Mesh = handles.front();
+        //renderable.Mesh = handles.front();
+        renderable.SetMesh(CUBE_MESH);
         renderable.SetMaterial(customMat);
 
         if (y == 50)
           renderable.GetModifiableMaterial()->SetProperty("data.color", SHVec4(1.0f, 0.0f, 0.0f, 1.0f));
 
         //Set initial positions
-          transform.SetWorldPosition(TEST_OBJ_START_POS + SHVec3{
+        transform.SetWorldPosition(TEST_OBJ_START_POS + SHVec3{ x * TEST_OBJ_SPACING.x, y * TEST_OBJ_SPACING.y, SHMath::GenerateRandomNumber(-3.5f, -5.0f) });
-                                                                  x * TEST_OBJ_SPACING.x,
-                                                                  y * TEST_OBJ_SPACING.y,
-                                                                  0.0f
-            });
         //transform.SetWorldPosition({-1.0f, -1.0f, -1.0f});
-        //transform.SetWorldRotation(3.14159265f * 1.5f, -3.14159265f / 2.0f, 0.0f);
+        transform.SetWorldRotation(SHMath::GenerateRandomNumber(0.0f, 360.0f), SHMath::GenerateRandomNumber(0.0f, 360.0f), SHMath::GenerateRandomNumber(0.0f, 360.0f));
-        transform.SetLocalScale(TEST_OBJ_SCALE);
+        transform.SetWorldScale(TEST_OBJ_SCALE);
 
+        collider.AddBoundingBox(SHVec3::One, SHVec3::Zero);
         stressTestObjects.emplace_back(entity);
-    }
+      }
 
     auto raccoonSpin = SHEntityManager::CreateEntity<SHRenderable, SHTransformComponent>();
     auto& renderable = *SHComponentManager::GetComponent_s<SHRenderable>(raccoonSpin);
     auto& transform = *SHComponentManager::GetComponent_s<SHTransformComponent>(raccoonSpin);
 
-    renderable.Mesh = handles.front();
+    renderable.SetMesh(handles.front());
     renderable.SetMaterial(customMat);
     renderable.GetModifiableMaterial()->SetProperty("data.color", SHVec4(0.0f, 0.0f, 0.0f, 0.0f));
     renderable.GetModifiableMaterial()->SetProperty("data.alpha", 1.0f);
-    renderable.GetModifiableMaterial()->SetProperty("data.textureIndex", 1);
+    renderable.GetModifiableMaterial()->SetProperty("data.textureIndex", 0);
 
-    transform.SetWorldPosition ({-3.0f, -1.0f, -1.0f});
+    transform.SetWorldPosition({ -3.0f, -1.0f, -1.0f });
-    transform.SetLocalScale({5.0f, 5.0f, 5.0f});
+    transform.SetLocalScale({ 5.0f, 5.0f, 5.0f });
 
-    //auto entity = SHEntityManager::CreateEntity<SHRenderable, SHTransformComponent>();
+    auto floor = SHEntityManager::CreateEntity<SHRenderable, SHTransformComponent, SHRigidBodyComponent, SHColliderComponent>();
-    //auto& renderable = *SHComponentManager::GetComponent_s<SHRenderable>(entity);
+    auto& floorRenderable = *SHComponentManager::GetComponent_s<SHRenderable>(floor);
-    //auto& transform = *SHComponentManager::GetComponent_s<SHTransformComponent>(entity);
+    auto& floorTransform = *SHComponentManager::GetComponent_s<SHTransformComponent>(floor);
+    auto& floorRigidBody = *SHComponentManager::GetComponent_s<SHRigidBodyComponent>(floor);
+    auto& floorCollider = *SHComponentManager::GetComponent_s<SHColliderComponent>(floor);
 
-    //renderable.Mesh = handles.back();
+    floorRenderable.SetMesh(CUBE_MESH);
-    //renderable.SetMaterial(customMat);
+    floorRenderable.SetMaterial(graphicsSystem->GetDefaultMaterialInstance());
 
-    //transform.SetLocalScale(TEST_OBJ_SCALE);
+    floorTransform.SetWorldScale({ 7.5f, 0.5f, 7.5 });
-    //transform.SetWorldPosition({-1.0f, -1.0f, -1.0f});
+    floorTransform.SetWorldPosition({ 0.0f, -3.0f, -5.0f });
+
+    floorRigidBody.SetType(SHRigidBodyComponent::Type::STATIC);
+
+    auto* floorBox = floorCollider.AddBoundingBox();
+    floorBox->SetHalfExtents(floorTransform.GetWorldScale() * 0.5f);
 
     // Create blank entity with a script
     //testObj = SHADE::SHEntityManager::CreateEntity<SHRenderable, SHTransformComponent>();
-    //auto& testObjRenderable = *SHComponentManager::GetComponent_s<SHRenderable>(testObj);
+    //auto& testObjRenderable = *SHComponentManager::GetComponent<SHRenderable>(testObj);
     //testObjRenderable.Mesh = CUBE_MESH;
     //testObjRenderable.SetMaterial(matInst);
 
+
     SHADE::SHScriptEngine* scriptEngine = static_cast<SHADE::SHScriptEngine*>(SHADE::SHSystemManager::GetSystem<SHADE::SHScriptEngine>());
-	scriptEngine->AddScript(raccoonSpin, "RaccoonSpin");
+    scriptEngine->AddScript(raccoonSpin, "RaccoonSpin");
 
-	auto raccoonShowcase = SHEntityManager::CreateEntity<SHRenderable, SHTransformComponent>();
+    auto raccoonShowcase = SHEntityManager::CreateEntity<SHRenderable, SHTransformComponent>();
-	auto& renderableShowcase = *SHComponentManager::GetComponent_s<SHRenderable>(raccoonShowcase);
+    auto& renderableShowcase = *SHComponentManager::GetComponent_s<SHRenderable>(raccoonShowcase);
-	auto& transformShowcase = *SHComponentManager::GetComponent_s<SHTransformComponent>(raccoonShowcase);
+    auto& transformShowcase = *SHComponentManager::GetComponent_s<SHTransformComponent>(raccoonShowcase);
 
-	renderableShowcase.Mesh = handles.front();
+    renderableShowcase.SetMesh(handles.front());
-	renderableShowcase.SetMaterial(customMat);
+    renderableShowcase.SetMaterial(customMat);
-	renderableShowcase.GetModifiableMaterial()->SetProperty("data.color", SHVec4(0.0f, 0.0f, 0.0f, 0.0f));
+    renderableShowcase.GetModifiableMaterial()->SetProperty("data.color", SHVec4(0.0f, 0.0f, 0.0f, 0.0f));
-	renderableShowcase.GetModifiableMaterial()->SetProperty("data.alpha", 1.0f);
+    renderableShowcase.GetModifiableMaterial()->SetProperty("data.alpha", 1.0f);
-	renderableShowcase.GetModifiableMaterial()->SetProperty("data.textureIndex", 1);
+    renderableShowcase.GetModifiableMaterial()->SetProperty("data.textureIndex", 0);
 
-	transformShowcase.SetWorldPosition({ 3.0f, -1.0f, -1.0f });
+    transformShowcase.SetWorldPosition({ 3.0f, -1.0f, -1.0f });
-	transformShowcase.SetLocalScale({ 5.0f, 5.0f, 5.0f });
+    transformShowcase.SetLocalScale({ 5.0f, 5.0f, 5.0f });
-	scriptEngine->AddScript(raccoonShowcase, "RaccoonShowcase");
+    scriptEngine->AddScript(raccoonShowcase, "RaccoonShowcase");
+
+    SHComponentManager::AddComponent<SHCameraComponent>(0);
+    SHComponentManager::AddComponent<SHLightComponent>(0);
+    SHComponentManager::RemoveComponent <SHRigidBodyComponent>(0);
+    SHComponentManager::RemoveComponent <SHColliderComponent>(0);
+
+    auto ambientLight = SHEntityManager::CreateEntity<SHLightComponent>();
+    SHComponentManager::GetComponent<SHLightComponent>(ambientLight)->SetColor(SHVec4(1.0f, 1.0f, 1.0f, 1.0f));
+    SHComponentManager::GetComponent<SHLightComponent>(ambientLight)->SetStrength(0.25f);
+    SHComponentManager::GetComponent<SHLightComponent>(ambientLight)->SetType(SH_LIGHT_TYPE::AMBIENT);
   }
 
   void SBTestScene::Update(float dt)
   {
     static float rotation = 0.0f;
+    SHVec3 direction{0.0f, 0.0f, 1.0f};
+    direction = SHVec3::RotateY(direction, rotation);
 
+    auto* lightComp =SHComponentManager::GetComponent<SHLightComponent>(0);
+    lightComp->SetDirection (direction);
+    rotation += 0.005f;
     //auto& transform = *SHADE::SHComponentManager::GetComponent_s<SHADE::SHTransformComponent>(testObj);
 
     //transform.SetWorldPosition({1.0f, 1.0f, -1.0f});
     //transform.SetWorldRotation(0.0f, 0.0f + rotation, 0.0f);
     //rotation += dt * 0.2f;
-    
+
     // Destroy entity if space is pressed
     if (GetKeyState(VK_SPACE) & 0x8000)
     {
       rotation = 0.0f;
-        SHADE::SHScriptEngine* scriptEngine = static_cast<SHADE::SHScriptEngine*>(SHADE::SHSystemManager::GetSystem<SHADE::SHScriptEngine>());
+      SHADE::SHScriptEngine* scriptEngine = static_cast<SHADE::SHScriptEngine*>(SHADE::SHSystemManager::GetSystem<SHADE::SHScriptEngine>());
-        scriptEngine->RemoveAllScripts(testObj);
+      scriptEngine->RemoveAllScripts(testObj);
     }
   }
 
   void SBTestScene::Render()
   {
-    
+
   }
 
   void SBTestScene::Unload()
@@ -186,8 +202,4 @@ namespace Sandbox
   {
     //SHSerialization::SerializeScene("resources/scenes/Scene01.SHADE");
   }
-
 }
-
-
-

SHADE_CSharp/premake5.lua

@@ -0,0 +1,52 @@
+project "SHADE_CSharp"
+  architecture "x64"
+  kind "SharedLib"
+  language "C#"
+  clr "NetCore"
+  dotnetframework "net5.0"
+  namespace ("SHADE")
+  targetdir (outputdir)
+  objdir    (interdir)
+  systemversion "latest"
+
+  files  
+  {
+    "%{prj.location}/src/**.cs",
+    "%{prj.location}/src/**.tt"
+  }
+
+  flags
+  {
+  	"MultiProcessorCompile"
+  }
+
+  dependson
+  {
+    "SHADE_Engine"
+  }
+
+  warnings 'Extra'
+  
+  filter "configurations:Debug"
+    symbols "On"
+    defines {"_DEBUG"}
+  
+  filter "configurations:Release"
+    optimize "On"
+    defines{"_RELEASE"}
+
+  filter "configurations:Publish"
+    optimize "On"
+    defines{"_RELEASE"}
+
+  require "vstudio"
+
+  function platformsElement(cfg)
+    _p(2,'<Platforms>x64</Platforms>')
+  end
+
+  premake.override(premake.vstudio.cs2005.elements, "projectProperties", function (oldfn, cfg)
+    return table.join(oldfn(cfg), {
+      platformsElement,
+    })
+  end)

SHADE_CSharp/src/Events/CallbackAction.tt

@@ -0,0 +1,149 @@
+<#
+/************************************************************************************//*!
+\file           CallbackAction.tt
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Oct 23, 2022
+\brief          Contains the T4 template for the definition of CallbackAction and
+                related classes.
+ 
+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.
+*//*************************************************************************************/#>
+<#@ template hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+<# var max = 10; #>
+/************************************************************************************//*!
+\file           CallbackAction.cs
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Oct 23, 2022
+\brief          Contains the definition of CallbackAction and related classes.
+ 
+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.
+*//*************************************************************************************/
+using System;
+using System.Reflection;
+
+namespace SHADE
+{
+    /// <summary>
+    /// Interface for a CallbackAction that all variants inherit from.
+    /// </summary>
+    public interface ICallbackAction
+    {
+        /// <summary>
+        /// Whether or not this CallbackAction is runtime assigned. If it is, then the
+        /// TargetMethodName and TargetObject properties are invalid.
+        /// </summary>
+        bool IsRuntimeAction { get; }
+        /// <summary>
+        /// Name of the method that this CallbackAction is using.
+        /// </summary>
+        string TargetMethodName { get; }
+        /// <summary>
+        /// Object which the specified target method is called on.
+        /// </summary>
+        Object TargetObject { get; }
+    }
+
+<# for (int i = 1; i <= max; ++i) { #>
+    /// <summary>
+    /// Represents a function call that can be serialised and put togetheer with scripts.
+    /// This variant accepts functions with <#=i#> parameter<# if (i > 1) {#>s<#} #>.
+    /// </summary>
+    public class CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> : ICallbackAction
+    {
+        #region Properties ------------------------------------------------------------
+        /// <inheritdoc/>
+        public Object TargetObject { get; private set; }
+        /// <inheritdoc/>
+        public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name;
+        /// <inheritdoc/>
+        public bool IsRuntimeAction => targetAction != null;
+        #endregion
+
+        #region Fields ------------------------------------------------------------------
+        private MethodInfo targetMethod;
+        private Action<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> targetAction;
+        private Object[] parameters;
+        #endregion
+
+        #region Constructors ------------------------------------------------------------
+        /// <summary>
+        /// Constructs an empty Callback action.
+        /// </summary>
+        public CallbackAction() {}
+        /// <summary>
+        /// Constructs a CallbackAction that represents a call to the specified static 
+        /// method.
+        /// </summary>
+        /// <param name="method">Method to call.</param>
+        /// <exception cref="ArgumentException">
+        /// Thrown if a method that is not compatible with the target is specified. The method's
+        /// source type must match the target's type.
+        /// </exception>
+        public CallbackAction(MethodInfo method)
+        {
+            // No errors, assign
+            targetMethod = method;
+
+            // Create storage for parameters for calling
+            parameters = new Object[<#=i#>];
+        }
+        /// <summary>
+        /// Constructs a CallbackAction that represents a call to a specified member 
+        /// method on the specified target.
+        /// </summary>
+        /// <param name="target">Object to call the method on.</param>
+        /// <param name="method">Method to call.</param>
+        /// <exception cref="ArgumentException">
+        /// Thrown if a method that is not compatible with the target is specified. The method's
+        /// source type must match the target's type.
+        /// </exception>
+        public CallbackAction(Object target, MethodInfo method)
+        {
+            // Error Checks
+            if (method.DeclaringType != target.GetType())
+                throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method.");
+
+            // No errors, assign
+            TargetObject = target;
+            targetMethod = method;
+
+            // Create storage for parameters for calling
+            parameters = new Object[<#=i#>];
+        }
+        /// <summary>
+        /// Constructs a Callback action based on an action.
+        /// </summary>
+        /// <param name="action">Action that wraps a function to be called.</param>
+        public CallbackAction(Action<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> action)
+        {
+            targetAction = action;
+        }
+        #endregion
+
+        #region Usage Functions ---------------------------------------------------------
+        /// <summary>
+        /// Invokes the CallbackAction's stored method/action with the specified parameters.
+        /// </summary>
+        public void Invoke(<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#> t<#=t#><# if (t != i) { #>, <# } #><# } #>)
+        {
+            if (targetAction != null)
+            {
+                targetAction.Invoke(<# for (int t = 1; t < i + 1; ++t) { #>t<#=t#><# if (t != i) { #>, <# } #><# } #>);
+            }
+            else if (targetMethod != null)
+            {                
+                <# for (int t = 0; t < i; ++t) {#>parameters[<#=t#>] = t<#=t+1#>;
+                <# } #>_ = targetMethod.Invoke(TargetObject, parameters);
+            }
+        }
+        #endregion
+    }
+<# } #>
+}

SHADE_CSharp/src/Events/CallbackEvent.cs

@@ -0,0 +1,908 @@
+/************************************************************************************//*!
+\file           CallbackEvent.cs
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Oct 23, 2022
+\brief          Contains the definition of CallbackEvent and related classes.
+ 
+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.
+*//*************************************************************************************/
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Reflection.Metadata.Ecma335;
+
+namespace SHADE
+{
+    /// <summary>
+    /// Interface for a CallbackEvent that all variants inherit from.
+    /// </summary>
+    public interface ICallbackEvent
+    { 
+        /// <summary>
+        /// Registers an empty ICallbackAction.
+        /// </summary>
+        void RegisterAction();
+        /// <summary>
+        /// Registers an ICallbackAction with the event such that it will be called in
+        /// future
+        /// </summary>
+        /// <param name="action">ICallbackAction to register with.</param>
+        void RegisterAction(ICallbackAction action);
+        /// <summary>
+        /// Deregisters an ICallbackAction that was previously added. This should
+        /// only emit a warning if an action that was not previous added was 
+        /// provided.
+        /// </summary>
+        /// <param name="action">ICallbackAction to remove.</param>
+        void DeregisterAction(ICallbackAction action);
+        /// <summary>
+        /// Iterable set of ICallbackActions that were registered to this event.
+        /// </summary>
+        IEnumerable<ICallbackAction> Actions { get; }
+    }
+    
+    /// <summary>
+    /// A container of CallbackActions that is correlated to a specific scenario as
+    /// specified by the user of this class.
+    /// This variant accepts CallbackEvents with 1 generic parameter.
+    /// </summary>
+    public class CallbackEvent<T1> : ICallbackEvent
+    {
+        #region Properties --------------------------------------------------------------
+        /// <inheritdoc/>
+        public IEnumerable<ICallbackAction> Actions => actions;
+        #endregion
+
+        #region Fields ------------------------------------------------------------------
+        private List<ICallbackAction> actions = new List<ICallbackAction>();
+        #endregion
+
+        #region Usage Functions ---------------------------------------------------------
+        /// <inheritdoc/>
+        public void RegisterAction()
+        {
+            actions.Add(new CallbackAction<T1>());
+        }
+        /// <inheritdoc/>
+        public void RegisterAction(ICallbackAction action)
+        {
+            // Check if valid action
+            if (action.GetType() != typeof(CallbackAction<T1>))
+            {
+                Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+                return;
+            }
+
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Adds a CallbackAction into the event.
+        /// </summary>
+        /// <param name="action">CallbackAction to add.</param>
+        public void RegisterAction(CallbackAction<T1> action)
+        {
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="action">System.Action to add as a CallbackAction.</param>
+        public void RegisterAction(Action<T1> action)
+        {
+            actions.Add(new CallbackAction<T1>(action));
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="target">Object to call the method on.</param>
+        /// <param name="method">Method to call.</param>
+        public void RegisterAction(Object target, MethodInfo method)
+        {
+            actions.Add(new CallbackAction<T1>(target, method));
+        }
+        /// <inheritdoc/>
+        public void DeregisterAction(ICallbackAction action)
+        {
+            if (!actions.Remove(action))
+            {
+                Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+            }
+        }
+        /// <summary>
+        /// Invokes all stored CallbackActions with the specified parameters.
+        /// </summary>
+        public void Invoke(T1 t1)
+        {
+            foreach (CallbackAction<T1> action in actions)
+            {
+                try
+                {
+                    action.Invoke(t1);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+        #endregion
+    }
+    /// <summary>
+    /// A container of CallbackActions that is correlated to a specific scenario as
+    /// specified by the user of this class.
+    /// This variant accepts CallbackEvents with 1 generic parameter.
+    /// </summary>
+    public class CallbackEvent<T1, T2> : ICallbackEvent
+    {
+        #region Properties --------------------------------------------------------------
+        /// <inheritdoc/>
+        public IEnumerable<ICallbackAction> Actions => actions;
+        #endregion
+
+        #region Fields ------------------------------------------------------------------
+        private List<ICallbackAction> actions = new List<ICallbackAction>();
+        #endregion
+
+        #region Usage Functions ---------------------------------------------------------
+        /// <inheritdoc/>
+        public void RegisterAction()
+        {
+            actions.Add(new CallbackAction<T1, T2>());
+        }
+        /// <inheritdoc/>
+        public void RegisterAction(ICallbackAction action)
+        {
+            // Check if valid action
+            if (action.GetType() != typeof(CallbackAction<T1, T2>))
+            {
+                Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+                return;
+            }
+
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Adds a CallbackAction into the event.
+        /// </summary>
+        /// <param name="action">CallbackAction to add.</param>
+        public void RegisterAction(CallbackAction<T1, T2> action)
+        {
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="action">System.Action to add as a CallbackAction.</param>
+        public void RegisterAction(Action<T1, T2> action)
+        {
+            actions.Add(new CallbackAction<T1, T2>(action));
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="target">Object to call the method on.</param>
+        /// <param name="method">Method to call.</param>
+        public void RegisterAction(Object target, MethodInfo method)
+        {
+            actions.Add(new CallbackAction<T1, T2>(target, method));
+        }
+        /// <inheritdoc/>
+        public void DeregisterAction(ICallbackAction action)
+        {
+            if (!actions.Remove(action))
+            {
+                Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+            }
+        }
+        /// <summary>
+        /// Invokes all stored CallbackActions with the specified parameters.
+        /// </summary>
+        public void Invoke(T1 t1, T2 t2)
+        {
+            foreach (CallbackAction<T1, T2> action in actions)
+            {
+                try
+                {
+                    action.Invoke(t1, t2);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+        #endregion
+    }
+    /// <summary>
+    /// A container of CallbackActions that is correlated to a specific scenario as
+    /// specified by the user of this class.
+    /// This variant accepts CallbackEvents with 1 generic parameter.
+    /// </summary>
+    public class CallbackEvent<T1, T2, T3> : ICallbackEvent
+    {
+        #region Properties --------------------------------------------------------------
+        /// <inheritdoc/>
+        public IEnumerable<ICallbackAction> Actions => actions;
+        #endregion
+
+        #region Fields ------------------------------------------------------------------
+        private List<ICallbackAction> actions = new List<ICallbackAction>();
+        #endregion
+
+        #region Usage Functions ---------------------------------------------------------
+        /// <inheritdoc/>
+        public void RegisterAction()
+        {
+            actions.Add(new CallbackAction<T1, T2, T3>());
+        }
+        /// <inheritdoc/>
+        public void RegisterAction(ICallbackAction action)
+        {
+            // Check if valid action
+            if (action.GetType() != typeof(CallbackAction<T1, T2, T3>))
+            {
+                Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+                return;
+            }
+
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Adds a CallbackAction into the event.
+        /// </summary>
+        /// <param name="action">CallbackAction to add.</param>
+        public void RegisterAction(CallbackAction<T1, T2, T3> action)
+        {
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="action">System.Action to add as a CallbackAction.</param>
+        public void RegisterAction(Action<T1, T2, T3> action)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3>(action));
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="target">Object to call the method on.</param>
+        /// <param name="method">Method to call.</param>
+        public void RegisterAction(Object target, MethodInfo method)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3>(target, method));
+        }
+        /// <inheritdoc/>
+        public void DeregisterAction(ICallbackAction action)
+        {
+            if (!actions.Remove(action))
+            {
+                Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+            }
+        }
+        /// <summary>
+        /// Invokes all stored CallbackActions with the specified parameters.
+        /// </summary>
+        public void Invoke(T1 t1, T2 t2, T3 t3)
+        {
+            foreach (CallbackAction<T1, T2, T3> action in actions)
+            {
+                try
+                {
+                    action.Invoke(t1, t2, t3);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+        #endregion
+    }
+    /// <summary>
+    /// A container of CallbackActions that is correlated to a specific scenario as
+    /// specified by the user of this class.
+    /// This variant accepts CallbackEvents with 1 generic parameter.
+    /// </summary>
+    public class CallbackEvent<T1, T2, T3, T4> : ICallbackEvent
+    {
+        #region Properties --------------------------------------------------------------
+        /// <inheritdoc/>
+        public IEnumerable<ICallbackAction> Actions => actions;
+        #endregion
+
+        #region Fields ------------------------------------------------------------------
+        private List<ICallbackAction> actions = new List<ICallbackAction>();
+        #endregion
+
+        #region Usage Functions ---------------------------------------------------------
+        /// <inheritdoc/>
+        public void RegisterAction()
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4>());
+        }
+        /// <inheritdoc/>
+        public void RegisterAction(ICallbackAction action)
+        {
+            // Check if valid action
+            if (action.GetType() != typeof(CallbackAction<T1, T2, T3, T4>))
+            {
+                Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+                return;
+            }
+
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Adds a CallbackAction into the event.
+        /// </summary>
+        /// <param name="action">CallbackAction to add.</param>
+        public void RegisterAction(CallbackAction<T1, T2, T3, T4> action)
+        {
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="action">System.Action to add as a CallbackAction.</param>
+        public void RegisterAction(Action<T1, T2, T3, T4> action)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4>(action));
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="target">Object to call the method on.</param>
+        /// <param name="method">Method to call.</param>
+        public void RegisterAction(Object target, MethodInfo method)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4>(target, method));
+        }
+        /// <inheritdoc/>
+        public void DeregisterAction(ICallbackAction action)
+        {
+            if (!actions.Remove(action))
+            {
+                Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+            }
+        }
+        /// <summary>
+        /// Invokes all stored CallbackActions with the specified parameters.
+        /// </summary>
+        public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4)
+        {
+            foreach (CallbackAction<T1, T2, T3, T4> action in actions)
+            {
+                try
+                {
+                    action.Invoke(t1, t2, t3, t4);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+        #endregion
+    }
+    /// <summary>
+    /// A container of CallbackActions that is correlated to a specific scenario as
+    /// specified by the user of this class.
+    /// This variant accepts CallbackEvents with 1 generic parameter.
+    /// </summary>
+    public class CallbackEvent<T1, T2, T3, T4, T5> : ICallbackEvent
+    {
+        #region Properties --------------------------------------------------------------
+        /// <inheritdoc/>
+        public IEnumerable<ICallbackAction> Actions => actions;
+        #endregion
+
+        #region Fields ------------------------------------------------------------------
+        private List<ICallbackAction> actions = new List<ICallbackAction>();
+        #endregion
+
+        #region Usage Functions ---------------------------------------------------------
+        /// <inheritdoc/>
+        public void RegisterAction()
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5>());
+        }
+        /// <inheritdoc/>
+        public void RegisterAction(ICallbackAction action)
+        {
+            // Check if valid action
+            if (action.GetType() != typeof(CallbackAction<T1, T2, T3, T4, T5>))
+            {
+                Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+                return;
+            }
+
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Adds a CallbackAction into the event.
+        /// </summary>
+        /// <param name="action">CallbackAction to add.</param>
+        public void RegisterAction(CallbackAction<T1, T2, T3, T4, T5> action)
+        {
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="action">System.Action to add as a CallbackAction.</param>
+        public void RegisterAction(Action<T1, T2, T3, T4, T5> action)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5>(action));
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="target">Object to call the method on.</param>
+        /// <param name="method">Method to call.</param>
+        public void RegisterAction(Object target, MethodInfo method)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5>(target, method));
+        }
+        /// <inheritdoc/>
+        public void DeregisterAction(ICallbackAction action)
+        {
+            if (!actions.Remove(action))
+            {
+                Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+            }
+        }
+        /// <summary>
+        /// Invokes all stored CallbackActions with the specified parameters.
+        /// </summary>
+        public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
+        {
+            foreach (CallbackAction<T1, T2, T3, T4, T5> action in actions)
+            {
+                try
+                {
+                    action.Invoke(t1, t2, t3, t4, t5);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+        #endregion
+    }
+    /// <summary>
+    /// A container of CallbackActions that is correlated to a specific scenario as
+    /// specified by the user of this class.
+    /// This variant accepts CallbackEvents with 1 generic parameter.
+    /// </summary>
+    public class CallbackEvent<T1, T2, T3, T4, T5, T6> : ICallbackEvent
+    {
+        #region Properties --------------------------------------------------------------
+        /// <inheritdoc/>
+        public IEnumerable<ICallbackAction> Actions => actions;
+        #endregion
+
+        #region Fields ------------------------------------------------------------------
+        private List<ICallbackAction> actions = new List<ICallbackAction>();
+        #endregion
+
+        #region Usage Functions ---------------------------------------------------------
+        /// <inheritdoc/>
+        public void RegisterAction()
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6>());
+        }
+        /// <inheritdoc/>
+        public void RegisterAction(ICallbackAction action)
+        {
+            // Check if valid action
+            if (action.GetType() != typeof(CallbackAction<T1, T2, T3, T4, T5, T6>))
+            {
+                Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+                return;
+            }
+
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Adds a CallbackAction into the event.
+        /// </summary>
+        /// <param name="action">CallbackAction to add.</param>
+        public void RegisterAction(CallbackAction<T1, T2, T3, T4, T5, T6> action)
+        {
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="action">System.Action to add as a CallbackAction.</param>
+        public void RegisterAction(Action<T1, T2, T3, T4, T5, T6> action)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6>(action));
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="target">Object to call the method on.</param>
+        /// <param name="method">Method to call.</param>
+        public void RegisterAction(Object target, MethodInfo method)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6>(target, method));
+        }
+        /// <inheritdoc/>
+        public void DeregisterAction(ICallbackAction action)
+        {
+            if (!actions.Remove(action))
+            {
+                Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+            }
+        }
+        /// <summary>
+        /// Invokes all stored CallbackActions with the specified parameters.
+        /// </summary>
+        public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
+        {
+            foreach (CallbackAction<T1, T2, T3, T4, T5, T6> action in actions)
+            {
+                try
+                {
+                    action.Invoke(t1, t2, t3, t4, t5, t6);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+        #endregion
+    }
+    /// <summary>
+    /// A container of CallbackActions that is correlated to a specific scenario as
+    /// specified by the user of this class.
+    /// This variant accepts CallbackEvents with 1 generic parameter.
+    /// </summary>
+    public class CallbackEvent<T1, T2, T3, T4, T5, T6, T7> : ICallbackEvent
+    {
+        #region Properties --------------------------------------------------------------
+        /// <inheritdoc/>
+        public IEnumerable<ICallbackAction> Actions => actions;
+        #endregion
+
+        #region Fields ------------------------------------------------------------------
+        private List<ICallbackAction> actions = new List<ICallbackAction>();
+        #endregion
+
+        #region Usage Functions ---------------------------------------------------------
+        /// <inheritdoc/>
+        public void RegisterAction()
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6, T7>());
+        }
+        /// <inheritdoc/>
+        public void RegisterAction(ICallbackAction action)
+        {
+            // Check if valid action
+            if (action.GetType() != typeof(CallbackAction<T1, T2, T3, T4, T5, T6, T7>))
+            {
+                Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+                return;
+            }
+
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Adds a CallbackAction into the event.
+        /// </summary>
+        /// <param name="action">CallbackAction to add.</param>
+        public void RegisterAction(CallbackAction<T1, T2, T3, T4, T5, T6, T7> action)
+        {
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="action">System.Action to add as a CallbackAction.</param>
+        public void RegisterAction(Action<T1, T2, T3, T4, T5, T6, T7> action)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6, T7>(action));
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="target">Object to call the method on.</param>
+        /// <param name="method">Method to call.</param>
+        public void RegisterAction(Object target, MethodInfo method)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6, T7>(target, method));
+        }
+        /// <inheritdoc/>
+        public void DeregisterAction(ICallbackAction action)
+        {
+            if (!actions.Remove(action))
+            {
+                Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+            }
+        }
+        /// <summary>
+        /// Invokes all stored CallbackActions with the specified parameters.
+        /// </summary>
+        public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
+        {
+            foreach (CallbackAction<T1, T2, T3, T4, T5, T6, T7> action in actions)
+            {
+                try
+                {
+                    action.Invoke(t1, t2, t3, t4, t5, t6, t7);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+        #endregion
+    }
+    /// <summary>
+    /// A container of CallbackActions that is correlated to a specific scenario as
+    /// specified by the user of this class.
+    /// This variant accepts CallbackEvents with 1 generic parameter.
+    /// </summary>
+    public class CallbackEvent<T1, T2, T3, T4, T5, T6, T7, T8> : ICallbackEvent
+    {
+        #region Properties --------------------------------------------------------------
+        /// <inheritdoc/>
+        public IEnumerable<ICallbackAction> Actions => actions;
+        #endregion
+
+        #region Fields ------------------------------------------------------------------
+        private List<ICallbackAction> actions = new List<ICallbackAction>();
+        #endregion
+
+        #region Usage Functions ---------------------------------------------------------
+        /// <inheritdoc/>
+        public void RegisterAction()
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8>());
+        }
+        /// <inheritdoc/>
+        public void RegisterAction(ICallbackAction action)
+        {
+            // Check if valid action
+            if (action.GetType() != typeof(CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8>))
+            {
+                Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+                return;
+            }
+
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Adds a CallbackAction into the event.
+        /// </summary>
+        /// <param name="action">CallbackAction to add.</param>
+        public void RegisterAction(CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8> action)
+        {
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="action">System.Action to add as a CallbackAction.</param>
+        public void RegisterAction(Action<T1, T2, T3, T4, T5, T6, T7, T8> action)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8>(action));
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="target">Object to call the method on.</param>
+        /// <param name="method">Method to call.</param>
+        public void RegisterAction(Object target, MethodInfo method)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8>(target, method));
+        }
+        /// <inheritdoc/>
+        public void DeregisterAction(ICallbackAction action)
+        {
+            if (!actions.Remove(action))
+            {
+                Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+            }
+        }
+        /// <summary>
+        /// Invokes all stored CallbackActions with the specified parameters.
+        /// </summary>
+        public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
+        {
+            foreach (CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8> action in actions)
+            {
+                try
+                {
+                    action.Invoke(t1, t2, t3, t4, t5, t6, t7, t8);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+        #endregion
+    }
+    /// <summary>
+    /// A container of CallbackActions that is correlated to a specific scenario as
+    /// specified by the user of this class.
+    /// This variant accepts CallbackEvents with 1 generic parameter.
+    /// </summary>
+    public class CallbackEvent<T1, T2, T3, T4, T5, T6, T7, T8, T9> : ICallbackEvent
+    {
+        #region Properties --------------------------------------------------------------
+        /// <inheritdoc/>
+        public IEnumerable<ICallbackAction> Actions => actions;
+        #endregion
+
+        #region Fields ------------------------------------------------------------------
+        private List<ICallbackAction> actions = new List<ICallbackAction>();
+        #endregion
+
+        #region Usage Functions ---------------------------------------------------------
+        /// <inheritdoc/>
+        public void RegisterAction()
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8, T9>());
+        }
+        /// <inheritdoc/>
+        public void RegisterAction(ICallbackAction action)
+        {
+            // Check if valid action
+            if (action.GetType() != typeof(CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8, T9>))
+            {
+                Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+                return;
+            }
+
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Adds a CallbackAction into the event.
+        /// </summary>
+        /// <param name="action">CallbackAction to add.</param>
+        public void RegisterAction(CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8, T9> action)
+        {
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="action">System.Action to add as a CallbackAction.</param>
+        public void RegisterAction(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8, T9>(action));
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="target">Object to call the method on.</param>
+        /// <param name="method">Method to call.</param>
+        public void RegisterAction(Object target, MethodInfo method)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8, T9>(target, method));
+        }
+        /// <inheritdoc/>
+        public void DeregisterAction(ICallbackAction action)
+        {
+            if (!actions.Remove(action))
+            {
+                Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+            }
+        }
+        /// <summary>
+        /// Invokes all stored CallbackActions with the specified parameters.
+        /// </summary>
+        public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
+        {
+            foreach (CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8, T9> action in actions)
+            {
+                try
+                {
+                    action.Invoke(t1, t2, t3, t4, t5, t6, t7, t8, t9);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+        #endregion
+    }
+    /// <summary>
+    /// A container of CallbackActions that is correlated to a specific scenario as
+    /// specified by the user of this class.
+    /// This variant accepts CallbackEvents with 1 generic parameter.
+    /// </summary>
+    public class CallbackEvent<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : ICallbackEvent
+    {
+        #region Properties --------------------------------------------------------------
+        /// <inheritdoc/>
+        public IEnumerable<ICallbackAction> Actions => actions;
+        #endregion
+
+        #region Fields ------------------------------------------------------------------
+        private List<ICallbackAction> actions = new List<ICallbackAction>();
+        #endregion
+
+        #region Usage Functions ---------------------------------------------------------
+        /// <inheritdoc/>
+        public void RegisterAction()
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>());
+        }
+        /// <inheritdoc/>
+        public void RegisterAction(ICallbackAction action)
+        {
+            // Check if valid action
+            if (action.GetType() != typeof(CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>))
+            {
+                Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+                return;
+            }
+
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Adds a CallbackAction into the event.
+        /// </summary>
+        /// <param name="action">CallbackAction to add.</param>
+        public void RegisterAction(CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action)
+        {
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="action">System.Action to add as a CallbackAction.</param>
+        public void RegisterAction(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(action));
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="target">Object to call the method on.</param>
+        /// <param name="method">Method to call.</param>
+        public void RegisterAction(Object target, MethodInfo method)
+        {
+            actions.Add(new CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(target, method));
+        }
+        /// <inheritdoc/>
+        public void DeregisterAction(ICallbackAction action)
+        {
+            if (!actions.Remove(action))
+            {
+                Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+            }
+        }
+        /// <summary>
+        /// Invokes all stored CallbackActions with the specified parameters.
+        /// </summary>
+        public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10)
+        {
+            foreach (CallbackAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action in actions)
+            {
+                try
+                {
+                    action.Invoke(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+        #endregion
+    }
+}

SHADE_CSharp/src/Events/CallbackEvent.tt

@@ -0,0 +1,152 @@
+<#
+/************************************************************************************//*!
+\file           CallbackEvent.tt
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Oct 23, 2022
+\brief          Contains the T4 template for the definition of CallbackEvent and 
+                related classes.
+ 
+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.
+*//*************************************************************************************/#>
+<#@ template hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+<# var max = 10; #>
+/************************************************************************************//*!
+\file           CallbackEvent.cs
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Oct 23, 2022
+\brief          Contains the definition of CallbackEvent and related classes.
+ 
+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.
+*//*************************************************************************************/
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Reflection.Metadata.Ecma335;
+
+namespace SHADE
+{
+    /// <summary>
+    /// Interface for a CallbackEvent that all variants inherit from.
+    /// </summary>
+    public interface ICallbackEvent
+    { 
+        /// <summary>
+        /// Registers an empty ICallbackAction.
+        /// </summary>
+        void RegisterAction();
+        /// <summary>
+        /// Registers an ICallbackAction with the event such that it will be called in
+        /// future
+        /// </summary>
+        /// <param name="action">ICallbackAction to register with.</param>
+        void RegisterAction(ICallbackAction action);
+        /// <summary>
+        /// Deregisters an ICallbackAction that was previously added. This should
+        /// only emit a warning if an action that was not previous added was 
+        /// provided.
+        /// </summary>
+        /// <param name="action">ICallbackAction to remove.</param>
+        void DeregisterAction(ICallbackAction action);
+        /// <summary>
+        /// Iterable set of ICallbackActions that were registered to this event.
+        /// </summary>
+        IEnumerable<ICallbackAction> Actions { get; }
+    }
+    
+<# for (int i = 1; i <= max; ++i) { #>
+    /// <summary>
+    /// A container of CallbackActions that is correlated to a specific scenario as
+    /// specified by the user of this class.
+    /// This variant accepts CallbackEvents with 1 generic parameter.
+    /// </summary>
+    public class CallbackEvent<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> : ICallbackEvent
+    {
+        #region Properties --------------------------------------------------------------
+        /// <inheritdoc/>
+        public IEnumerable<ICallbackAction> Actions => actions;
+        #endregion
+
+        #region Fields ------------------------------------------------------------------
+        private List<ICallbackAction> actions = new List<ICallbackAction>();
+        #endregion
+
+        #region Usage Functions ---------------------------------------------------------
+        /// <inheritdoc/>
+        public void RegisterAction()
+        {
+            actions.Add(new CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>>());
+        }
+        /// <inheritdoc/>
+        public void RegisterAction(ICallbackAction action)
+        {
+            // Check if valid action
+            if (action.GetType() != typeof(CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>>))
+            {
+                Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+                return;
+            }
+
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Adds a CallbackAction into the event.
+        /// </summary>
+        /// <param name="action">CallbackAction to add.</param>
+        public void RegisterAction(CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> action)
+        {
+            actions.Add(action);
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="action">System.Action to add as a CallbackAction.</param>
+        public void RegisterAction(Action<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> action)
+        {
+            actions.Add(new CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>>(action));
+        }
+        /// <summary>
+        /// Constructs and adds a CallbackACtion into the event.
+        /// </summary>
+        /// <param name="target">Object to call the method on.</param>
+        /// <param name="method">Method to call.</param>
+        public void RegisterAction(Object target, MethodInfo method)
+        {
+            actions.Add(new CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>>(target, method));
+        }
+        /// <inheritdoc/>
+        public void DeregisterAction(ICallbackAction action)
+        {
+            if (!actions.Remove(action))
+            {
+                Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+            }
+        }
+        /// <summary>
+        /// Invokes all stored CallbackActions with the specified parameters.
+        /// </summary>
+        public void Invoke(<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#> t<#=t#><# if (t != i) { #>, <# } #><# } #>)
+        {
+            foreach (CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> action in actions)
+            {
+                try
+                {
+                    action.Invoke(<# for (int t = 1; t < i + 1; ++t) { #>t<#=t#><# if (t != i) { #>, <# } #><# } #>);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+        #endregion
+    }
+<# } #>
+}

SHADE_CSharp/src/Utility/Debug.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace SHADE
+{
+    internal static class Debug
+    {
+        [DllImport("SHADE_Engine.dll", EntryPoint = "SHLog_Info")]
+        public static extern void LogInfo([MarshalAs(UnmanagedType.LPStr)] string str);
+        [DllImport("SHADE_Engine.dll", EntryPoint = "SHLog_Warning")]
+        public static extern void LogWarning([MarshalAs(UnmanagedType.LPStr)] string str);
+        [DllImport("SHADE_Engine.dll", EntryPoint = "SHLog_Error")]
+        public static extern void LogError([MarshalAs(UnmanagedType.LPStr)] string str);
+        [DllImport("SHADE_Engine.dll", EntryPoint = "SHLog_Critical")]
+        public static extern void LogCritical([MarshalAs(UnmanagedType.LPStr)] string str);
+        public static void LogInfo(string msg, Object thrower)
+        {
+            LogInfo($"[{thrower.GetType().Name}] {msg}");
+        }
+        public static void LogWarning(string msg, Object thrower)
+        {
+            LogWarning($"[{thrower.GetType().Name}] {msg}");
+        }
+        public static void LogError(string msg, Object thrower)
+        {
+            LogError($"[{thrower.GetType().Name}] {msg}");
+        }
+        public static void LogCritical(string msg, Object thrower)
+        {
+            LogCritical($"[{thrower.GetType().Name}] {msg}");
+        }
+        public static void LogException(Exception exception, Object thrower)
+        {
+            LogError($"[{ thrower.GetType().Name }] Unhandled exception: { exception.ToString() }");
+        }
+    }
+}

SHADE_Engine/premake5.lua

@@ -8,7 +8,7 @@ project "SHADE_Engine"
   pchheader "SHpch.h"
   pchsource "%{prj.location}/src/SHpch.cpp"
   staticruntime "off"
-
+  buildoptions{"/bigobj"}
   files  
   {
     "%{prj.location}/src/**.h",
@@ -57,7 +57,7 @@ project "SHADE_Engine"
     "%{IncludeDir.RTTR}/lib",
     "%{IncludeDir.SDL}/lib",
     "%{IncludeDir.spdlog}/lib",
-    "%{IncludeDir.fmod}/lib",
+    "%{IncludeDir.fmod}/lib"
   }
   
   links
@@ -76,8 +76,15 @@ project "SHADE_Engine"
   
   disablewarnings
   {
-    "4251"
+    "4251",
+    "26812",
+    "26439",
+    "26451",
+    "26437",
+    "4275"
   }
+
+  linkoptions { "-IGNORE:4006" }
   
   defines
   {
@@ -156,8 +163,8 @@ project "SHADE_Engine"
     links{"assimp-vc142-mt.lib", "librttr_core.lib", "spdlog.lib"}
     excludes
     {
-      "%{prj.location}/src/Editor/**.cpp",
+--      "%{prj.location}/src/Editor/**.cpp",
-      "%{prj.location}/src/Editor/**.h",
+--      "%{prj.location}/src/Editor/**.h",
-      "%{prj.location}/src/Editor/**.hpp",
+--      "%{prj.location}/src/Editor/**.hpp",
     }
     links{"fmodstudio_vc.lib", "fmod_vc.lib"}

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

@@ -0,0 +1,30 @@
+/*************************************************************************//**
+ * \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/SHAssetData.h

@@ -0,0 +1,19 @@
+/*************************************************************************//**
+ * \file    SHAssetDataBase.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
+
+namespace SHADE
+{
+	struct SHAssetData
+	{
+		virtual ~SHAssetData(){}
+	};
+}

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

@@ -0,0 +1,4 @@
+#pragma once
+
+#include "SHMeshAsset.h"
+#include "SHTextureAsset.h"

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

@@ -0,0 +1,21 @@
+/*************************************************************************//**
+ * \file    SHInternalAsset.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 "SHAsset.h"
+
+namespace SHADE
+{
+	struct SHInternalAsset : SHAsset
+	{
+		
+	};
+}

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

@@ -0,0 +1,23 @@
+/******************************************************************************
+ * \file    SHMaterialAsset.h
+ * \author  Loh Xiao Qi
+ * \date    29 October 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 "Assets/Asset Types/SHAssetData.h"
+#include <string>
+
+namespace  SHADE
+{
+  struct SHMaterialAsset : SHAssetData
+  {
+    std::string name;
+    std::string data;
+  };
+}

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

@@ -1,8 +1,20 @@
+/*************************************************************************//**
+ * \file    SHMeshAsset.h
+ * \author  Loh Xiao Qi
+ * \date    30 September 2022
+ * \brief		Struct to contain ready data for loading into GPU. Also used for
+ *					compilation into binary files
+ * 
+ *
+ * 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 "Math/SHMath.h"
-#include "SH_API.h"
+#include "SHAssetData.h"
 
 namespace SHADE
 {
@@ -10,17 +22,16 @@ namespace SHADE
 	{
 		uint32_t vertexCount;
 		uint32_t indexCount;
+		std::string name;
 	};
 
-	struct SH_API SHMeshAsset
+	struct SH_API SHMeshAsset : SHAssetData
 	{
 		bool compiled;
 		bool changed;
 
 		SHMeshAssetHeader header;
 
-		std::string meshName;
-
 		std::vector<SHVec3> vertexPosition;
 		std::vector<SHVec3> vertexTangent;
 		std::vector<SHVec3> vertexNormal;

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

@@ -0,0 +1,23 @@
+/******************************************************************************
+ * \file    SHPrefabAsset.h
+ * \author  Loh Xiao Qi
+ * \date    28 October 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 "SHAssetData.h"
+#include <string>
+
+namespace SHADE
+{
+  struct SHPrefabAsset : SHAssetData
+  {
+    std::string name;
+    std::string data;
+  };
+}

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

@@ -0,0 +1,23 @@
+/******************************************************************************
+ * \file    SHSceneAsset.h
+ * \author  Loh Xiao Qi
+ * \date    28 October 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 "SHAssetData.h"
+#include <string>
+
+namespace SHADE
+{
+  struct SHSceneAsset : SHAssetData
+  {
+    std::string name;
+    std::string data;
+  };
+}

SHADE_Engine/src/Assets/Asset Types/SHShaderAsset.cpp

@@ -0,0 +1,61 @@
+/*************************************************************************//**
+ * \file    SHShaderAsset.cpp
+ * \author  Brandon Mak
+ * \date    24 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.
+ *****************************************************************************/
+
+#include "SHpch.h"
+#include "SHShaderAsset.h"
+
+namespace SHADE
+{
+  SHShaderAsset::SHShaderAsset() noexcept
+    : spirvBinary{},
+      shaderType{SH_SHADER_TYPE::VERTEX},
+      name{}
+  {
+  }
+
+  SHShaderAsset::SHShaderAsset(SHShaderAsset const& rhs) noexcept
+    : spirvBinary{rhs.spirvBinary},
+    shaderType{ rhs.shaderType },
+    name{rhs.name}
+  {
+  }
+
+  SHShaderAsset::SHShaderAsset(SHShaderAsset&& rhs) noexcept
+    : spirvBinary{ std::move(rhs.spirvBinary) },
+    shaderType{ std::move(rhs.shaderType) },
+    name{ std::move(rhs.name) }
+  {
+  }
+
+  SHShaderAsset& SHShaderAsset::operator=(SHShaderAsset&& rhs) noexcept
+  {
+    if (this == &rhs)
+    {
+      return *this;
+    }
+
+    spirvBinary = std::move(rhs.spirvBinary);
+    shaderType = std::move(rhs.shaderType);
+    name = std::move(rhs.name);
+  }
+
+  SHShaderAsset& SHShaderAsset::operator=(SHShaderAsset const& rhs) noexcept
+  {
+    if (this == &rhs)
+    {
+      return *this;
+    }
+
+    spirvBinary = rhs.spirvBinary;
+    shaderType = rhs.shaderType;
+    name = rhs.name;
+  }
+}

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

@@ -0,0 +1,48 @@
+/*************************************************************************//**
+ * \file    SHShaderAsset.h
+ * \author  Brandon Mak
+ * \date    24 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 "SHAssetData.h"
+#include "SH_API.h"
+#include <vector>
+#include <string>
+
+namespace SHADE
+{
+  enum class SH_SHADER_TYPE : uint8_t
+  {
+    VERTEX,
+    FRAGMENT,
+    COMPUTE,
+    INAVLID_TYPE
+  };
+
+  struct SH_API SHShaderAsset : SHAssetData
+  {
+    /*-----------------------------------------------------------------------*/
+    /* MEMBER VARIABLES                                                      */
+    /*-----------------------------------------------------------------------*/
+    //! container storing the spirv binary
+    std::vector<uint32_t> spirvBinary;
+
+    //! For the compilation of the shader. Vulkan backend will use it too
+    SH_SHADER_TYPE shaderType;
+
+    //! Name of the shader file (without parent path)
+    std::string name;
+
+    SHShaderAsset() noexcept;
+    SHShaderAsset(SHShaderAsset const& rhs) noexcept;
+    SHShaderAsset(SHShaderAsset&& rhs) noexcept;
+    SHShaderAsset& operator= (SHShaderAsset&& rhs) noexcept;
+    SHShaderAsset& operator= (SHShaderAsset const& rhs) noexcept;
+  };
+}

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

@@ -1,15 +1,16 @@
 #pragma once
 
 #include "tinyddsloader.h"
-
 #include "Graphics/MiddleEnd/Textures/SHTextureLibrary.h"
-
+#include "SHAssetData.h"
-#include <memory>
 
 namespace SHADE
 {
-	struct SHTextureAsset
+	struct SHTextureAsset : SHAssetData
 	{
+		bool compiled;
+
+		std::string name;
 		uint32_t numBytes;
 		uint32_t width;
 		uint32_t height;
@@ -18,7 +19,8 @@ namespace SHADE
 		SHTexture::PixelChannel const * pixelData;
 
 		SHTextureAsset()
-			:	numBytes{ 0 },
+			:	compiled{ false },
+				numBytes{ 0 },
 				width{ 0 },
 				height{ 0 },
 				format{ SHTexture::TextureFormat::eUndefined },
@@ -26,7 +28,8 @@ namespace SHADE
 		{}
 
 		SHTextureAsset(SHTextureAsset const& rhs)
-			: numBytes{ rhs.numBytes },
+			: compiled{ false },
+				numBytes{ rhs.numBytes },
 				width{ rhs.width },
 				height{ rhs.height },
 				format{ rhs.format },

SHADE_Engine/src/Assets/Libraries/Compilers/SHMeshCompiler.cpp

@@ -0,0 +1,201 @@
+/*************************************************************************//**
+ * \file    SHMeshCompiler.cpp
+ * \author  Loh Xiao Qi
+ * \date    30 September 2022
+ * \brief   Library to write data in SHMeshAsset into binary file for faster
+ *					loading in the future
+ * 
+ *
+ * Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or
+ * disclosure of this file or its contents without the prior written consent
+ * of DigiPen Institute of Technology is prohibited.
+ *****************************************************************************/
+#include "SHpch.h"
+#include "SHMeshCompiler.h"
+#include "Graphics/MiddleEnd/Meshes/SHMeshData.h"
+#include <assimp/postprocess.h>
+
+#include <fstream>
+
+namespace SHADE
+{
+
+  Assimp::Importer SHMeshCompiler::aiImporter;
+
+  void SHMeshCompiler::ProcessNode(aiNode const& node, aiScene const& scene, MeshVectorRef meshes) noexcept
+  {
+    for (size_t i{ 0 }; i < node.mNumMeshes; ++i)
+    {
+      aiMesh* mesh = scene.mMeshes[node.mMeshes[i]];
+      meshes.push_back(ProcessMesh(*mesh));
+    }
+
+    for (size_t i{ 0 }; i < node.mNumChildren; ++i)
+    {
+      ProcessNode(*node.mChildren[i], scene, meshes);
+    }
+  }
+
+  void SHMeshCompiler::ExtractAnimations(aiScene const& scene, AnimVectorRef anims) noexcept
+  {
+    if (scene.HasAnimations())
+    {
+      std::vector<SHAnimationAsset> anims(scene.mNumAnimations);
+      for (auto i{ 0 }; i < scene.mNumAnimations; ++i)
+      {
+        auto const& anim{ *scene.mAnimations[i] };
+
+        anims[i].name = anim.mName.C_Str();
+
+        anims[i].duration = anim.mDuration;
+        anims[i].ticksPerSecond = anim.mTicksPerSecond;
+
+        std::copy_n(anim.mChannels, anim.mNumChannels, anims[i].nodeChannels.data());
+        std::copy_n(anim.mMeshChannels, anim.mNumMeshChannels, anims[i].meshChannels.data());
+        std::copy_n(anim.mMorphMeshChannels, anim.mNumMorphMeshChannels, anims[i].morphMeshChannels.data());
+      }
+    }
+  }
+
+  SHMeshAsset* SHMeshCompiler::ProcessMesh(aiMesh const& mesh) noexcept
+  {
+    SHMeshAsset* result = new SHMeshAsset();
+    result->compiled = false;
+    result->changed = false;
+
+    for (size_t i{ 0 }; i < mesh.mNumVertices; ++i)
+    {
+      // Vertex position
+      SHVec3 vertex;
+      vertex.x = mesh.mVertices[i].x;
+      vertex.y = mesh.mVertices[i].y;
+      vertex.z = mesh.mVertices[i].z;
+      result->vertexPosition.push_back(vertex);
+
+      // Tex coords
+      SHVec2 texCoord{ 0.f, 0.f };
+      if (mesh.mTextureCoords[0])
+      {
+        texCoord.x = mesh.mTextureCoords[0][i].x;
+        texCoord.y = mesh.mTextureCoords[0][i].y;
+      }
+      result->texCoords.push_back(texCoord);
+
+      // Normals
+      SHVec3 normal{ 0.f, 0.f, 0.f };
+      if (mesh.mNormals)
+      {
+        normal.x = mesh.mNormals[i].x;
+        normal.y = mesh.mNormals[i].y;
+        normal.z = mesh.mNormals[i].z;
+      }
+      result->vertexNormal.push_back(normal);
+
+      // Tangent
+      SHVec3 tangent{ 0.f, 0.f, 0.f };
+      if (mesh.mTangents)
+      {
+        tangent.x = mesh.mTangents[i].x;
+        tangent.y = mesh.mTangents[i].y;
+        tangent.z = mesh.mTangents[i].z;
+      }
+      result->vertexTangent.push_back(tangent);
+    }
+
+    for (size_t i{ 0 }; i < mesh.mNumFaces; ++i)
+    {
+      aiFace face = mesh.mFaces[i];
+      for (size_t j{ 0 }; j < face.mNumIndices; ++j)
+      {
+        result->indices.push_back(face.mIndices[j]);
+      }
+    }
+
+    result->header.vertexCount = static_cast<uint32_t>(result->vertexPosition.size());
+    result->header.indexCount = static_cast<uint32_t>(result->indices.size());
+    result->header.name = mesh.mName.C_Str();
+
+    return result;
+  }
+
+  void SHMeshCompiler::LoadFromFile(AssetPath path, MeshVectorRef meshes, AnimVectorRef anims) noexcept
+  {
+    const aiScene* scene = aiImporter.ReadFile(path.string().c_str(),
+      aiProcess_Triangulate                 // Make sure we get triangles rather than nvert polygons
+      | aiProcess_GenUVCoords               // Convert any type of mapping to uv mapping
+      | aiProcess_TransformUVCoords         // preprocess UV transformations (scaling, translation ...)
+      | aiProcess_FindInstances             // search for instanced meshes and remove them by references to one master
+      | aiProcess_CalcTangentSpace          // calculate tangents and bitangents if possible
+      | aiProcess_JoinIdenticalVertices     // join identical vertices/ optimize indexing
+      | aiProcess_RemoveRedundantMaterials  // remove redundant materials
+      | aiProcess_FindInvalidData           // detect invalid model data, such as invalid normal vectors
+      | aiProcess_FlipUVs                   // flip the V to match the Vulkans way of doing UVs
+    );
+
+    if (!scene || !scene->HasMeshes())
+    {
+      SHLOG_ERROR("ERROR in GLTF::ASSIMP: {}\nFile: {}", aiImporter.GetErrorString(), path.string());
+      return;
+    }
+
+    //ExtractAnimations(*scene, anims);
+
+    ProcessNode(*scene->mRootNode, *scene, meshes);
+
+    aiImporter.FreeScene();
+  }
+
+  std::optional<AssetPath> SHMeshCompiler::CompileMeshBinary(SHMeshAsset const& asset, AssetPath path) noexcept
+  {
+    std::string newPath{ path.parent_path().string() + '/' };
+    newPath += asset.header.name + MESH_EXTENSION.data();
+
+    std::ofstream file{ newPath, std::ios::out | std::ios::binary | std::ios::trunc };
+    if (!file.is_open())
+    {
+      SHLOG_ERROR("Unable to open file for writing mesh file: {}", path.string());
+    }
+
+    file.write(
+      reinterpret_cast<char const*>(&(asset.header.vertexCount)),
+      sizeof(uint32_t)
+    );
+
+    file.write(
+      reinterpret_cast<const char*>(&(asset.header.indexCount)),
+      sizeof(uint32_t)
+    );
+
+    auto const vertexVec3Byte{ sizeof(SHVec3) * asset.header.vertexCount };
+    auto const vertexVec2Byte{ sizeof(SHVec2) * asset.header.vertexCount };
+
+    file.write(
+      reinterpret_cast<char const*>(asset.vertexPosition.data()),
+      vertexVec3Byte
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(asset.vertexTangent.data()),
+      vertexVec3Byte
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(asset.vertexNormal.data()),
+      vertexVec3Byte
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(asset.texCoords.data()),
+      vertexVec2Byte
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(asset.indices.data()),
+      sizeof(uint32_t) * asset.header.indexCount
+    );
+
+    file.close();
+
+    return newPath;
+  }
+}

SHADE_Engine/src/Assets/Libraries/Compilers/SHMeshCompiler.h

@@ -0,0 +1,40 @@
+/*************************************************************************//**
+ * \file    SHMeshCompiler.h
+ * \author  Loh Xiao Qi
+ * \date    30 September 2022
+ * \brief   Library to write data in SHMeshAsset into binary file for faster
+ *					loading in the future
+ * 
+ *
+ * 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 <assimp/Importer.hpp>
+#include <assimp/scene.h>
+#include <vector>
+
+#include "Assets/Asset Types/SHAnimationAsset.h"
+#include "Assets/Asset Types/SHMeshAsset.h"
+#include "Assets/SHAssetMacros.h"
+
+namespace SHADE
+{
+	class SHMeshCompiler
+	{
+
+    using MeshVectorRef = std::vector<SHMeshAsset*>&;
+    using AnimVectorRef = std::vector<SHAnimationAsset*>&;
+
+    static Assimp::Importer aiImporter;
+    static void ProcessNode(aiNode const& node, aiScene const& scene, MeshVectorRef meshes) noexcept;
+    static void ExtractAnimations(aiScene const& scene, AnimVectorRef anims) noexcept;
+    static SHMeshAsset* ProcessMesh(aiMesh const& mesh) noexcept;
+
+  public:
+    static void LoadFromFile(AssetPath path, MeshVectorRef meshes, AnimVectorRef anims) noexcept;
+    static std::optional<AssetPath> CompileMeshBinary(SHMeshAsset const& asset, AssetPath path) noexcept;
+	};
+}

SHADE_Engine/src/Assets/Libraries/Compilers/SHShaderSourceCompiler.cpp

@@ -0,0 +1,162 @@
+/*************************************************************************//**
+ * \file    SHShaderSourceCompiler.cpp
+ * \author  Loh Xiao Qi
+ * \date    23 10 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.
+ *****************************************************************************/
+#include "SHpch.h"
+#include "SHShaderSourceCompiler.h"
+#include "shaderc/shaderc.hpp"
+
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <algorithm>
+
+namespace SHADE
+{
+	std::string SHShaderSourceCompiler::CompileShaderSourceToBinary(AssetPath path, SHShaderAsset const& data) noexcept
+	{
+		std::string newPath{ path.string() };
+    newPath = newPath.substr(0, newPath.find_last_of('.'));
+    newPath += SHADER_BUILT_IN_EXTENSION.data();
+
+		std::ofstream file{ newPath, std::ios::binary | std::ios::out | std::ios::trunc };
+
+		file.write(
+			reinterpret_cast<char const*>(& data.shaderType), sizeof(uint8_t)
+		);
+
+		size_t const byteCount = sizeof(uint32_t) * data.spirvBinary.size();
+
+		file.write(
+			reinterpret_cast<char const*>(&byteCount), sizeof(size_t)
+		);
+
+		file.write(
+			reinterpret_cast<char const*>(data.spirvBinary.data()), byteCount
+		);
+
+		file.close();
+
+		return newPath;
+	}
+
+	SHShaderAsset const* SHShaderSourceCompiler::CompileShaderSourceToMemory(std::string const& data, std::string const& name, SH_SHADER_TYPE type) noexcept
+	{
+		// shaderc compiler
+		shaderc::Compiler compiler;
+		shaderc::CompileOptions options;
+
+		options.AddMacroDefinition("MY_DEFINE", "1");
+
+		//TODO: Check if we need optimisation levels when compiling into spirv
+		// Set optimization levels
+		//if (opLevel != shaderc_optimization_level_zero)
+		//	options.SetOptimizationLevel(opLevel);
+
+		// Attempt to get the shaderc equivalent shader stage
+		shaderc_shader_kind shaderKind;
+		switch (type)
+		{
+		case SH_SHADER_TYPE::VERTEX:
+			shaderKind = shaderc_shader_kind::shaderc_glsl_vertex_shader;
+			break;
+		case SH_SHADER_TYPE::FRAGMENT:
+			shaderKind = shaderc_shader_kind::shaderc_glsl_fragment_shader;
+			break;
+		case SH_SHADER_TYPE::COMPUTE:
+			shaderKind = shaderc_shader_kind::shaderc_glsl_compute_shader;
+			break;
+		default:
+			shaderKind = shaderc_shader_kind::shaderc_glsl_vertex_shader;
+			break;
+		}
+
+		// Compile the shader and get the result
+		shaderc::SpvCompilationResult compileResult = compiler.CompileGlslToSpv(data, shaderKind, name.c_str(), options);
+
+		if (compileResult.GetCompilationStatus() != shaderc_compilation_status_success)
+		{
+			SHLOG_ERROR("Shaderc failed to compile GLSL shader to binary | " + compileResult.GetErrorMessage());
+			return nullptr;
+		}
+
+		auto result = new SHShaderAsset();
+		result->spirvBinary.resize(compileResult.end() - compileResult.begin());
+
+		std::ranges::copy(compileResult.begin(), compileResult.end(), result->spirvBinary.data());
+
+    result->name = name;
+    result->shaderType = type;
+
+		return result;
+	}
+
+	SH_SHADER_TYPE SHShaderSourceCompiler::GetShaderTypeFromFilename(std::string name) noexcept
+	{
+		for (auto i { 0}; i < SHADER_TYPE_MAX_COUNT; ++i)
+		{
+			if (name.find(SHADER_IDENTIFIERS[i].data()) != std::string::npos)
+			{
+				return static_cast<SH_SHADER_TYPE>(i);
+			}
+		}
+
+		return SH_SHADER_TYPE::INAVLID_TYPE;
+	}
+
+  std::optional<AssetPath> SHShaderSourceCompiler::LoadAndCompileShader(AssetPath path) noexcept
+	{
+		auto type = GetShaderTypeFromFilename(path.filename().string());
+
+		if (type == SH_SHADER_TYPE::INAVLID_TYPE)
+		{
+			SHLOG_ERROR("Invalid filename for shaders, follow suffix in SHAssetMacros.h: {}", path.string());
+			return {};
+		}
+
+    path.make_preferred();
+
+		std::ifstream file{ path.string(), std::ios::in };
+
+		if (file.is_open())
+		{
+			std::stringstream stream;
+
+			stream << file.rdbuf();
+
+			std::string const content = stream.str();
+
+			auto data = CompileShaderSourceToMemory(content, path.filename().string(), type);
+
+			if (data == nullptr)
+			{
+				return{};
+			}
+
+			return CompileShaderSourceToBinary(path, *data);
+		}
+
+		SHLOG_ERROR("Unable to open shader file: {}", path.string());
+
+		return {};
+	}
+
+	std::optional<AssetPath> SHShaderSourceCompiler::CompileShaderFromString
+	(std::string const& string, AssetPath path, SH_SHADER_TYPE type) noexcept
+	{
+		auto const data = CompileShaderSourceToMemory(string, path.filename().string(), type);
+
+		if (data == nullptr)
+		{
+			return{};
+		}
+
+		return CompileShaderSourceToBinary(path, *data);
+	}
+}

SHADE_Engine/src/Assets/Libraries/Compilers/SHShaderSourceCompiler.h

@@ -0,0 +1,31 @@
+/*************************************************************************//**
+ * \file    SHShaderSourceCompiler.h
+ * \author  Loh Xiao Qi
+ * \date    23 10 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 "Assets/SHAssetMacros.h"
+#include "Assets/Asset Types/SHShaderAsset.h"
+
+namespace SHADE
+{
+	class SHShaderSourceCompiler
+	{
+	private:
+		static std::string CompileShaderSourceToBinary(AssetPath path, SHShaderAsset const& data) noexcept;
+		static SHShaderAsset const* CompileShaderSourceToMemory(std::string const& data, std::string const& name, SH_SHADER_TYPE type) noexcept;
+
+		static SH_SHADER_TYPE GetShaderTypeFromFilename(std::string name) noexcept;
+
+	public:
+		static std::optional<AssetPath> LoadAndCompileShader(AssetPath path) noexcept;
+		static std::optional<AssetPath> CompileShaderFromString
+		(std::string const& string, AssetPath path, SH_SHADER_TYPE type) noexcept;
+	};
+}

SHADE_Engine/src/Assets/Libraries/Compilers/SHTextureCompiler.cpp

@@ -0,0 +1,171 @@
+/*************************************************************************//**
+ * \file    SHTextureCompiler.cpp
+ * \author  Loh Xiao Qi
+ * \date    30 September 2022
+ * \brief   Library to write data in SHTextureAsset into binary file for 
+ *					faster loading in the future
+ * 
+ *
+ * Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or
+ * disclosure of this file or its contents without the prior written consent
+ * of DigiPen Institute of Technology is prohibited.
+ *****************************************************************************/
+#include "SHpch.h"
+#include "SHTextureCompiler.h"
+
+#include <fstream>
+
+namespace SHADE
+{
+
+  std::string SHTextureCompiler::TinyDDSResultToString(tinyddsloader::Result value)
+  {
+    switch (value)
+    {
+    case tinyddsloader::Result::ErrorFileOpen:
+      return "File open err";
+    case tinyddsloader::Result::ErrorRead:
+      return "File read err";
+    case tinyddsloader::Result::ErrorMagicWord:
+      return "File header magic word err";
+    case tinyddsloader::Result::ErrorSize:
+      return "File size err";
+    case tinyddsloader::Result::ErrorVerify:
+      return "Pixel format err";
+    case tinyddsloader::Result::ErrorNotSupported:
+      return "Unsupported format";
+    case tinyddsloader::Result::ErrorInvalidData:
+      return "Invalid data";
+    default:
+      return "Unknown";
+    }
+  }
+
+  vk::Format SHTextureCompiler::ddsLoaderToVkFormat(tinyddsloader::DDSFile::DXGIFormat format, bool isLinear)
+  {
+    switch (format)
+    {
+    case tinyddsloader::DDSFile::DXGIFormat::BC1_UNorm:
+    case tinyddsloader::DDSFile::DXGIFormat::BC1_UNorm_SRGB:
+      return isLinear ? vk::Format::eBc1RgbaUnormBlock : vk::Format::eBc1RgbaSrgbBlock;
+    case tinyddsloader::DDSFile::DXGIFormat::BC2_UNorm:
+    case tinyddsloader::DDSFile::DXGIFormat::BC2_UNorm_SRGB:
+      return isLinear ? vk::Format::eBc2UnormBlock : vk::Format::eBc2SrgbBlock;
+    case tinyddsloader::DDSFile::DXGIFormat::BC3_UNorm:
+    case tinyddsloader::DDSFile::DXGIFormat::BC3_UNorm_SRGB:
+      return isLinear ? vk::Format::eBc3UnormBlock : vk::Format::eBc3SrgbBlock;
+    case tinyddsloader::DDSFile::DXGIFormat::BC5_UNorm:
+    case tinyddsloader::DDSFile::DXGIFormat::BC5_SNorm:
+      return isLinear ? vk::Format::eBc5UnormBlock : vk::Format::eBc5SnormBlock;
+    case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UNorm:
+    case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UNorm_SRGB:
+      return isLinear ? vk::Format::eR8G8B8A8Unorm : vk::Format::eR8G8B8A8Srgb;
+    case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_SNorm:
+      return vk::Format::eR8G8B8A8Snorm;
+    case tinyddsloader::DDSFile::DXGIFormat::B8G8R8A8_UNorm:
+    case tinyddsloader::DDSFile::DXGIFormat::B8G8R8A8_UNorm_SRGB:
+      return isLinear ? vk::Format::eB8G8R8A8Unorm : vk::Format::eB8G8R8A8Srgb;
+    case tinyddsloader::DDSFile::DXGIFormat::B8G8R8X8_UNorm:
+    case tinyddsloader::DDSFile::DXGIFormat::B8G8R8X8_UNorm_SRGB:
+      return isLinear ? vk::Format::eB8G8R8A8Unorm : vk::Format::eB8G8R8Srgb;
+    default:
+      throw std::runtime_error("Unsupported DDS format.");
+    }
+  }
+
+  void SHTextureCompiler::LoadTinyDDS(AssetPath path, SHTextureAsset& asset) noexcept
+  {
+    tinyddsloader::Result loadResult = tinyddsloader::Result::Success;
+    tinyddsloader::DDSFile file;
+    loadResult = file.Load(path.string().c_str());
+    if (loadResult != tinyddsloader::Result::Success)
+    {
+      SHLOG_ERROR("Unable to load Texture file: {} at {}", TinyDDSResultToString(loadResult), path.string());
+    }
+
+    size_t totalBytes{ 0 };
+
+    std::vector<uint32_t> mipOff(file.GetMipCount());
+
+    for (size_t i{ 0 }; i < file.GetMipCount(); ++i)
+    {
+      mipOff[i] = static_cast<uint32_t>(totalBytes);
+      totalBytes += file.GetImageData(static_cast<uint32_t>(i), 0)->m_memSlicePitch;
+    }
+
+    SHTexture::PixelChannel* pixel = new SHTexture::PixelChannel[totalBytes];
+    std::memcpy(pixel, file.GetImageData()->m_mem, totalBytes);
+    //pixel = std::move(reinterpret_cast<SHTexture::PixelChannel const*>(file.GetDDSData()));
+
+    asset.name = path.stem().string();
+    asset.compiled = false;
+    asset.numBytes = static_cast<uint32_t>(totalBytes);
+    asset.width = file.GetWidth();
+    asset.height = file.GetHeight();
+    asset.format = ddsLoaderToVkFormat(file.GetFormat(), true);
+    asset.mipOffsets = std::move(mipOff);
+    asset.pixelData = std::move(pixel);
+  }
+
+  std::string SHTextureCompiler::WriteToFile(SHTextureAsset const& asset, AssetPath path) noexcept
+  {
+    std::string newPath{ path.string() };
+    newPath = newPath.substr(0, newPath.find_last_of('.'));
+    newPath += TEXTURE_EXTENSION;
+
+    std::ofstream file{ newPath, std::ios::out | std::ios::binary };
+    if (!file.is_open())
+    {
+      SHLOG_ERROR("Unable to open file for writing texture file: {}", path.string());
+    }
+
+    constexpr auto intBytes{ sizeof(uint32_t) };
+
+    uint32_t const mipOffsetCount{ static_cast<uint32_t>(asset.mipOffsets.size()) };
+
+    file.write(
+      reinterpret_cast<char const*>(&asset.numBytes),
+      intBytes
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(&asset.width),
+      intBytes
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(&asset.height),
+      intBytes
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(&asset.format),
+      sizeof(SHTexture::TextureFormat)
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(&mipOffsetCount),
+      intBytes
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(asset.mipOffsets.data()),
+      intBytes * asset.mipOffsets.size()
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(asset.pixelData),
+      asset.numBytes
+    );
+
+    file.close();
+    return newPath;
+  }
+
+  std::optional<AssetPath> SHTextureCompiler::CompileTextureAsset(AssetPath path)
+	{
+    auto data = new SHTextureAsset();
+    LoadTinyDDS(path, *data);
+    return WriteToFile(*data, path);
+	}
+}

SHADE_Engine/src/Assets/Libraries/Compilers/SHTextureCompiler.h

@@ -0,0 +1,33 @@
+/*************************************************************************//**
+ * \file    SHTextureCompiler.h
+ * \author  Loh Xiao Qi
+ * \date    30 September 2022
+ * \brief   Library to write data in SHTextureAsset into binary file for 
+ *					faster loading in the future
+ * 
+ *
+ * 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
+#define TINYDDSLOADER_IMPLEMENTATION
+
+#include "Assets/Asset Types/SHTextureAsset.h"
+#include "Assets/SHAssetMacros.h"
+#include "tinyddsloader.h"
+
+namespace SHADE
+{
+	class SHTextureCompiler
+	{
+  private:
+    static std::string TinyDDSResultToString(tinyddsloader::Result value);
+    static vk::Format ddsLoaderToVkFormat(tinyddsloader::DDSFile::DXGIFormat format, bool isLinear);
+    static void LoadTinyDDS(AssetPath path, SHTextureAsset& asset) noexcept;
+
+    static std::string WriteToFile(SHTextureAsset const& asset, AssetPath path) noexcept;
+  public:
+		static std::optional<AssetPath> CompileTextureAsset(AssetPath path);
+	};
+}

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

@@ -0,0 +1,23 @@
+/*************************************************************************//**
+ * \file    SHAssetLoader.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 "Assets/SHAssetMacros.h"
+#include "Assets/Asset Types/SHAssetData.h"
+
+namespace SHADE
+{
+	struct SHAssetLoader
+	{
+		virtual SHAssetData* Load(AssetPath path) = 0;
+    virtual void Write(SHAssetData const* data, AssetPath path) = 0;
+	};
+}

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

@@ -0,0 +1,130 @@
+/*************************************************************************//**
+ * \file    SHMeshLoader.cpp
+ * \author  Loh Xiao Qi
+ * \date    30 September 2022
+ * \brief   Implementation for Mesh loader. Accounts for custom binary format
+ *          as well as GLTF file format.
+ * 
+ *
+ * Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or
+ * disclosure of this file or its contents without the prior written consent
+ * of DigiPen Institute of Technology is prohibited.
+ *****************************************************************************/
+#include "SHpch.h"
+#include "SHMeshLoader.h"
+#include <fstream>
+
+namespace SHADE
+{
+	void SHMeshLoader::LoadSHMesh(AssetPath path, SHMeshAsset& mesh) noexcept
+	{
+    std::ifstream file{ path.string(), std::ios::in | std::ios::binary };
+    if (!file.is_open())
+    {
+      SHLOG_ERROR("Unable to open SHMesh File: {}", path.string());
+      return;
+    }
+
+    const std::string name{ path.stem().string() };
+
+    file.seekg(0);
+
+    uint32_t vertCount, indexCount;
+    std::vector<SHVec3> vertPos, vertTan, vertNorm;
+    std::vector<SHVec2> texCoord;
+    std::vector<uint32_t> indices;
+
+    file.read(reinterpret_cast<char*>(&vertCount), sizeof(uint32_t));
+    file.read(reinterpret_cast<char*>(&indexCount), sizeof(uint32_t));
+
+    auto const vertexVec3Byte{ sizeof(SHVec3) * vertCount };
+    auto const vertexVec2Byte{ sizeof(SHVec2) * vertCount };
+
+    vertPos.resize(vertCount);
+    vertTan.resize(vertCount);
+    vertNorm.resize(vertCount);
+    texCoord.resize(vertCount);
+    indices.resize(indexCount);
+
+    file.read(reinterpret_cast<char *>(vertPos.data()), vertexVec3Byte);
+    file.read(reinterpret_cast<char *>(vertTan.data()), vertexVec3Byte);
+    file.read(reinterpret_cast<char *>(vertNorm.data()), vertexVec3Byte);
+    file.read(reinterpret_cast<char *>(texCoord.data()), vertexVec2Byte);
+    file.read(reinterpret_cast<char *>(indices.data()), sizeof(uint32_t) * indexCount);
+
+    mesh.compiled = true;
+    mesh.changed  = false;
+
+    mesh.header.indexCount  = indexCount;
+    mesh.header.vertexCount = vertCount;
+    mesh.header.name = name;
+
+    mesh.vertexPosition = std::move(vertPos);
+    mesh.vertexTangent  = std::move(vertTan);
+    mesh.vertexNormal   = std::move(vertNorm);
+    mesh.texCoords      = std::move(texCoord);
+    mesh.indices        = std::move(indices);
+
+    file.close();
+	}
+
+	SHAssetData* SHMeshLoader::Load(AssetPath path)
+	{
+    auto result = new SHMeshAsset();
+
+    LoadSHMesh(path, *result);
+
+    return result;
+	}
+
+  void SHMeshLoader::Write(SHAssetData const* data, AssetPath path)
+  {
+    std::ofstream file{ path, std::ios::out | std::ios::binary | std::ios::trunc };
+    if (!file.is_open())
+    {
+      SHLOG_ERROR("Unable to open file for writing mesh file: {}", path.string());
+    }
+
+    auto asset = *dynamic_cast<SHMeshAsset const*>(data);
+
+    file.write(
+      reinterpret_cast<char const*>(&(asset.header.vertexCount)),
+      sizeof(uint32_t)
+    );
+
+    file.write(
+      reinterpret_cast<const char*>(&(asset.header.indexCount)),
+      sizeof(uint32_t)
+    );
+
+    auto const vertexVec3Byte{ sizeof(SHVec3) * asset.header.vertexCount };
+    auto const vertexVec2Byte{ sizeof(SHVec2) * asset.header.vertexCount };
+
+    file.write(
+      reinterpret_cast<char const*>(asset.vertexPosition.data()),
+      vertexVec3Byte
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(asset.vertexTangent.data()),
+      vertexVec3Byte
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(asset.vertexNormal.data()),
+      vertexVec3Byte
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(asset.texCoords.data()),
+      vertexVec2Byte
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(asset.indices.data()),
+      sizeof(uint32_t) * asset.header.indexCount
+    );
+
+    file.close();
+  }
+}

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

@@ -0,0 +1,24 @@
+/*************************************************************************//**
+ * \file    SHMeshLoader.h
+ * \author  Loh Xiao Qi
+ * \date    30 September 2022
+ * \brief   Library to load gltf mesh files and custom binary format
+ * 
+ *
+ * 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 "Assets/Asset Types/SHMeshAsset.h"
+#include "SHAssetLoader.h"
+
+namespace SHADE
+{
+	struct SHMeshLoader : SHAssetLoader
+	{
+		void LoadSHMesh(AssetPath path, SHMeshAsset& meshes) noexcept;
+		SHAssetData* Load(AssetPath path) override;
+    void Write(SHAssetData const* data, AssetPath path) override;
+	};
+}

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

@@ -0,0 +1,69 @@
+/*************************************************************************//**
+ * \file    SHShaderSourceLoader.cpp
+ * \author  Loh Xiao Qi
+ * \date    23 10 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.
+ *****************************************************************************/
+
+#include "SHpch.h"
+#include "SHShaderSourceLoader.h"
+#include "Assets/Asset Types/SHShaderAsset.h"
+
+#include <fstream>
+
+namespace SHADE
+{
+	SHAssetData* SHShaderSourceLoader::Load(AssetPath path)
+	{
+		auto result = new SHShaderAsset();
+
+    result->name = path.stem().stem().string();
+
+		std::ifstream file{ path.string(), std::ios::in | std::ios::binary };
+		if (!file.is_open())
+		{
+			SHLOG_ERROR("Unable to open compiled shader file: {}", path.string());
+			return nullptr;
+		}
+
+		size_t byteCount = 0;
+
+		file.read(reinterpret_cast<char*>(&result->shaderType), sizeof(uint8_t));
+		file.read(reinterpret_cast<char*>(&byteCount), sizeof(size_t));
+
+    result->spirvBinary.resize(byteCount / sizeof(uint32_t));
+
+		file.read(reinterpret_cast<char*>(result->spirvBinary.data()), byteCount);
+
+		file.close();
+
+		return result;
+	}
+
+  void SHShaderSourceLoader::Write(SHAssetData const* data, AssetPath path)
+  {
+    std::ofstream file{ path, std::ios::binary | std::ios::out | std::ios::trunc };
+
+    auto asset = *dynamic_cast<SHShaderAsset const*>(data);
+
+    file.write(
+      reinterpret_cast<char const*>(&asset.shaderType), sizeof(uint8_t)
+    );
+
+    size_t const byteCount = sizeof(uint32_t) * asset.spirvBinary.size();
+
+    file.write(
+      reinterpret_cast<char const*>(&byteCount), sizeof(size_t)
+    );
+
+    file.write(
+      reinterpret_cast<char const*>(asset.spirvBinary.data()), byteCount
+    );
+
+    file.close();
+  }
+}

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

@@ -0,0 +1,22 @@
+/*************************************************************************//**
+ * \file    SHShaderSourceLoader.h
+ * \author  Loh Xiao Qi
+ * \date    23 10 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 "Assets/Libraries/Loaders/SHAssetLoader.h"
+
+namespace SHADE
+{
+	struct SHShaderSourceLoader : SHAssetLoader
+	{
+		SHAssetData* Load(AssetPath path) override;
+    void Write(SHAssetData const* data, AssetPath path) override;
+	};
+}

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

@@ -0,0 +1,95 @@
+/******************************************************************************
+ * \file    SHTextBasedLoader.cpp
+ * \author  Loh Xiao Qi
+ * \date    28 October 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.
+ ******************************************************************************/
+#include "SHpch.h"
+#include "SHTextBasedLoader.h"
+
+#include "Assets/Asset Types/SHSceneAsset.h"
+#include "Assets/Asset Types/SHPrefabAsset.h"
+#include "Assets/Asset Types/SHMaterialAsset.h"
+
+#include <fstream>
+#include <sstream>
+
+namespace SHADE
+{
+  SHAssetData* SHTextBasedLoader::Load(AssetPath path)
+  {
+    std::ifstream file{ path, std::ios::in };
+
+    if (!file.is_open())
+    {
+      SHLOG_ERROR("Unable to open text File: {}", path.string());
+      return nullptr;
+    }
+    std::stringstream stream;
+
+    stream << file.rdbuf();
+
+    std::string content = stream.str();
+
+    SHAssetData* result;
+
+    if (path.extension().string() == SCENE_EXTENSION)
+    {
+      auto data = new SHSceneAsset();
+      data->name = path.stem().string();
+      data->data = std::move(content);
+      result = data;
+    }
+    else if (path.extension().string() == PREFAB_EXTENSION)
+    {
+      auto data = new SHPrefabAsset();
+      data->name = path.stem().string();
+      data->data = std::move(content);
+      result = data;
+    }
+    else if (path.extension().string() == MATERIAL_EXTENSION)
+    {
+      auto data = new SHMaterialAsset();
+      data->name = path.stem().string();
+      data->data = std::move(content);
+      result = data;
+    }
+
+    file.close();
+
+    return result;
+  }
+
+  void SHTextBasedLoader::Write(SHAssetData const* data, AssetPath path)
+  {
+    std::ofstream file{ path, std::ios::out | std::ios::trunc };
+
+    if (!file.is_open())
+    {
+      SHLOG_ERROR("Unable to open text File: {}", path.string());
+      return;
+    }
+
+    if (path.extension().string() == SCENE_EXTENSION)
+    {
+      auto scene = dynamic_cast<SHSceneAsset const*>(data);
+      file << scene->data;
+    }
+    else if (path.extension().string() == PREFAB_EXTENSION)
+    {
+      auto prefab = dynamic_cast<SHPrefabAsset const*>(data);
+      file << prefab->data;
+    }
+    else if (path.extension().string() == MATERIAL_EXTENSION)
+    {
+      auto material = dynamic_cast<SHMaterialAsset const*>(data);
+      file << material->data;
+    }
+
+    file.close();
+  }
+}

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

@@ -0,0 +1,21 @@
+/******************************************************************************
+ * \file    Header.h
+ * \author  Loh Xiao Qi
+ * \date    28 October 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 "SHAssetLoader.h"
+
+namespace SHADE
+{
+	struct SHTextBasedLoader : SHAssetLoader
+	{
+		SHAssetData* Load(AssetPath path) override;
+		void Write(SHAssetData const* data, AssetPath path) override;
+	};
+}

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

@@ -0,0 +1,110 @@
+/*************************************************************************//**
+ * \file    SHTextureLoader.cpp
+ * \author  Loh Xiao Qi
+ * \date    30 September 2022
+ * \brief   Library to load dds textures and custom binary format
+ * 
+ *
+ * Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or
+ * disclosure of this file or its contents without the prior written consent
+ * of DigiPen Institute of Technology is prohibited.
+ *****************************************************************************/
+#include "SHpch.h"
+#include "SHTextureLoader.h"
+
+#include <fstream>
+
+namespace SHADE
+{
+
+	void SHTextureLoader::LoadSHTexture(AssetPath path, SHTextureAsset& asset) noexcept
+	{
+		std::ifstream file{ path.string(), std::ios::in | std::ios::binary };
+		if (!file.is_open())
+		{
+			SHLOG_ERROR("Error opening SHTexture file: {}", path.string());
+		}
+
+		auto const intBytes{ sizeof(uint32_t) };
+		uint32_t mipCount;
+
+		file.read(reinterpret_cast<char*>(&asset.numBytes), intBytes);
+		file.read(reinterpret_cast<char*>(&asset.width), intBytes);
+		file.read(reinterpret_cast<char*>(&asset.height), intBytes);
+		file.read(reinterpret_cast<char*>(&asset.format), sizeof(SHTexture::TextureFormat));
+
+		file.read(reinterpret_cast<char*>(&mipCount), intBytes);
+		std::vector<uint32_t> mips(mipCount);
+		file.read(reinterpret_cast<char*>(mips.data()), intBytes * mipCount);
+
+		auto pixel = new SHTexture::PixelChannel[asset.numBytes];
+		file.read(reinterpret_cast<char*>(pixel), asset.numBytes);
+
+		asset.mipOffsets = std::move(mips);
+		asset.pixelData = std::move(pixel);
+
+		asset.compiled = true;
+		file.close();
+	}
+
+	SHAssetData* SHTextureLoader::Load(AssetPath path)
+	{
+		auto result = new SHTextureAsset();
+
+		LoadSHTexture(path, *result);
+
+		return result;
+	}
+
+	void SHTextureLoader::Write(SHAssetData const* data, AssetPath path)
+	{
+		std::ofstream file{ path, std::ios::out | std::ios::binary };
+		if (!file.is_open())
+		{
+			SHLOG_ERROR("Unable to open file for writing texture file: {}", path.string());
+		}
+
+		auto asset = *dynamic_cast<SHTextureAsset const*>(data);
+
+		constexpr auto intBytes{ sizeof(uint32_t) };
+
+		uint32_t const mipOffsetCount{ static_cast<uint32_t>(asset.mipOffsets.size()) };
+
+		file.write(
+			reinterpret_cast<char const*>(&asset.numBytes),
+			intBytes
+		);
+
+		file.write(
+			reinterpret_cast<char const*>(&asset.width),
+			intBytes
+		);
+
+		file.write(
+			reinterpret_cast<char const*>(&asset.height),
+			intBytes
+		);
+
+		file.write(
+			reinterpret_cast<char const*>(&asset.format),
+			sizeof(SHTexture::TextureFormat)
+		);
+
+		file.write(
+			reinterpret_cast<char const*>(&mipOffsetCount),
+			intBytes
+		);
+
+		file.write(
+			reinterpret_cast<char const*>(asset.mipOffsets.data()),
+			intBytes * asset.mipOffsets.size()
+		);
+
+		file.write(
+			reinterpret_cast<char const*>(asset.pixelData),
+			asset.numBytes
+		);
+
+		file.close();
+	}
+}

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

@@ -0,0 +1,24 @@
+/*************************************************************************//**
+ * \file    SHTextureLoader.h
+ * \author  Loh Xiao Qi
+ * \date    30 September 2022
+ * \brief   Library to load dds textures and custom binary format
+ * 
+ *
+ * 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 "Assets/Asset Types/SHTextureAsset.h"
+#include "SHAssetLoader.h"
+
+namespace SHADE
+{
+	class SHTextureLoader : public SHAssetLoader
+	{
+		void LoadSHTexture(AssetPath path, SHTextureAsset& asset) noexcept;
+		SHAssetData* Load(AssetPath path) override;
+    void Write(SHAssetData const* data, AssetPath path) override;
+	};
+}

SHADE_Engine/src/Assets/Libraries/SHMeshLoader.cpp

@@ -1,129 +0,0 @@
-#include "SHpch.h"
-#include "SHMeshLoader.h"
-#include <assimp/postprocess.h>
-
-namespace SHADE
-{
-	Assimp::Importer SHMeshLoader::aiImporter;
-
-	void SHMeshLoader::ProcessNode(aiNode const& node, aiScene const& scene, std::vector<SHMeshAsset>& meshes)
-	{
-    for (size_t i {0}; i < node.mNumMeshes; ++i)
-    {
-      aiMesh* mesh = scene.mMeshes[node.mMeshes[i]];
-      meshes.push_back(ProcessMesh(*mesh, scene));
-    }
-
-    for (size_t i{ 0 }; i < node.mNumChildren; ++i)
-    {
-      ProcessNode(*node.mChildren[i], scene, meshes);
-    }
-	}
-
-	SHMeshAsset SHMeshLoader::ProcessMesh(aiMesh const& mesh, aiScene const& scene)
-	{
-    (void)scene;
-
-    SHMeshAsset result
-    {
-      .compiled { false},
-      .changed { false },
-      .meshName { mesh.mName.C_Str() }
-    };
-
-    for (size_t i{0}; i < mesh.mNumVertices; ++i)
-    {
-      // Vertex position
-      SHVec3 vertex;
-      vertex.x = mesh.mVertices[i].x;
-      vertex.y = mesh.mVertices[i].y;
-      vertex.z = mesh.mVertices[i].z;
-      result.vertexPosition.push_back(vertex);
-
-      // Tex coords
-      SHVec2 texCoord{0.f, 0.f};
-      if (mesh.mTextureCoords[0])
-      {
-        texCoord.x = mesh.mTextureCoords[0][i].x;
-        texCoord.y = mesh.mTextureCoords[0][i].y;
-      }
-      result.texCoords.push_back(texCoord);
-
-      // Normals
-      SHVec3 normal{0.f, 0.f, 0.f};
-      if (mesh.mNormals)
-      {
-        normal.x = mesh.mNormals[i].x;
-        normal.y = mesh.mNormals[i].y;
-        normal.z = mesh.mNormals[i].z;
-      }
-      result.vertexNormal.push_back(normal);
-
-      // Tangent
-      SHVec3 tangent{0.f, 0.f, 0.f};
-      if (mesh.mTangents)
-      {
-        tangent.x = mesh.mTangents[i].x;
-        tangent.y = mesh.mTangents[i].y;
-        tangent.z = mesh.mTangents[i].z;
-      }
-      result.vertexTangent.push_back(tangent);
-    }
-
-    for (size_t i {0}; i < mesh.mNumFaces; ++i)
-    {
-      aiFace face = mesh.mFaces[i];
-      for (size_t j{0}; j < face.mNumIndices; ++j)
-      {
-        result.indices.push_back(face.mIndices[j]);
-      }
-    }
-
-    result.header.vertexCount = result.vertexPosition.size();
-    result.header.indexCount = result.indices.size();
-
-    return result;
-	}
-
-	bool SHMeshLoader::LoadMesh(std::vector<SHMeshAsset>& meshes, AssetPath path)
-  {
-    const aiScene* scene = aiImporter.ReadFile(path.string().c_str(),
-      aiProcess_Triangulate
-      // Make sure we get triangles rather than nvert polygons
-      | aiProcess_GenUVCoords // Convert any type of mapping to uv mapping
-      | aiProcess_TransformUVCoords
-      // preprocess UV transformations (scaling, translation ...)
-      | aiProcess_FindInstances
-      // search for instanced meshes and remove them by references to one master
-      | aiProcess_CalcTangentSpace
-      // calculate tangents and bitangents if possible
-      | aiProcess_JoinIdenticalVertices
-      // join identical vertices/ optimize indexing
-      | aiProcess_RemoveRedundantMaterials // remove redundant materials
-      | aiProcess_FindInvalidData// detect invalid model data, such as invalid normal vectors
-      | aiProcess_FlipUVs // flip the V to match the Vulkans way of doing UVs
-    );
-
-    if (!scene || !scene->HasMeshes())
-    {
-      SHLOG_ERROR("ERROR in GLTF::ASSIMP: {}\nFile: {}", aiImporter.GetErrorString(), path.string());
-      return false;
-    }
-    //TODO MATERIALS FROM MESHES
-    //if (scene->HasMaterials())
-    //{
-    //  for (int i{0}; i < scene->mNumMaterials; ++i)
-    //  {
-    //    if (scene->mMaterials[i]->mNumProperties > 0)
-    //    {
-	   //     for (int j{0}; j < scene->mMaterials[i]->mProperties[j].)
-    //    }
-				//std::cout << scene->mMaterials[i]->;
-    //  }
-    //}
-
-    ProcessNode(*scene->mRootNode, *scene, meshes);
-
-    return true;
-	}
-}

SHADE_Engine/src/Assets/Libraries/SHMeshLoader.h

@@ -1,21 +0,0 @@
-#pragma once
-#include <assimp/Importer.hpp>
-#include <assimp/scene.h>
-#include "../SHAssetMacros.h"
-#include "../Asset Types/SHMeshAsset.h"
-#include <vector>
-
-namespace SHADE
-{
-	class SHMeshLoader
-	{
-	private:
-		static Assimp::Importer aiImporter;
-
-		static void ProcessNode(aiNode const& node, aiScene const& scene, std::vector<SHMeshAsset>& meshes);
-
-		static SHMeshAsset ProcessMesh(aiMesh const& mesh, aiScene const& scene);
-	public:
-		static bool LoadMesh(std::vector<SHMeshAsset>& meshes, AssetPath path);
-	};
-}

SHADE_Engine/src/Assets/Libraries/SHMeshWriter.cpp

@@ -1,48 +0,0 @@
-#include "SHpch.h"
-#include "SHMeshWriter.h"
-
-#include <fstream>
-
-void SHADE::SHMeshWriter::WriteMeshBinary(SHMeshAsset const& asset, AssetPath path) noexcept
-{
-	std::ofstream file{path, std::ios::out | std::ios::binary};
-	if (!file.is_open())
-	{
-		SHLOG_ERROR("Unable to open file for writing mesh file: {}", path.string());
-	}
-
-	file.write(
-		reinterpret_cast<char const*>(&(asset.header.vertexCount)),
-		sizeof(uint32_t)
-	);
-
-	file.write(
-		reinterpret_cast<const char*>(&(asset.header.indexCount)),
-		sizeof(uint32_t)
-	);
-
-	auto const vertexVec3Byte {sizeof(SHVec3) * asset.header.vertexCount};
-	auto const vertexVec2Byte {sizeof(SHVec2) * asset.header.vertexCount};
-
-	file.write(
-		reinterpret_cast<char const*>(asset.vertexPosition.data()),
-		vertexVec3Byte
-	);
-	
-	file.write(
-		reinterpret_cast<char const*>(asset.vertexTangent.data()),
-		vertexVec3Byte
-	);
-	
-	file.write(
-		reinterpret_cast<char const*>(asset.vertexNormal.data()),
-		vertexVec3Byte
-	);
-	
-	file.write(
-		reinterpret_cast<char const*>(asset.texCoords.data()),
-		vertexVec2Byte
-	);
-
-	file.close();
-}

SHADE_Engine/src/Assets/Libraries/SHMeshWriter.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#include "../Asset Types/SHMeshAsset.h"
-#include "../SHAssetMacros.h"
-
-namespace SHADE
-{
-	class SHMeshWriter
-	{
-	private:
-	public:
-		static void WriteMeshBinary(SHMeshAsset const& asset, AssetPath path) noexcept;
-	};
-}

SHADE_Engine/src/Assets/Libraries/SHTextureLoader.cpp

@@ -1,92 +0,0 @@
-#include "SHpch.h"
-#include "SHTextureLoader.h"
-
-namespace SHADE
-{
-	std::string SHTextureLoader::TinyDDSResultToString(tinyddsloader::Result value)
-	{
-		switch (value)
-		{
-		case tinyddsloader::Result::ErrorFileOpen:
-			return "File open err";
-		case tinyddsloader::Result::ErrorRead:
-			return "File read err";
-		case tinyddsloader::Result::ErrorMagicWord:
-			return "File header magic word err";
-		case tinyddsloader::Result::ErrorSize:
-			return "File size err";
-		case tinyddsloader::Result::ErrorVerify:
-			return "Pixel format err";
-		case tinyddsloader::Result::ErrorNotSupported:
-			return "Unsupported format";
-		case tinyddsloader::Result::ErrorInvalidData:
-			return "Invalid data";
-		default:
-			return "Unknown";
-		}
-	}
-
-	vk::Format SHTextureLoader::ddsLoaderToVkFormat(tinyddsloader::DDSFile::DXGIFormat format, bool isLinear)
-	{
-		switch (format)
-		{
-		case tinyddsloader::DDSFile::DXGIFormat::BC1_UNorm:
-		case tinyddsloader::DDSFile::DXGIFormat::BC1_UNorm_SRGB:
-			return isLinear ? vk::Format::eBc1RgbaUnormBlock : vk::Format::eBc1RgbaSrgbBlock;
-		case tinyddsloader::DDSFile::DXGIFormat::BC2_UNorm:
-		case tinyddsloader::DDSFile::DXGIFormat::BC2_UNorm_SRGB:
-			return isLinear ? vk::Format::eBc2UnormBlock : vk::Format::eBc2SrgbBlock;
-		case tinyddsloader::DDSFile::DXGIFormat::BC3_UNorm:
-		case tinyddsloader::DDSFile::DXGIFormat::BC3_UNorm_SRGB:
-			return isLinear ? vk::Format::eBc3UnormBlock : vk::Format::eBc3SrgbBlock;
-		case tinyddsloader::DDSFile::DXGIFormat::BC5_UNorm:
-		case tinyddsloader::DDSFile::DXGIFormat::BC5_SNorm:
-			return isLinear ? vk::Format::eBc5UnormBlock : vk::Format::eBc5SnormBlock;
-		case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UNorm:
-		case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UNorm_SRGB:
-			return isLinear ? vk::Format::eR8G8B8A8Unorm : vk::Format::eR8G8B8A8Srgb;
-		case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_SNorm:
-			return vk::Format::eR8G8B8A8Snorm;
-		case tinyddsloader::DDSFile::DXGIFormat::B8G8R8A8_UNorm:
-		case tinyddsloader::DDSFile::DXGIFormat::B8G8R8A8_UNorm_SRGB:
-			return isLinear ? vk::Format::eB8G8R8A8Unorm : vk::Format::eB8G8R8A8Srgb;
-		case tinyddsloader::DDSFile::DXGIFormat::B8G8R8X8_UNorm:
-		case tinyddsloader::DDSFile::DXGIFormat::B8G8R8X8_UNorm_SRGB:
-			return isLinear ? vk::Format::eB8G8R8A8Unorm : vk::Format::eB8G8R8Srgb;
-		default:
-			throw std::runtime_error("Unsupported DDS format.");
-		}
-	}
-
-	void SHTextureLoader::LoadImageAsset(AssetPath path, SHTextureAsset& asset)
-	{
-		tinyddsloader::Result loadResult = tinyddsloader::Result::Success;
-		tinyddsloader::DDSFile file;
-		loadResult = file.Load(path.string().c_str());
-		if (loadResult != tinyddsloader::Result::Success)
-		{
-			SHLOG_ERROR("Unable to load Texture file: {} at {}", TinyDDSResultToString(loadResult), path.string());
-		}
-
-		size_t totalBytes{ 0 };
-
-		std::vector<uint32_t> mipOff(file.GetMipCount());
-
-		for (auto i{0}; i < file.GetMipCount(); ++i)
-		{
-			mipOff[i] = totalBytes;
-			totalBytes += file.GetImageData(i, 0)->m_memSlicePitch;
-		}
-
-		SHTexture::PixelChannel* pixel = new SHTexture::PixelChannel[totalBytes];
-		std::memcpy(pixel, file.GetImageData()->m_mem, totalBytes);
-		//pixel = std::move(reinterpret_cast<SHTexture::PixelChannel const*>(file.GetDDSData()));
-
-		asset.numBytes = totalBytes;
-		asset.width = file.GetWidth();
-		asset.height = file.GetHeight();
-		asset.format = ddsLoaderToVkFormat(file.GetFormat(), true);
-		asset.mipOffsets = std::move(mipOff);
-		asset.pixelData = std::move(pixel);
-	}
-}

SHADE_Engine/src/Assets/Libraries/SHTextureLoader.h

@@ -1,19 +0,0 @@
-#pragma once
-#define TINYDDSLOADER_IMPLEMENTATION
-
-#include "../SHAssetMacros.h"
-#include "../Asset Types/SHTextureAsset.h"
-#include "tinyddsloader.h"
-
-namespace SHADE
-{
-	class SHTextureLoader
-	{
-	private:
-		static std::string TinyDDSResultToString(tinyddsloader::Result value);
-		static vk::Format ddsLoaderToVkFormat(tinyddsloader::DDSFile::DXGIFormat format, bool isLinear);
-
-	public:
-		static void LoadImageAsset(AssetPath paths, SHTextureAsset& image);
-	};
-}

SHADE_Engine/src/Assets/SHAsset.h

@@ -1,16 +1,26 @@
+/*************************************************************************//**
+ * \file    SHAsset.h
+ * \author  Loh Xiao Qi
+ * \date    30 September 2022
+ * \brief   Struct for asset identification and meta file writing
+ * 
+ *
+ * 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 "Filesystem/SHFileSystem.h"
+#include "Assets/SHAssetMacros.h"
-#include "SHAssetMacros.h"
+#include "SH_API.h"
 
 namespace SHADE
 {
-	struct SHAsset
+	struct SH_API SHAsset
 	{
 		AssetName name;
 		AssetID id;
 		AssetType type;
 		AssetPath path;
-		FolderLocation location;
 	};
 }

SHADE_Engine/src/Assets/SHAssetMacros.h

@@ -32,69 +32,99 @@ typedef std::filesystem::path AssetPath;
 typedef unsigned char*				AssetData;
 typedef std::string						AssetMetaVersion;
 typedef std::string						AssetExtension;
-typedef unsigned char					AssetTypeMeta;
+typedef size_t					AssetTypeMeta;
 
 typedef FMOD::Sound*					SHSound;
 
 // Asset Meta Version
-#define ASSET_META_VER "1.0"
+constexpr std::string_view ASSET_META_VER { "1.0" };
 
 // Asset type enum
-enum class AssetType : uint8_t
+enum class AssetType : AssetTypeMeta
 {
-	INVALID = 0,
+	INVALID,
-	AUDIO = 1,
 	SHADER,
-	MATERIAL,
+	SHADER_BUILT_IN,
-	IMAGE,
+  TEXTURE,
-	TEXTURE,
+  MESH,
-	MESH,
+  SCENE,
-	SCRIPT,
+  PREFAB,
-	SCENE,
+  MATERIAL,
-	PREFAB,
+	MAX_COUNT
-	AUDIO_WAV,
-	DDS
 };
+constexpr size_t TYPE_COUNT{ static_cast<size_t>(AssetType::MAX_COUNT) };
 
 //Directory
-#define ASSET_ROOT "./Assets/"
+#ifdef _PUBLISH
+constexpr std::string_view ASSET_ROOT{ "Assets" };
+constexpr std::string_view BUILT_IN_ASSET_ROOT {"Built_In"};
+#else
+constexpr std::string_view ASSET_ROOT {"../../Assets"};
+constexpr std::string_view BUILT_IN_ASSET_ROOT{ "../../Built_In" };
+#endif
+
+// INTERNAL ASSET PATHS
+constexpr std::string_view SCENE_FOLDER{ "/Scenes/" };
+constexpr std::string_view PREFAB_FOLDER{ "/Prefabs/" };
+constexpr std::string_view MATERIAL_FOLDER{ "/Materials/" };
+
 
 // ASSET EXTENSIONS
-#define META_EXTENSION ".shmeta"
+constexpr std::string_view META_EXTENSION {".shmeta"};
-#define IMAGE_EXTENSION ".png"
+constexpr std::string_view AUDIO_EXTENSION {".ogg"};
-#define AUDIO_EXTENSION ".ogg"
+constexpr std::string_view AUDIO_WAV_EXTENSION {".wav"};
-#define AUDIO_WAV_EXTENSION ".wav"
+constexpr std::string_view SHADER_EXTENSION{ ".shshader" };
-#define SHADER_EXTENSION ".glsl"
+constexpr std::string_view SHADER_BUILT_IN_EXTENSION{".shshaderb"};
-#define SCRIPT_EXTENSION ".cs"
+constexpr std::string_view SCRIPT_EXTENSION {".cs"};
-#define SCENE_EXTENSION ".SHADE"
+constexpr std::string_view SCENE_EXTENSION {".shade"};
-#define PREFAB_EXTENSION ".SHPrefab"
+constexpr std::string_view PREFAB_EXTENSION {".shprefab"};
-#define MATERIAL_EXTENSION ".SHMat"
+constexpr std::string_view MATERIAL_EXTENSION {".shmat"};
-#define TEXTURE_EXTENSION ".shtex"
+constexpr std::string_view TEXTURE_EXTENSION {".shtex"};
-#define DDS_EXTENSION ".dds"
+constexpr std::string_view MESH_EXTENSION {".shmesh"};
-#define FBX_EXTENSION ".fbx"
-#define GLTF_EXTENSION ".gltf"
-#define MESH_EXTENSION ".shmesh"
 
-std::string const EXTENSIONS[] = {
+constexpr std::string_view EXTENSIONS[] = {
 	AUDIO_EXTENSION,
 	SHADER_EXTENSION,
+	SHADER_BUILT_IN_EXTENSION,
 	MATERIAL_EXTENSION,
-	IMAGE_EXTENSION,
 	TEXTURE_EXTENSION,
-	DDS_EXTENSION,
 	MESH_EXTENSION,
 	SCRIPT_EXTENSION,
 	SCENE_EXTENSION,
 	PREFAB_EXTENSION,
 	AUDIO_WAV_EXTENSION,
+};
+
+// EXTERNAL EXTENSIONS
+constexpr std::string_view GLSL_EXTENSION{ ".glsl" };
+constexpr std::string_view DDS_EXTENSION{ ".dds" };
+constexpr std::string_view FBX_EXTENSION{ ".fbx" };
+constexpr std::string_view GLTF_EXTENSION{ ".gltf" };
+
+constexpr std::string_view EXTERNALS[] = {
+	GLSL_EXTENSION,
+	DDS_EXTENSION,
 	FBX_EXTENSION,
 	GLTF_EXTENSION
 };
 
+// SHADER IDENTIFIERS
+constexpr std::string_view VERTEX_SHADER{ "_VS" };
+constexpr std::string_view FRAGMENT_SHADER{ "_FS" };
+constexpr std::string_view COMPUTER_SHADER{ "_CS" };
+
+constexpr std::string_view SHADER_IDENTIFIERS[] = {
+	VERTEX_SHADER,
+	FRAGMENT_SHADER,
+	COMPUTER_SHADER
+};
+
+constexpr size_t SHADER_TYPE_MAX_COUNT{ 3 };
+
 // Error flags
-#define FILE_NOT_FOUND_ERR "FILE NOT FOUND"
+constexpr std::string_view FILE_NOT_FOUND_ERR {"FILE NOT FOUND"};
-#define META_NOT_FOUND_ERR "META NOT FOUND"
+constexpr std::string_view META_NOT_FOUND_ERR {"META NOT FOUND"};
-#define ASSET_NOT_FOUND_ERR "ASSET NOT FOUND"
+constexpr std::string_view ASSET_NOT_FOUND_ERR {"ASSET NOT FOUND"};
-#define EXT_DOES_NOT_EXIST "TYPE DOES NOT HAVE EXTENSION DEFINED"
+constexpr std::string_view EXT_DOES_NOT_EXIST {"TYPE DOES NOT HAVE EXTENSION DEFINED"};
 
 #endif // !SH_ASSET_MACROS_H

SHADE_Engine/src/Assets/SHAssetManager.cpp

@@ -10,23 +10,33 @@
 #include "SHpch.h"
 #include <random>
 #include <chrono>
+#include <ranges>
 #include "SHAssetManager.h"
 #include "SHAssetMetaHandler.h"
-#include "Filesystem/SHFileSystem.h"
 
-#include "Libraries/SHMeshLoader.h"
+#include "Libraries/Loaders/SHMeshLoader.h"
-#include "Libraries/SHTextureLoader.h"
+#include "Libraries/Loaders/SHTextureLoader.h"
+#include "Libraries/Loaders/SHShaderSourceLoader.h"
+#include "Libraries/Loaders/SHTextBasedLoader.h"
+
+#include "Libraries/Compilers/SHMeshCompiler.h"
+#include "Libraries/Compilers/SHTextureCompiler.h"
+#include "Libraries/Compilers/SHShaderSourceCompiler.h"
+
+#include "Filesystem/SHFileSystem.h"
 
 namespace SHADE
 {
+  FolderPointer SHAssetManager::folderRoot{ nullptr };
+
 	FMOD::System* SHAssetManager::audioSystem;
 	std::unordered_map<AssetID, SHSound >* SHAssetManager::audioSoundList;
 
-	std::vector<SHAsset> SHAssetManager::assetCollection;
+	std::vector<SHAssetLoader*> SHAssetManager::loaders(TYPE_COUNT);
-	std::unordered_map<AssetID, SHAsset> SHAssetManager::assetRegistry;
 
-	std::unordered_map<AssetID, SHMeshAsset> SHAssetManager::meshCollection;
+	std::unordered_map<AssetID, SHAsset> SHAssetManager::assetCollection;
-	std::unordered_map<AssetID, SHTextureAsset> SHAssetManager::textureCollection;
+	std::unordered_map<AssetID, SHAssetData * const> SHAssetManager::assetData;
+  
 
 	/****************************************************************************
 	 * \brief   Static function to generate asset ID.
@@ -41,7 +51,7 @@ namespace SHADE
 
 		result |= unique;
 
-		while (result == 0)
+		while (result == 0 || assetCollection.contains(result))
 		{
 			result = GenerateAssetID(type);
 		}
@@ -51,11 +61,21 @@ namespace SHADE
 	/****************************************************************************
 	 * \brief   Deallocate all memory used by asset data
 	****************************************************************************/
-	void SHAssetManager::Unload() noexcept
+	void SHAssetManager::Unload(AssetID assetId) noexcept
 	{
-		for (auto const& asset : assetCollection)
+	// TODO
+	}
+
+	void SHAssetManager::Exit() noexcept
+	{
+    delete loaders[static_cast<size_t>(AssetType::SHADER)];
+    delete loaders[static_cast<size_t>(AssetType::TEXTURE)];
+    delete loaders[static_cast<size_t>(AssetType::MESH)];
+    delete loaders[static_cast<size_t>(AssetType::SCENE)];
+
+		for (auto const& data : std::ranges::views::values(assetData))
 		{
-			SHAssetMetaHandler::WriteMetaData(asset);
+			delete data;
 		}
 	}
 
@@ -69,14 +89,38 @@ namespace SHADE
 
 		AssetType type = SHAssetMetaHandler::GetTypeFromExtension(path.extension().string().c_str());
 		std::string folder;
-		switch (type)
+		//TODO Implement asset type generation
+		//switch (type)
+		//{
+		//default:
+		//	//TODO:ASSERT UNSUPPORTED FILE TYPE
+		//	return std::filesystem::path();
+		//}
+
+		return std::filesystem::path(std::string(ASSET_ROOT) + folder + path.filename().string());
+	}
+
+	AssetPath SHAssetManager::GenerateNewPath(AssetName name, AssetType type)
+	{
+		std::string folder;
+
+		switch(type)
 		{
+		case AssetType::SHADER:
+		case AssetType::SHADER_BUILT_IN:
+			folder = "Shaders/";
+			break;
+
 		default:
-			//TODO:ASSERT UNSUPPORTED FILE TYPE
+			folder = "/";
-			return std::filesystem::path();
 		}
 
-		return std::filesystem::path(ASSET_ROOT + folder + path.filename().string());
+		return std::filesystem::path{
+			std::string(ASSET_ROOT) + 
+			folder + 
+			name + 
+			std::string(EXTENSIONS[static_cast<size_t>(type)])
+		};
 	}
 
 	/****************************************************************************
@@ -84,9 +128,17 @@ namespace SHADE
 	 *
 	 * \return const& to unordered_map<AssetName, AssetID>
 	****************************************************************************/
-	std::vector<SHAsset> const& SHAssetManager::GetAllAssets() noexcept
+	std::vector<SHAsset> SHAssetManager::GetAllAssets() noexcept
 	{
-		return assetCollection;
+    std::vector<SHAsset> result;
+    result.reserve(assetCollection.size());
+
+    for (auto const& asset : std::ranges::views::values(assetCollection))
+    {
+      result.push_back(asset);
+    }
+
+		return result;
 	}
 
 	/****************************************************************************
@@ -99,27 +151,113 @@ namespace SHADE
 	****************************************************************************/
 	AssetID SHAssetManager::CreateNewAsset(AssetType type, AssetName name) noexcept
 	{
-		AssetID id{ GenerateAssetID(type) };
+    std::string newPath{ ASSET_ROOT };
-		SHAsset meta;
+    switch (type)
-		meta.id = id;
+    {
-		meta.type = type;
+    case AssetType::PREFAB:
+      newPath += PREFAB_FOLDER;
+      break;
 
-		std::string folder;
+    case AssetType::SCENE:
-		switch (type)
+      newPath += SCENE_FOLDER;
-		{
+      break;
-		default:
-			folder = "";
-			break;
-		}
-		AssetPath path{ ASSET_ROOT + folder + name + SHAssetMetaHandler::GetExtensionFromType(type) };
 
-		SHAssetMetaHandler::WriteMetaData(meta);
+    case AssetType::MATERIAL:
+      newPath += MATERIAL_FOLDER;
+      break;
 
-		assetCollection.push_back(meta);
+    default:
+      SHLOG_ERROR("Asset type of {} not an internal asset type, cannot be created", name);
+      return 0;
+    }
+
+    auto id = GenerateAssetID(type);
+    SHAsset asset{
+      name,
+      id,
+      type,
+      newPath
+    };
+
+    assetCollection.insert({
+      id,
+        SHAsset(
+          name,
+          id,
+          type,
+          newPath
+          )
+    });
 
 		return id;
 	}
 
+  bool SHAssetManager::SaveAsset(AssetID id) noexcept
+  {
+    if (assetCollection.contains(id))
+    {
+      auto const& asset = assetCollection[id];
+      if (
+        asset.type == AssetType::SCENE ||
+        asset.type == AssetType::PREFAB ||
+        asset.type == AssetType::MATERIAL
+        )
+      {
+        if (assetData.contains(id))
+        {
+          auto const data = assetData.at(id);
+          loaders[static_cast<size_t>(asset.type)]->Write(data, asset.path);
+          SHAssetMetaHandler::WriteMetaData(asset);
+
+          return true;
+        }
+
+        SHLOG_ERROR("Asset data has not been written into, cannot be saved: {}",
+          asset.path.filename().string());
+
+        return false;
+      }
+    }
+
+    SHLOG_WARNING("Asset id: {} not an internal asset type, save cannot be triggered", id);
+    return false;
+  }
+
+  bool SHAssetManager::DeleteAsset(AssetID id) noexcept
+  {
+
+    if (assetCollection.contains(id))
+    {
+      auto const& asset = assetCollection[id];
+      if (
+        asset.type == AssetType::SCENE ||
+        asset.type == AssetType::PREFAB ||
+        asset.type == AssetType::MATERIAL
+        )
+      {
+        return (DeleteLocalFile(asset.path) && DeleteLocalFile(asset.path.string() + META_EXTENSION.data()));
+      }
+      SHLOG_WARNING("Asset id: {} not an internal asset type, file deletion not allowed", id);
+    }
+
+    SHLOG_WARNING("Asset id does not exist, nothing was deleted: {}", id);
+    return false;
+  }
+
+  //AssetID SHAssetManager::CreateAsset(AssetName name, AssetType type) noexcept
+	//{
+	//	AssetID id = GenerateAssetID(type);
+
+	//	assetCollection.emplace_back(
+	//		name,
+	//		id,
+	//		type,
+	//		GenerateNewPath(name, type)
+	//	); 
+	//	return id;
+	//}
+
+
 	/****************************************************************************
 	 * \brief Import new asset from outside editor window.
 	 *
@@ -128,7 +266,10 @@ namespace SHADE
 	****************************************************************************/
 	AssetID SHAssetManager::ImportNewAsset(char const* p) noexcept
 	{
-		 std::filesystem::path const path{ p };
+		std::filesystem::path const path{ p };
+
+		auto const type = SHAssetMetaHandler::GetTypeFromExtension(path.extension().string());
+		auto const id = GenerateAssetID(type);
 
 		std::filesystem::path const newPath{ GenerateLocalPath(path) };
 		if (newPath.empty())
@@ -139,11 +280,8 @@ namespace SHADE
 
 		std::filesystem::copy(path, newPath);
 
-		AssetID id{ RetrieveAsset(newPath.string().c_str()) };
+    auto asset = CreateAssetFromPath(newPath);
-		if (id != 0)
+		assetCollection.insert({asset.id, asset});
-		{
-			LoadData(id);
-		}
 
 		return id;
 	}
@@ -154,135 +292,67 @@ namespace SHADE
 	****************************************************************************/
 	void SHAssetManager::RefreshAllAssets() noexcept
 	{
-		std::vector<AssetPath> metaFiles;
-		std::vector<AssetPath> AssetFiles;
 
-		//SHFileSystem::LoadAllFiles(metaFiles, AssetFiles);
+	}
-		//std::vector<AssetPath> AssetFilesVerified;
-		std::vector<AssetPath> AssetFilesNew;
 
-		for (auto const& asset : AssetFiles)
+	std::vector<SHAssetData const*> SHAssetManager::GetAllDataOfType(AssetType type) noexcept
+	{
+		auto const toRetrieve = GetAllRecordOfType(type);
+		std::vector<SHAssetData const*> result;
+		result.reserve(toRetrieve.size());
+		for (auto const& get : toRetrieve)
 		{
-			bool found = false;
+			result.push_back(LoadData(get));
-		  for (auto it {metaFiles.begin()}; it != metaFiles.end(); ++it)
+		}
-		  {
-				std::string fileExtCheck{ asset.filename().string() };
-				fileExtCheck += META_EXTENSION;
-				if (it->filename().string() == fileExtCheck)
-				{
-					metaFiles.erase(it);
-					found = true;
-					break;
-				}
-		  }
 
-			if (!found && IsRecognised(asset.extension().string().c_str()))
+		return result;
+	}
+
+	std::vector<SHAsset> SHAssetManager::GetAllRecordOfType(AssetType type) noexcept
+	{
+		std::vector<SHAsset> result;
+		for (auto const& asset : std::ranges::views::values(assetCollection))
+		{
+			if (asset.type == type)
 			{
-				AssetFilesNew.push_back(asset);
+				result.push_back(asset);
 			}
 		}
 
-		std::vector<SHAsset> newLoad;
-		newLoad.reserve(AssetFilesNew.size());
-
-		//TODO: Handle if meta does not match all assets (if meta exist and asset doesnt, vice versa)
-		for (auto const& file : AssetFilesNew)
-		{
-			newLoad.push_back(RegisterAssetNew(file));
-		}
-
-    //UpdateAllSpriteSets();
-
-	}
-
-	void SHAssetManager::LoadDataTemp(std::string p) noexcept
-	{
-		AssetPath path{ p };
-
-		if (path.extension().string() == GLTF_EXTENSION)
-		{
-			LoadGLTF(
-				{
-					.name {path.filename().string()},
-					.id {0},
-					.type {AssetType::MESH},
-					.path {path},
-					.location {0}
-				}
-			);
-		}
-		else if (path.extension().string() == DDS_EXTENSION)
-		{
-			LoadDDS(
-				{
-					.name {path.filename().string()},
-					.id {0},
-					.type {AssetType::DDS},
-					.path {path},
-					.location {0}
-				}
-			);
-		}
-	}
-
-	std::vector<SHMeshAsset> SHAssetManager::GetAllMeshes() noexcept
-	{
-		std::vector<SHMeshAsset> result;
-		for (auto const& mesh : meshCollection)
-		{
-			result.push_back(mesh.second);
-		}
-
 		return result;
 	}
 
-	std::vector<SHTextureAsset> SHAssetManager::GetAllTextures() noexcept
+	AssetID SHAssetManager::CompileAsset(AssetPath const& path) noexcept
 	{
-		std::vector<SHTextureAsset> result;
+		SHAsset newAsset
-		for (auto const& dds : textureCollection)
 		{
-			result.push_back(dds.second);
+			.name = path.stem().string()
+		};
+
+		auto const ext{ path.extension().string() };
+		if (ext == GLSL_EXTENSION.data())
+		{
+			newAsset.path = SHShaderSourceCompiler::LoadAndCompileShader(path).value();
+			newAsset.id = GenerateAssetID(AssetType::SHADER_BUILT_IN);
+			newAsset.type = AssetType::SHADER_BUILT_IN;
 		}
 
-		return result;
+    assetCollection.insert({ newAsset.id, newAsset });
+		SHAssetMetaHandler::WriteMetaData(newAsset);
+
+		return newAsset.id;
 	}
 
-	/****************************************************************************
+  FolderPointer SHAssetManager::GetRootFolder() noexcept
-	 * \param   Path for meta data file
+  {
-	 * \param   Path for asset file
+    return folderRoot;
+  }
 
-	 * \brief   Links meta data to asset in registries. Meta data should
+  bool SHAssetManager::IsRecognised(char const* ext) noexcept
-	 *					already exist
-	****************************************************************************/
-	void SHAssetManager::RegisterAsset(AssetPath const& metaPath, AssetPath const& path) noexcept
-	{
-		SHAsset const meta = SHAssetMetaHandler::RetrieveMetaData(metaPath);
-
-		assetCollection.push_back(meta);
-	}
-
-	/****************************************************************************
-	 * \param   Path for asset file
-
-	 * \brief   Creates new meta data for new asset.
-	****************************************************************************/
-	SHAsset SHAssetManager::RegisterAssetNew(AssetPath const& asset) noexcept
-	{
-		SHAsset meta;
-		meta.type = SHAssetMetaHandler::GetTypeFromExtension(asset.extension().string());
-		meta.id = GenerateAssetID(meta.type);
-
-		assetCollection.push_back(meta);
-
-		SHAssetMetaHandler::WriteMetaData(meta);
-		return assetCollection.back();
-	}
-
-	bool SHAssetManager::IsRecognised(char const* ext) noexcept
 	{
 		for (auto const& e : EXTENSIONS)
 		{
-			if (strcmp(ext, e.c_str()) == 0)
+			if (strcmp(ext, e.data()) == 0)
 			{
 				return true;
 			}
@@ -291,25 +361,96 @@ namespace SHADE
 		return false;
 	}
 
-	void SHAssetManager::LoadGLTF(SHAsset asset) noexcept
+	SHAsset SHAssetManager::CreateAssetFromPath(AssetPath path) noexcept
 	{
-		std::vector<SHMeshAsset> meshes;
+		SHAsset result;
 
-		SHMeshLoader::LoadMesh(meshes, asset.path);
+		result.name = path.stem().string();
+		result.type = SHAssetMetaHandler::GetTypeFromExtension(path.extension().string());
+		result.id = GenerateAssetID(result.type);
+		result.path = path;
 
-		for (auto const& mesh : meshes)
+		return result;
+	}
+
+	void SHAssetManager::CompileAll() noexcept
+	{
+		std::vector<AssetPath> paths;
+
+		for (auto const& dir : std::filesystem::recursive_directory_iterator{ ASSET_ROOT })
 		{
-			meshCollection.emplace(GenerateAssetID(AssetType::MESH), mesh);
+			if (dir.is_regular_file())
+			{
+				for (auto const& ext : EXTERNALS)
+				{
+					if (dir.path().extension().string() == ext.data())
+					{
+						paths.push_back(dir.path());
+					}
+				}
+			}
+		}
+
+		for (auto const& path : paths)
+		{
+			SHAsset newAsset
+			{
+				.name = path.stem().string()
+			};
+
+			auto const ext{ path.extension().string() };
+			if (ext == GLSL_EXTENSION.data())
+			{
+				newAsset.path = SHShaderSourceCompiler::LoadAndCompileShader(path).value();
+				newAsset.id = GenerateAssetID(AssetType::SHADER_BUILT_IN);
+				newAsset.type = AssetType::SHADER_BUILT_IN;
+			}
+			else if (ext == DDS_EXTENSION.data())
+			{
+				newAsset.path = SHTextureCompiler::CompileTextureAsset(path).value();
+				newAsset.id = GenerateAssetID(AssetType::TEXTURE);
+				newAsset.type = AssetType::TEXTURE;
+			}
+			else if (ext == GLTF_EXTENSION.data() || ext == FBX_EXTENSION.data())
+			{
+				std::vector<SHMeshAsset*> meshes;
+				std::vector<SHAnimationAsset*> anims;
+				SHMeshCompiler::LoadFromFile(path, meshes, anims);
+
+				for (auto const& mesh : meshes)
+				{
+					SHAsset meshAsset{
+						.name = mesh->header.name
+					};
+					meshAsset.path = SHMeshCompiler::CompileMeshBinary(*mesh, path).value();
+					meshAsset.id = GenerateAssetID(AssetType::MESH);
+					meshAsset.type = AssetType::MESH;
+          assetCollection.insert({ meshAsset.id, meshAsset });
+					SHAssetMetaHandler::WriteMetaData(meshAsset);
+				}
+				continue;
+			}
+
+      assetCollection.insert({ newAsset.id, newAsset });
+			SHAssetMetaHandler::WriteMetaData(newAsset);
 		}
 	}
 
-	void SHAssetManager::LoadDDS(SHAsset asset) noexcept
+  bool SHAssetManager::DeleteLocalFile(AssetPath path) noexcept
+  {
+    //TODO Move this to dedicated library
+    return std::filesystem::remove(path);
+  }
+
+  void SHAssetManager:: InitLoaders() noexcept
 	{
-		SHTextureAsset image;
+		loaders[static_cast<size_t>(AssetType::SHADER)] = dynamic_cast<SHAssetLoader*>(new SHShaderSourceLoader());
-
+		loaders[static_cast<size_t>(AssetType::SHADER_BUILT_IN)] = loaders[static_cast<size_t>(AssetType::SHADER)];
-		SHTextureLoader::LoadImageAsset(asset.path, image);
+		loaders[static_cast<size_t>(AssetType::TEXTURE)] = dynamic_cast<SHAssetLoader*>(new SHTextureLoader());
-
+		loaders[static_cast<size_t>(AssetType::MESH)] = dynamic_cast<SHAssetLoader*>(new SHMeshLoader());
-		textureCollection.emplace(GenerateAssetID(AssetType::DDS), image);
+		loaders[static_cast<size_t>(AssetType::SCENE)] = dynamic_cast<SHAssetLoader*>(new SHTextBasedLoader());
+		loaders[static_cast<size_t>(AssetType::PREFAB)] = loaders[static_cast<size_t>(AssetType::SCENE)];
+    loaders[static_cast<size_t>(AssetType::MATERIAL)] = loaders[static_cast<size_t>(AssetType::SCENE)];
 	}
 
 	/****************************************************************************
@@ -317,8 +458,10 @@ namespace SHADE
 	****************************************************************************/
 	void SHAssetManager::Load() noexcept
 	{
-		RetrieveAssets();
+		//CompileAll();
-		LoadAllData();
+    BuildAssetCollection();
+		InitLoaders();
+		//LoadAllData();
 	}
 
 	/****************************************************************************
@@ -326,116 +469,31 @@ namespace SHADE
 	****************************************************************************/
 	void SHAssetManager::LoadAllData() noexcept
 	{
-		for (auto const& asset : assetCollection)
+		for (auto const& asset : std::ranges::views::values(assetCollection))
 		{
+			SHAssetData* data = loaders[static_cast<size_t>(asset.type)]->Load(asset.path);
+			assetData.emplace(asset.id, data);
 		}
 	}
 
-	void SHAssetManager::LoadData(AssetID id) noexcept
+	SHAssetData* SHAssetManager::LoadData(SHAsset const& asset) noexcept
 	{
-		(void)id;
+		SHAssetData* data = loaders[static_cast<size_t>(asset.type)]->Load(asset.path);
-	}
 
-	/****************************************************************************
+		if (data == nullptr)
-	 * \brief   Retrieve all asset files and meta files from filesystem
-	****************************************************************************/
-	void SHAssetManager::RetrieveAssets() noexcept
-	{
-		std::vector<AssetPath> metaFiles;
-		std::vector<AssetPath> AssetFiles;
-
-		//TODO: Write new function for file manager to loop through all files
-		SHFileSystem::StartupFillDirectories(ASSET_ROOT);
-		FolderPointer rootFolder = SHFileSystem::GetRoot();
-
-		for (auto const& meta : metaFiles)
 		{
-			for (std::vector<AssetPath>::const_iterator it{ AssetFiles.cbegin() };
+			SHLOG_ERROR("Unable to load asset into memory: {}\n", asset.path.string());
-				it != AssetFiles.cend();
-				++it)
-			{
-				// Asset exists for meta file
-				std::string fileExtCheck{ it->filename().string() };
-				fileExtCheck += META_EXTENSION;
-				if (meta.filename().string() == fileExtCheck)
-				{
-					RegisterAsset(meta, *it);
-					AssetFiles.erase(it);
-					break;
-				}
-			}
-		}
-
-		//TODO: Handle if meta does not match all assets (if meta exist and asset doesnt, vice versa)
-		for (auto const& file : AssetFiles)
-		{
-			if (IsRecognised(file.extension().string().c_str()))
-			{
-				SHAssetMetaHandler::WriteMetaData(RegisterAssetNew(file));
-			}
-			else
-			{
-				std::cout << "Unsupported File Format: " << file.filename() << "\n";
-			}
-		}
-	}
-
-	AssetID SHAssetManager::RetrieveAsset(char const* path) noexcept
-	{
-		std::filesystem::path p{ path };
-		if (IsRecognised(p.extension().string().c_str()))
-		{
-			SHAsset const& meta{ RegisterAssetNew(p) };
-			SHAssetMetaHandler::WriteMetaData(meta);
-			return meta.id;
 		}
 		else
 		{
-			std::cout << "Unsupported File Format: " << p.filename() << "\n";
+			assetData.emplace(asset.id, data);
 		}
 
-		// Assert that file imported is not recognised
+		return data;
-		return 0;
 	}
 
-	/****************************************************************************
+  void SHAssetManager::BuildAssetCollection() noexcept
-	 * \param   Full path of file
+  {
-
+    SHFileSystem::BuildDirectory(ASSET_ROOT.data(), folderRoot, assetCollection);
-	 * \brief   Extracts file name from path. Formats file name into readable
+  }
-	 *					with spaces and capitalises first letter of every word
-	****************************************************************************/
-	AssetName SHAssetManager::GetNameFromPath(AssetPath filepath) noexcept
-	{
-		std::string name{ filepath.filename().string() };
-		name = name.substr(0, name.find_last_of('.'));
-
-		//if (name[0] <= 122 && name[0] >= 97)
-		//{
-		//	name[0] -= 32;
-		//}
-
-		//for (size_t i{ 1 }; i < name.length(); ++i)
-		//{
-		//	// Replace all underscores with spaces
-		//	if (name[i] == '_')
-		//	{
-		//		name[i] = ' ';
-		//		continue;
-		//	}
-
-		//	if (name[i + 1] <= 'Z' && name[i + 1] >= 'A'
-		//		&& name[i] <= 'z' && name[i] >= 'a')
-		//	{
-		//		name.insert(i + 1, 1, ' ');
-		//		continue;
-		//	}
-
-		//	if (name[i - 1] == ' ' && name[i] <= 'z' && name[i] >= 'a')
-		//	{
-		//		name[i] -= 32;
-		//	}
-		//}
-
-		return name;
-	}
 }

SHADE_Engine/src/Assets/SHAssetManager.h

@@ -10,10 +10,13 @@
 ******************************************************************************/
 #pragma once
 #include "tinyddsloader.h"
-#include "SHAsset.h"
 
-#include "Asset Types/SHMeshAsset.h"	
+#include "SHAsset.h"
-#include "Asset Types/SHTextureAsset.h"	
+#include "Asset Types/SHAssetData.h"
+#include "Assets/Libraries/Loaders/SHAssetLoader.h"
+
+#include "Filesystem/SHFolder.h"
+
 #include "SH_API.h"
 
 namespace SHADE
@@ -25,13 +28,16 @@ namespace SHADE
 		 * \brief   Static function to generate resource ID.
 		****************************************************************************/
 		static AssetID GenerateAssetID(AssetType type) noexcept;
-
 		static AssetPath GenerateLocalPath(AssetPath path) noexcept;
+		static AssetPath GenerateNewPath(AssetName name, AssetType type);
 
 		/****************************************************************************
 		 * \brief   Deallocate all memory used by resource data
 		****************************************************************************/
-		static void Unload() noexcept;
+		static void Exit() noexcept;
+
+
+    static void Unload(AssetID assetId) noexcept;
 
 		/****************************************************************************
 		 * \brief   Load all resources that are in the folder
@@ -43,7 +49,7 @@ namespace SHADE
 		 * 
 		 * \return const& to unordered_map<AssetName, AssetID>
 		****************************************************************************/
-		static std::vector<SHAsset> const& GetAllAssets() noexcept;
+		static std::vector<SHAsset> GetAllAssets() noexcept;
 
 		/****************************************************************************
 		 * \brief Create record for new resource. CAN ONLY CREATE FOR CUSTOM
@@ -53,7 +59,9 @@ namespace SHADE
 		 * \param name of resource
 		 * \return resource id generated for new asset
 		****************************************************************************/
-		static AssetID CreateNewAsset(AssetType, AssetName) noexcept;
+		static AssetID CreateNewAsset(AssetType type, AssetName name) noexcept;
+    static bool SaveAsset(AssetID id) noexcept;
+    static bool DeleteAsset(AssetID id) noexcept;
 
 		/****************************************************************************
 		 * \brief Import new resource from outside editor window.
@@ -70,64 +78,48 @@ namespace SHADE
 		static void RefreshAllAssets() noexcept;
 		// -------------------------------------------------------------------------/
 
-		//TODO: TEMPORARY FOR TESTING GLTF & DDS
+		template<typename T>
-		static void LoadDataTemp(std::string path) noexcept;
+		static std::enable_if_t<std::is_base_of_v<SHAssetData, T>, T* const> GetData(AssetID id) noexcept;
-		static std::vector<SHMeshAsset> GetAllMeshes() noexcept;
-		static std::vector<SHTextureAsset> GetAllTextures() noexcept;
 
+    template<typename T>
+    static std::enable_if_t<std::is_base_of_v<SHAssetData, T>, T const* const> GetConstData(AssetID id) noexcept;
+
+		static std::vector<SHAssetData const*> GetAllDataOfType(AssetType type) noexcept;
+		static std::vector<SHAsset> GetAllRecordOfType(AssetType type) noexcept;
+
+    static AssetID CompileAsset(AssetPath const& path) noexcept;
+
+    static FolderPointer GetRootFolder() noexcept;
+		
 	private:
-		/****************************************************************************
+
-		 * \brief   Load resource data into memory
+    static void InitLoaders() noexcept;
-		****************************************************************************/
 		static void LoadAllData() noexcept;
-
+		static SHAssetData* LoadData(SHAsset const& asset) noexcept;
-		static void LoadData(AssetID id) noexcept;
+		inline static void BuildAssetCollection() noexcept;
-
-		/****************************************************************************
-		 * \brief   Retrieve all resource files and meta files from filesystem
-		****************************************************************************/
-		static void RetrieveAssets() noexcept;
-
-		static AssetID RetrieveAsset(char const* path) noexcept;
-
-		/****************************************************************************
-		 * \param   Full path of file
-		
-		 * \brief   Extracts file name from path. Formats file name into readable
-		 *					with spaces and capitalises first letter of every word
-		****************************************************************************/
-		static AssetName GetNameFromPath(AssetPath) noexcept;
-
-		/****************************************************************************
-		 * \param   Path for meta data file
-		 * \param   Path for resource file
-		
-		 * \brief   Links meta data to resource in registries. Meta data should 
-		 *					already exist
-		****************************************************************************/
-		static void RegisterAsset(AssetPath const&, AssetPath const&) noexcept;
-
-		/****************************************************************************
-		 * \param   Path for resource file
-		
-		 * \brief   Creates new meta data for new resource.
-		****************************************************************************/
-		static SHAsset RegisterAssetNew(AssetPath const&) noexcept;
 
 		static bool IsRecognised(char const*) noexcept;
+		
+		static SHAsset CreateAssetFromPath(AssetPath	path) noexcept;
 
-		// Specialised load calls
+    static void CompileAll() noexcept;
-		static void LoadGLTF(SHAsset asset) noexcept;
+
-		static void LoadDDS(SHAsset asset) noexcept;
+    static bool DeleteLocalFile(AssetPath path) noexcept;
+
+    //TODO use this function to create asset data internall at all calls to generate id
+    //static AssetID CreateAsset(AssetName name, AssetType type) noexcept;
+
+    static FolderPointer folderRoot;
 
 		static FMOD::System* audioSystem;
 		static std::unordered_map<AssetID,SHSound>* audioSoundList;
 
-		// For all resources
+		static std::vector<SHAssetLoader*> loaders;
-		static std::vector<SHAsset> assetCollection;
-		static std::unordered_map<AssetID, SHAsset> assetRegistry;
 
-		static std::unordered_map<AssetID, SHMeshAsset> meshCollection;
+		// For all resources
-		static std::unordered_map<AssetID, SHTextureAsset> textureCollection;
+		static std::unordered_map<AssetID, SHAsset> assetCollection;
+		static std::unordered_map<AssetID, SHAssetData * const> assetData;
 	};
 }
+
+#include "SHAssetManager.hpp"

SHADE_Engine/src/Assets/SHAssetManager.hpp

@@ -0,0 +1,47 @@
+
+#include "SHAssetManager.h"
+
+namespace SHADE
+{
+	template<typename T>
+	std::enable_if_t<std::is_base_of_v<SHAssetData, T>, T* const> SHAssetManager::GetData(AssetID id) noexcept
+	{
+		if (!assetData.contains(id))
+		{
+			for (auto const& asset : std::ranges::views::values(assetCollection))
+			{
+				if (asset.id == id)
+				{
+					assetData.emplace(id, LoadData(asset));
+					return dynamic_cast<T* const>(assetData[id]);
+				}
+			}
+
+			SHLOG_ERROR("Asset ID provided does not exist: {}", id);
+			return nullptr;
+		}
+
+		return dynamic_cast<T* const>(assetData[id]);
+	}
+
+  template<typename T>
+  std::enable_if_t<std::is_base_of_v<SHAssetData, T>, T const * const> SHAssetManager::GetConstData(AssetID id) noexcept
+  {
+    if (!assetData.contains(id))
+    {
+      for (auto const& asset : std::ranges::views::values(assetCollection))
+      {
+        if (asset.id == id)
+        {
+          assetData.emplace(id, LoadData(asset));
+          return dynamic_cast<T const* const>(assetData[id]);
+        }
+      }
+
+      SHLOG_ERROR("Asset ID provided does not exist: {}", id);
+      return nullptr;
+    }
+
+    return dynamic_cast<T const* const>(assetData[id]);
+  }
+}

SHADE_Engine/src/Assets/SHAssetMetaHandler.cpp

@@ -37,7 +37,7 @@ namespace SHADE
 	{
 		for (int i{0}; i < EXTENSIONS->size(); ++i)
 		{
-			if (ext == EXTENSIONS[i])
+			if (strcmp(ext.c_str(), EXTENSIONS[i].data()) == 0)
 			{
 				return static_cast<AssetType>(i);
 			}
@@ -53,7 +53,7 @@ namespace SHADE
 	****************************************************************************/
 	AssetExtension SHAssetMetaHandler::GetExtensionFromType(AssetType type) noexcept
 	{
-		return EXTENSIONS[static_cast<size_t>(type)];
+		return AssetExtension(EXTENSIONS[static_cast<size_t>(type)]);
 	}
 
 	/****************************************************************************
@@ -72,6 +72,13 @@ namespace SHADE
 		std::string line;
 		SHAsset meta;
 
+		// Get resource name
+		GetFieldValue(metaFile, line);
+		std::stringstream nameStream{ line };
+		AssetName name;
+		nameStream >> name;
+		meta.name = name;
+
 		// Get resource id
 		GetFieldValue(metaFile, line);
 		std::stringstream idStream{ line };
@@ -88,6 +95,8 @@ namespace SHADE
 
 		metaFile.close();
 
+		meta.path = path.parent_path().string() + "/" + path.stem().string();
+
 		return meta;
 	}
 
@@ -99,19 +108,22 @@ namespace SHADE
 	****************************************************************************/
 	void SHAssetMetaHandler::WriteMetaData(SHAsset const& meta) noexcept
 	{
+		//TODO: Write into binary eventually
 		std::string path{ meta.path.string() };
 		path.append(META_EXTENSION);
 
-		std::ofstream metaFile{ path, std::ios_base::out };
+		std::ofstream metaFile{ path, std::ios_base::out | std::ios_base::trunc };
 
 		if (!metaFile.is_open())
 		{
 			SHLOG_ERROR("Asset write path is invalid: {}", path);
 			return;
 		}
-		
+
+		metaFile << "Name: " << meta.name << "\n";
 		metaFile << "ID: " << meta.id << "\n";
-		metaFile << "Type: " << static_cast<int>(meta.type) << std::endl;
+		metaFile << "Type: " << static_cast<AssetTypeMeta>(meta.type) << std::endl;
+
 		metaFile.close();
 	}
 

SHADE_Engine/src/AudioSystem/SHAudioSystem.cpp

@@ -90,11 +90,11 @@ namespace SHADE
     //PlayEventOnce("event:/SFX/Dawn/Dawn_Attack");
   }
   
-  void SHADE::SHAudioSystem::Run(float dt)
+  void SHADE::SHAudioSystem::Run(double dt)
   {
     static_cast<void>(dt); 
-    if (GetKeyState(VK_SPACE) & 0x8000)
+    //if (GetKeyState(VK_SPACE) & 0x8000)
-      PlayEventOnce("event:/Characters/sfx_footsteps_raccoon");
+    //  PlayEventOnce("event:/Characters/sfx_footsteps_raccoon");
 
     fmodStudioSystem->update();
     if (!denseListener->empty())
@@ -417,7 +417,7 @@ namespace SHADE
       int instanceCount = 0;
       event.second->getInstanceCount(&instanceCount);
       std::vector<FMOD::Studio::EventInstance*> instances(instanceCount);
-      event.second->getInstanceList(instances.data(), instances.size(), &instanceCount);
+      event.second->getInstanceList(instances.data(), static_cast<int>(instances.size()), &instanceCount);
       for (auto const& instance : instances)
       {
         instance->setPaused(pause);

SHADE_Engine/src/AudioSystem/SHAudioSystem.h

@@ -50,7 +50,7 @@ namespace SHADE
     ~SHAudioSystem();
 
     void Init();
-    void Run(float dt);
+    void Run(double dt);
     class SH_API AudioRoutine final : public SHSystemRoutine
     {
     public:

SHADE_Engine/src/Camera/SHCameraComponent.cpp

@@ -0,0 +1,247 @@
+#include "SHpch.h"
+#include "SHCameraComponent.h"
+#include "ECS_Base/Managers/SHComponentManager.h"
+#include "SHCameraSystem.h"
+#include "ECS_Base/Managers/SHSystemManager.h"
+#include "Math/Transform/SHTransformComponent.h"
+#include "Math/SHMath.h"
+
+namespace SHADE
+{
+	SHCameraComponent::SHCameraComponent()
+		:yaw(0.0f), pitch(0.0f), roll(0.0f)
+		, width(1920.0f), height(1080.0f), zNear(0.01f), zFar(10000.0f), fov(90.0f), movementSpeed(1.0f), turnSpeed(0.5f)
+		, perspProj(true), dirtyView(true), dirtyProj(true)
+		, viewMatrix(), projMatrix()
+		, position()
+	{
+		ComponentFamily::GetID<SHCameraComponent>();
+	}
+
+	SHCameraComponent::~SHCameraComponent()
+	{
+	}
+
+	void SHCameraComponent::SetYaw(float yaw) noexcept
+	{
+		this->yaw = yaw;
+		if (SHComponentManager::HasComponent<SHTransformComponent>(GetEID()))
+		{
+			auto transform = SHComponentManager::GetComponent<SHTransformComponent>(GetEID());
+			SHVec3 rotation = transform->GetWorldRotation();
+			transform->SetWorldRotation(SHVec3{rotation.x,SHMath::DegreesToRadians(yaw), rotation.z});
+		}
+		dirtyView = true;
+	}
+
+	void SHCameraComponent::SetPitch(float pitch) noexcept
+	{
+		this->pitch = pitch;
+		if (SHComponentManager::HasComponent<SHTransformComponent>(GetEID()))
+		{
+			auto transform = SHComponentManager::GetComponent<SHTransformComponent>(GetEID());
+			SHVec3 rotation = transform->GetWorldRotation();
+			transform->SetWorldRotation(SHVec3{ SHMath::DegreesToRadians(pitch),rotation.y, rotation.z });
+		}
+		dirtyView = true;
+	}
+
+	void SHCameraComponent::SetRoll(float roll) noexcept
+	{
+		this->roll = roll;
+		if (SHComponentManager::HasComponent<SHTransformComponent>(GetEID()))
+		{
+			auto transform = SHComponentManager::GetComponent<SHTransformComponent>(GetEID());
+			SHVec3 rotation = transform->GetWorldRotation();
+			transform->SetWorldRotation(SHVec3{ rotation.x,rotation.y,  SHMath::DegreesToRadians(roll)});
+		}
+		dirtyView = true;
+	}
+	void SHCameraComponent::SetPositionX(float x) noexcept
+	{
+		position.x = x;
+		if (SHComponentManager::HasComponent<SHTransformComponent>(GetEID()))
+		{
+			auto transform = SHComponentManager::GetComponent<SHTransformComponent>(GetEID());
+			SHVec3 position = transform->GetWorldPosition();
+			transform->SetWorldRotation(SHVec3{ x,position.y, position.z});
+		}
+		dirtyView = true;
+	}
+	void SHCameraComponent::SetPositionY(float y) noexcept
+	{
+		position.y = y;
+		if (SHComponentManager::HasComponent<SHTransformComponent>(GetEID()))
+		{
+			auto transform = SHComponentManager::GetComponent<SHTransformComponent>(GetEID());
+			SHVec3 position = transform->GetWorldPosition();
+			transform->SetWorldRotation(SHVec3{ position.x,y, position.z });
+		}
+		dirtyView = true;
+	}
+	void SHCameraComponent::SetPositionZ(float z) noexcept
+	{
+		position.z = z;
+		if (SHComponentManager::HasComponent<SHTransformComponent>(GetEID()))
+		{
+			auto transform = SHComponentManager::GetComponent<SHTransformComponent>(GetEID());
+			SHVec3 position = transform->GetWorldPosition();
+			transform->SetWorldRotation(SHVec3{ position.x,position.y, z });
+		}
+		dirtyView = true;
+	}
+	void SHCameraComponent::SetPosition(float x,float y, float z) noexcept
+	{
+		position.x = x;
+		position.y = y;
+		position.z = z;
+		if (SHComponentManager::HasComponent<SHTransformComponent>(GetEID()))
+		{
+			auto transform = SHComponentManager::GetComponent<SHTransformComponent>(GetEID());
+			SHVec3 position = transform->GetWorldPosition();
+			transform->SetWorldRotation(SHVec3{ x,y, z });
+		}
+		dirtyView = true;
+	}
+	void SHCameraComponent::SetPosition(SHVec3 pos) noexcept
+	{
+		this->position = pos;
+		if (SHComponentManager::HasComponent<SHTransformComponent>(GetEID()))
+		{
+			auto transform = SHComponentManager::GetComponent<SHTransformComponent>(GetEID());
+			SHVec3 position = transform->GetWorldPosition();
+			transform->SetWorldRotation(pos);
+		}
+		dirtyView = true;
+	}
+
+	void SHCameraComponent::SetWidth(float width) noexcept
+	{
+		this->width = width;
+		dirtyProj = true;
+	}
+
+
+	void SHCameraComponent::SetHeight(float height) noexcept
+	{
+		this->height = height;
+		dirtyProj = true;
+	}
+
+	void SHCameraComponent::SetNear(float znear) noexcept
+	{
+		this->zNear = znear;
+		dirtyProj = true;
+	}
+
+	void SHCameraComponent::SetFar(float zFar) noexcept
+	{
+		this->zFar = zFar;
+		dirtyProj = true;
+	}
+
+	void SHCameraComponent::SetFOV(float fov) noexcept
+	{
+		this->fov = fov;
+		dirtyProj = true;
+	}
+
+  void SHCameraComponent::SetIsPerspective(bool persp) noexcept
+  {
+    this->perspProj = persp;
+    dirtyProj = true;
+  }
+
+  SHVec3 SHCameraComponent::GetPosition() const noexcept
+  {
+    return position;
+  }
+
+	float SHCameraComponent::GetYaw() const noexcept
+	{
+		return yaw;
+	}
+
+	float SHCameraComponent::GetPitch() const noexcept
+	{
+		return pitch;
+	}
+	float SHCameraComponent::GetRoll() const noexcept
+	{
+		return roll;
+	}	
+
+  float SHCameraComponent::GetWidth() const noexcept
+  {
+    return width;
+  }
+
+  float SHCameraComponent::GetHeight() const noexcept
+  {
+    return height;
+  }
+
+  float SHCameraComponent::GetNear() const noexcept
+  {
+    return zNear;
+  }
+
+  float SHCameraComponent::GetFar() const noexcept
+  {
+    return zFar;
+  }
+
+	float SHCameraComponent::GetAspectRatio() const noexcept
+	{
+		return width/height;
+	}
+
+	float SHCameraComponent::GetFOV() const noexcept
+	{
+		return fov;
+	}
+
+  bool SHCameraComponent::GetIsPerspective() const noexcept
+  {
+    return perspProj;
+  }
+
+	const SHMatrix& SHCameraComponent::GetViewMatrix() const noexcept
+	{
+		return viewMatrix;
+	}
+
+	const SHMatrix& SHCameraComponent::GetProjMatrix() const noexcept
+	{
+		return projMatrix;
+	}
+
+	//void SHCameraComponent::SetMainCamera(size_t directorCameraIndex) noexcept
+	//{
+	//	auto system = SHSystemManager::GetSystem<SHCameraSystem>();
+	//	system->GetDirector(directorCameraIndex)->SetMainCamera(*this);
+	//}
+
+
+
+}//namespace SHADE
+
+
+RTTR_REGISTRATION
+{
+  using namespace SHADE;
+  using namespace rttr;
+
+  registration::class_<SHCameraComponent>("Camera Component")
+    .property("Position", &SHCameraComponent::GetPosition, select_overload<void(SHVec3)>(&SHCameraComponent::SetPosition))
+    .property("Pitch", &SHCameraComponent::GetPitch, &SHCameraComponent::SetPitch)
+    .property("Yaw", &SHCameraComponent::GetYaw, &SHCameraComponent::SetYaw)
+    .property("Roll", &SHCameraComponent::GetRoll, &SHCameraComponent::SetRoll)
+    .property("Width", &SHCameraComponent::GetWidth, &SHCameraComponent::SetWidth)
+    .property("Height", &SHCameraComponent::GetHeight, &SHCameraComponent::SetHeight)
+    .property("Near", &SHCameraComponent::GetNear, &SHCameraComponent::SetNear)
+    .property("Far", &SHCameraComponent::GetFar, &SHCameraComponent::SetFar)
+    .property("Perspective", &SHCameraComponent::GetIsPerspective, &SHCameraComponent::SetIsPerspective);
+
+
+}

SHADE_Engine/src/Camera/SHCameraComponent.h

@@ -0,0 +1,96 @@
+#pragma once
+
+#include <rttr/registration>
+
+#include "ECS_Base/Components/SHComponent.h"
+#include "Math/Vector/SHVec3.h"
+#include "Math/SHMatrix.h"
+#include "SH_API.h"
+
+namespace SHADE
+{
+
+	class SH_API SHCameraComponent final : public SHComponent
+	{
+	private:
+
+		float yaw;
+		float pitch;
+		float roll;
+
+		float width;
+		float height;
+		float zNear;
+		float zFar;
+		float fov;
+
+		bool dirtyView;
+		bool dirtyProj;
+
+
+		SHMatrix viewMatrix;
+		SHMatrix projMatrix;
+		SHVec3 position;
+
+		bool perspProj;
+
+
+
+
+	public:
+		friend class SHCameraSystem;
+
+		SHCameraComponent();
+		~SHCameraComponent();
+		
+
+		//Getters and setters.
+		void SetYaw(float yaw) noexcept;
+		void SetPitch(float pitch) noexcept;
+		void SetRoll(float roll) noexcept;
+		void SetPositionX(float x) noexcept;
+		void SetPositionY(float y) noexcept;
+		void SetPositionZ(float z) noexcept;
+		void SetPosition(float x, float y, float z) noexcept;
+		void SetPosition(SHVec3 pos) noexcept;
+
+		void SetWidth(float width) noexcept;
+		void SetHeight(float height) noexcept;
+		void SetNear(float znear) noexcept;
+		void SetFar(float zfar) noexcept;
+		void SetFOV(float fov) noexcept;
+    void SetIsPerspective(bool persp) noexcept;
+		
+		
+    SHVec3 GetPosition() const noexcept;
+		float GetYaw() const noexcept;
+		float GetPitch() const noexcept;
+		float GetRoll() const noexcept;
+
+    float GetWidth() const noexcept;
+    float GetHeight() const noexcept;
+    float GetNear() const noexcept;
+    float GetFar() const noexcept;
+    
+		float GetAspectRatio() const noexcept;
+		float GetFOV() const noexcept;
+    bool GetIsPerspective() const noexcept;
+
+		const SHMatrix& GetViewMatrix() const noexcept;
+		const SHMatrix& GetProjMatrix() const noexcept;
+
+		//void SetMainCamera(size_t cameraDirectorIndex = 0) noexcept;
+		
+
+		float movementSpeed;
+		SHVec3 turnSpeed;
+    RTTR_ENABLE()
+	protected:
+
+		
+
+    
+	};
+
+
+}

SHADE_Engine/src/Camera/SHCameraDirector.cpp

@@ -0,0 +1,65 @@
+#include "SHpch.h"
+#include "SHCameraDirector.h"
+#include "SHCameraComponent.h"
+#include "ECS_Base/Managers/SHComponentManager.h"
+#include "ECS_Base/SHECSMacros.h"
+#include "ECS_Base/Managers/SHEntityManager.h"
+#include "Tools/SHLog.h"
+
+namespace SHADE
+{
+	SHCameraDirector::SHCameraDirector()
+		:mainCameraEID(MAX_EID), transitionCameraEID(MAX_EID)
+	{
+	}
+
+
+	SHMatrix SHCameraDirector::GetViewMatrix() const noexcept
+	{
+		return viewMatrix;
+	}
+	SHMatrix SHCameraDirector::GetProjMatrix() const noexcept
+	{
+		return projMatrix;
+	}
+	SHMatrix SHCameraDirector::GetVPMatrix() const noexcept
+	{
+		return projMatrix * viewMatrix;
+	}
+
+	void SHCameraDirector::UpdateMatrix() noexcept
+	{
+		if (mainCameraEID == MAX_EID)
+		{
+			auto& dense = SHComponentManager::GetDense<SHCameraComponent>();
+			if (dense.size() == 0)
+			{
+				return;
+			}
+			mainCameraEID = dense[0].GetEID();
+		}
+		SHCameraComponent* camComponent = SHComponentManager::GetComponent_s<SHCameraComponent>(mainCameraEID);
+		if (!camComponent)
+		{
+			SHLOG_WARNING("Camera Director warning: Entity does not have a camera");
+		}
+		else
+		{
+			viewMatrix = camComponent->GetViewMatrix();
+			projMatrix = camComponent->GetProjMatrix();
+		}
+	}
+
+	void SHCameraDirector::SetMainCamera(SHCameraComponent& camera) noexcept
+	{
+		if (SHEntityManager::IsValidEID(camera.GetEID()) == false)
+		{
+			SHLOG_WARNING("Camera Director Warning: Attempting to set an invalid entity as main camera.")
+			return;
+		}
+		mainCameraEID = camera.GetEID();
+	}
+
+
+
+}

SHADE_Engine/src/Camera/SHCameraDirector.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "SH_API.h"
+#include "ECS_Base/Entity/SHEntity.h"
+#include "Math/SHMatrix.h"
+#include "Resource/SHHandle.h"
+
+
+namespace SHADE
+{
+	class SHCameraComponent;
+
+	
+
+	class SH_API SHCameraDirector
+	{
+	public:
+		SHCameraDirector();
+		~SHCameraDirector() = default;
+
+		
+		EntityID mainCameraEID;
+		EntityID transitionCameraEID;
+
+		SHMatrix GetViewMatrix() const noexcept;
+		SHMatrix GetProjMatrix() const noexcept;
+		SHMatrix GetVPMatrix() const noexcept;
+		void UpdateMatrix() noexcept;
+		void SetMainCamera(SHCameraComponent& cam) noexcept;
+
+
+	private:
+
+
+	protected:
+		SHMatrix viewMatrix;
+		SHMatrix projMatrix;
+
+	};
+
+	typedef Handle<SHCameraDirector> DirectorHandle;
+
+}

SHADE_Engine/src/Camera/SHCameraSystem.cpp

@@ -0,0 +1,291 @@
+#include "SHpch.h"
+#include "SHCameraSystem.h"
+#include "Math/SHMathHelpers.h"
+#include "Input/SHInputManager.h"
+#include "Math/Vector/SHVec2.h"
+#include "ECS_Base/Managers/SHComponentManager.h"
+#include "Math/Transform/SHTransformComponent.h"
+
+
+namespace SHADE
+{
+  void SHCameraSystem::UpdateEditorCamera(double dt) noexcept
+  {
+    
+    auto& camera = editorCamera;
+    SHVec3 view, right, UP;
+    GetCameraAxis(camera, view, right, UP);
+
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::A))
+    {
+      camera.position -= right * dt * camera.movementSpeed;
+      camera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::D))
+    {
+      camera.position += right * dt * camera.movementSpeed;
+      camera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::W))
+    {
+      camera.position += view * dt * camera.movementSpeed;
+      camera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::S))
+    {
+      camera.position -= view * dt * camera.movementSpeed;
+      camera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::Q))
+    {
+      camera.position += UP * dt * camera.movementSpeed;
+      camera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::E))
+    {
+      camera.position -= UP * dt * camera.movementSpeed;
+      camera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::RMB))
+    {
+      double mouseX, mouseY;
+      SHInputManager::GetMouseVelocity(&mouseX, &mouseY);
+
+      //std::cout << camera.yaw << std::endl;
+
+      camera.pitch -= mouseY * dt * camera.turnSpeed.x;
+      camera.yaw -= mouseX * dt * camera.turnSpeed.y;
+      camera.dirtyView = true;
+    }
+
+    UpdateCameraComponent(editorCamera);
+  }
+	void SHCameraSystem::EditorCameraUpdate::Execute(double dt) noexcept 
+	{
+    SHCameraSystem* system = static_cast<SHCameraSystem*>(GetSystem());
+    auto& camera = system->editorCamera;
+    SHVec3 view, right, UP;
+    system->GetCameraAxis(camera, view, right, UP);
+
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::A))
+    {
+      //std::cout << "Camera movement: "<<right.x<<", " << right.y << std::endl;
+      camera.position -= right * dt * camera.movementSpeed;
+      camera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::D))
+    {
+      camera.position += right * dt * camera.movementSpeed;
+      camera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::W))
+    {
+      camera.position += view * dt * camera.movementSpeed;
+      camera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::S))
+    {
+      camera.position -= view * dt * camera.movementSpeed;
+      camera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::Q))
+    {
+      camera.position += UP * dt * camera.movementSpeed;
+      camera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::E))
+    {
+      camera.position -= UP * dt * camera.movementSpeed;
+      camera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::RMB))
+    {
+      double mouseX, mouseY;
+      SHInputManager::GetMouseVelocity(&mouseX,&mouseY);
+      
+      //std::cout << camera.yaw << std::endl;
+
+      camera.pitch -= mouseY * dt * camera.turnSpeed.x;
+      camera.yaw -= mouseX * dt * camera.turnSpeed.y;
+      camera.dirtyView = true;
+    }
+
+    //std::cout << "Camera position: " << camera.position.x << " " << camera.position.y << std::endl;
+    system->UpdateCameraComponent(system->editorCamera);
+	}
+
+  void SHCameraSystem::Init(void) 
+  {
+    editorCamera.SetPosition(0.0f, 0.0f, 0.0f);
+    editorCamera.SetPitch(0.0f);
+    editorCamera.SetYaw(0.0f);
+    editorCamera.SetRoll(0.0f);
+    editorCamera.movementSpeed = 2.0f;
+    
+  }
+
+  void SHCameraSystem::Exit(void) 
+  {
+
+  }
+
+  SHCameraComponent* SHCameraSystem::GetEditorCamera(void) noexcept
+  {
+    return &editorCamera;
+  }
+
+  void SHCameraSystem::UpdateCameraComponent(SHCameraComponent& camera) noexcept
+	{
+    if (SHComponentManager::HasComponent<SHTransformComponent>(camera.GetEID()) == true && &camera != &editorCamera)
+    {
+      auto transform = SHComponentManager::GetComponent<SHTransformComponent>(camera.GetEID());
+      SHVec3 rotation = transform->GetWorldRotation();
+      camera.pitch = SHMath::RadiansToDegrees(rotation.x);
+      camera.yaw =   SHMath::RadiansToDegrees(rotation.y);
+      camera.roll =  SHMath::RadiansToDegrees(rotation.z);
+      camera.position = transform->GetWorldPosition();    
+      camera.dirtyView = true;
+    }
+    
+
+		if (camera.dirtyView)
+		{
+      
+      SHVec3 view, right, UP;
+
+      
+      ClampCameraRotation(camera);
+
+      GetCameraAxis(camera, view, right, UP);
+
+      camera.viewMatrix = SHMatrix::Identity;
+      camera.viewMatrix(0, 0) = right[0];
+      camera.viewMatrix(0, 1) = right[1];
+      camera.viewMatrix(0, 2) = right[2];
+
+      camera.viewMatrix(1, 0) = UP[0];
+      camera.viewMatrix(1, 1) = UP[1];
+      camera.viewMatrix(1, 2) = UP[2];
+
+      camera.viewMatrix(2, 0) = view[0];
+      camera.viewMatrix(2, 1) = view[1];
+      camera.viewMatrix(2, 2) = view[2];
+
+      camera.viewMatrix(0, 3) = -right.Dot(camera.position);
+      camera.viewMatrix(1, 3) = -UP.Dot(camera.position);
+      camera.viewMatrix(2, 3) = -view.Dot(camera.position);
+
+      camera.dirtyView = false;
+		}
+    if (camera.dirtyProj == true)
+    {
+      if (camera.perspProj == true)
+      {
+        const float ASPECT_RATIO = (camera.GetAspectRatio());
+        const float TAN_HALF_FOV = tan(SHMath::DegreesToRadians(camera.fov) * 0.5f);
+        camera.projMatrix = SHMatrix::Identity;
+        camera.projMatrix(0, 0) = 1.0f / (ASPECT_RATIO * TAN_HALF_FOV);
+        camera.projMatrix(1, 1) = 1.0f / TAN_HALF_FOV;
+        camera.projMatrix(2, 2) = camera.zFar / (camera.zFar - camera.zNear);
+        camera.projMatrix(3, 3) = 0.0f;
+
+        camera.projMatrix(3, 2) = 1.0f;
+        camera.projMatrix(2, 3) = -(camera.zFar * camera.zNear) / (camera.zFar - camera.zNear);
+        
+        
+        camera.dirtyProj = false;
+      }
+      else
+      {
+        //const float R = camera.width * 0.5f;
+        //const float L = -R;
+        //const float T = camera.height * 0.5f;
+        //const float B = -T;
+
+        //camera.projMatrix = SHMatrix::Identity;
+        //camera.projMatrix(0, 0) = 2.0f / (R - L);
+        //camera.projMatrix(1, 1) = 2.0f / (B - T);
+        //camera.projMatrix(2, 2) = 1.0f / (camera.zFar - camera.zNear);
+        //camera.projMatrix(3, 0) = -(R + L) / (R - L);
+        //camera.projMatrix(3, 1) = -(B + T) / (B - T);
+        //camera.projMatrix(3, 2) = -camera.zNear / (camera.zFar - camera.zNear);
+
+        camera.dirtyProj = false;
+      }
+    }
+	}
+
+  void SHCameraSystem::GetCameraAxis(SHCameraComponent const& camera, SHVec3& forward, SHVec3& right, SHVec3& upVec) const noexcept
+  {
+    SHVec3 target{ 0.0f,0.0f,-1.0f };
+    SHVec3 up = { 0.0f,1.0f,0.0f };
+
+
+    target = SHVec3::RotateX(target, SHMath::DegreesToRadians(camera.pitch));
+    target = SHVec3::RotateY(target, SHMath::DegreesToRadians(camera.yaw));
+    target += camera.position;
+    ////SHVec3::RotateZ(target, SHMath::DegreesToRadians(camera.roll));
+
+    //target = SHVec3::Normalise(target);
+
+    SHVec3::RotateZ(up, camera.roll);
+    up = SHVec3::Normalise(up);
+
+
+    forward = target - camera.position; forward = SHVec3::Normalise(forward);
+    right = SHVec3::Cross(forward, up); right = SHVec3::Normalise(right);
+    upVec = SHVec3::Cross(forward, right);
+  }
+
+  void SHCameraSystem::CameraSystemUpdate::Execute(double dt) noexcept
+  {
+    SHCameraSystem* system = static_cast<SHCameraSystem*>(GetSystem());
+    auto& dense = SHComponentManager::GetDense<SHCameraComponent>();
+    for (auto& cam : dense)
+    {
+      system->UpdateCameraComponent(cam);
+    }
+    for (auto& handle : system->directorHandleList)
+    {
+      handle->UpdateMatrix();
+    }
+
+
+  }
+
+
+  DirectorHandle SHCameraSystem::CreateDirector() noexcept
+  {
+    auto handle = directorLibrary.Create();
+    directorHandleList.emplace_back(handle);
+    return handle;
+  }
+
+  DirectorHandle SHCameraSystem::GetDirector(size_t index) noexcept
+  {
+    if (index < directorHandleList.size())
+    {
+      return directorHandleList[index];
+    }
+    else
+    {
+      return CreateDirector();
+    }
+  }
+  void SHCameraSystem::ClampCameraRotation(SHCameraComponent& camera) noexcept
+  {
+
+
+
+    if (camera.pitch > 85)
+      camera.SetPitch(85);
+    if (camera.pitch < -85)
+      camera.SetPitch(-85);
+    if (camera.roll > 85)
+      camera.SetRoll(85);
+    if (camera.roll < -85)
+      camera.SetRoll(-85);
+
+  }
+
+}

SHADE_Engine/src/Camera/SHCameraSystem.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "ECS_Base/System/SHSystem.h"
+#include "SHCameraComponent.h"
+#include "ECS_Base/System/SHSystemRoutine.h"
+#include "Resource/SHResourceLibrary.h"
+#include "SHCameraDirector.h"
+#include "SH_API.h"
+
+namespace SHADE
+{
+	class SH_API SHCameraSystem final : public SHSystem
+	{
+	private:
+		//A camera component that represents editor camera.
+		//This is not tied to any entity. Hence this EID should not be used.
+		SHCameraComponent editorCamera;
+		
+		SHResourceLibrary<SHCameraDirector> directorLibrary;
+		std::vector<DirectorHandle> directorHandleList;
+
+	public:
+    SHCameraSystem(void) = default;
+    virtual ~SHCameraSystem(void) = default;
+
+		void Init (void);
+		void Exit (void);
+
+		class SH_API EditorCameraUpdate final : public SHSystemRoutine
+		{
+		public:
+
+			EditorCameraUpdate() : SHSystemRoutine("Editor Camera Update", true) {  };
+			virtual void Execute(double dt) noexcept override final;
+
+		};
+		friend class EditorCameraUpdate;
+
+		class SH_API CameraSystemUpdate final: public SHSystemRoutine
+		{
+		public:
+			CameraSystemUpdate() : SHSystemRoutine("Camera System Update", false) {};
+			virtual void Execute(double dt)noexcept override final;
+		};
+		friend class CameraSystemUpdate;
+
+
+		SHCameraComponent* GetEditorCamera (void) noexcept;
+		void GetCameraAxis(SHCameraComponent const& camera, SHVec3& forward, SHVec3& right, SHVec3& up) const noexcept;
+		DirectorHandle CreateDirector() noexcept;
+		DirectorHandle GetDirector(size_t index) noexcept;
+		void ClampCameraRotation(SHCameraComponent& camera) noexcept;
+		void UpdateEditorCamera(double dt) noexcept;
+	protected:
+
+		void UpdateCameraComponent(SHCameraComponent& camera) noexcept;
+
+		
+
+	};
+
+
+
+}

SHADE_Engine/src/ECS_Base/Components/SHComponent.h

@@ -48,6 +48,9 @@ namespace SHADE
 		{
 		}
 
+		
+
+
 	public:
 		//Whether or not this component is active. 
 		//Systems using this component should are responsible for checking the active state of the component before running their functionality.
@@ -59,7 +62,7 @@ namespace SHADE
 		 * \return uint32_t 
 		 * The entityID that this component belongs to.
 		***************************************************************************/
-		uint32_t GetEID()const
+		uint32_t GetEID()const noexcept
 		{
 			return this->entityID;
 		}

SHADE_Engine/src/ECS_Base/System/SHFixedSystemRoutine.h

@@ -8,23 +8,19 @@ namespace SHADE
 {
 	class SHFixedSystemRoutine: public SHSystemRoutine
 	{
-	private:
-		double accumulatedTime;
-		double fixedTimeStep;
-
 	protected:
-		SHFixedSystemRoutine(double timeStep = DEFAULT_FIXED_STEP, std::string routineName = "Default Fixed Routine Name", bool editorPause = false)
+    double accumulatedTime;
+    double fixedTimeStep;
+
+    SHFixedSystemRoutine(double timeStep = DEFAULT_FIXED_STEP, std::string routineName = "Default Fixed Routine Name", bool editorPause = false)
 			:SHSystemRoutine(routineName, editorPause), accumulatedTime(0.0), fixedTimeStep(timeStep){}
 
-
-
 	public:
 		~SHFixedSystemRoutine() = default;
 		
-		virtual void Execute(double dt) noexcept;
+		virtual void Execute(double dt) noexcept override;
-
-		virtual void FixedExecute(double dt) noexcept {};
 
+		virtual void FixedExecute(double dt) noexcept {}
 	};
 
 

SHADE_Engine/src/Editor/Command/SHCommand.hpp

@@ -5,9 +5,13 @@
 //#==============================================================#
 #include <functional>
 
+#include "SH_API.h"
+#include "Scripting/SHScriptEngine.h"
+#include "ECS_Base/Managers/SHSystemManager.h"
+
 namespace SHADE
 {
-  class SHBaseCommand
+  class SH_API SHBaseCommand
   {
   public:
     virtual ~SHBaseCommand() = default;
@@ -20,6 +24,7 @@ namespace SHADE
   class SHCommand : SHBaseCommand
   {
   public:
+    using SHCommandPtr = std::unique_ptr<T>;
     typedef std::function<void(T const&)> SetterFunction;
 
     SHCommand(T const& oldVal, T const& value, SetterFunction setFnc)
@@ -48,4 +53,20 @@ namespace SHADE
     T newValue;
     SetterFunction set;
   };
+
+  class SH_API SHCLICommand : SHBaseCommand
+  {
+  public:
+    SHCLICommand() = default;
+    void Execute() override
+    {
+      SHScriptEngine* scriptEngine = static_cast<SHScriptEngine*>(SHSystemManager::GetSystem<SHScriptEngine>());
+      scriptEngine->RedoScriptInspectorChanges();
+    }
+    void Undo() override
+    {
+      SHScriptEngine* scriptEngine = static_cast<SHScriptEngine*>(SHSystemManager::GetSystem<SHScriptEngine>());
+      scriptEngine->UndoScriptInspectorChanges();
+    }
+  };
 }//namespace SHADE

SHADE_Engine/src/Editor/Command/SHCommandManager.cpp

@@ -13,7 +13,7 @@ namespace SHADE
   SHCommandManager::CommandStack SHCommandManager::undoStack{};
   SHCommandManager::CommandStack SHCommandManager::redoStack{};
 
-  void SHCommandManager::PerformCommand(CommandPtr commandPtr, bool const& overrideValue)
+  void SHCommandManager::PerformCommand(BaseCommandPtr commandPtr, bool const& overrideValue)
   {
     redoStack = CommandStack();
     commandPtr->Execute();
@@ -27,6 +27,11 @@ namespace SHADE
     }
   }
 
+  void SHCommandManager::RegisterCommand(BaseCommandPtr commandPtr)
+  {
+	  undoStack.push(commandPtr);
+  }
+
   void SHCommandManager::UndoCommand()
   {
     if (undoStack.empty())
@@ -54,4 +59,14 @@ namespace SHADE
   {
     return redoStack.size();
   }
+
+  void SHCommandManager::PopLatestCommandFromRedoStack()
+  {
+    redoStack.pop();
+  }
+
+  void SHCommandManager::PopLatestCommandFromUndoStack()
+  {
+    undoStack.pop();
+  }
 }//namespace SHADE

SHADE_Engine/src/Editor/Command/SHCommandManager.h

@@ -9,24 +9,31 @@
 //||                       SHADE Includes                       ||
 //#==============================================================#
 #include "SHCommand.hpp"
+#include "SH_API.h"
 
 namespace SHADE
 {
-  class SHCommandManager
+  class SH_API SHCommandManager
   {
   public:
     //#==============================================================#
     //||                        Type Aliases                        ||
     //#==============================================================#
-    using CommandPtr = std::shared_ptr<SHBaseCommand>;
+    using BaseCommandPtr = std::shared_ptr<SHBaseCommand>;
-    using CommandStack = std::stack<CommandPtr>;
+    template<typename T>
+    using SHCommandPtr = std::shared_ptr<SHCommand<T>>;
+    using CommandStack = std::stack<BaseCommandPtr>;
 
-    static void PerformCommand(CommandPtr commandPtr, bool const& overrideValue = false);
+    static void PerformCommand(BaseCommandPtr commandPtr, bool const& overrideValue = false);
+    static void RegisterCommand(BaseCommandPtr commandPtr);
     static void UndoCommand();
     static void RedoCommand();
     static std::size_t GetUndoStackSize();
     static std::size_t GetRedoStackSize();
 
+    static void PopLatestCommandFromRedoStack();
+    static void PopLatestCommandFromUndoStack();
+
   private:
     static CommandStack undoStack;
     static CommandStack redoStack;

SHADE_Engine/src/Editor/DragDrop/SHDragDrop.hpp

@@ -6,12 +6,12 @@
 namespace SHADE
 {
   //TODO: Convert to RTTR?
-  constexpr auto DRAG_EID = "DragEID";
-  constexpr auto DRAG_RESOURCE = "DragResource";
-
 
   struct SHDragDrop
   {
+    using DragDropTag = std::string_view;
+    static constexpr DragDropTag DRAG_EID = "DragEID";
+    static constexpr DragDropTag DRAG_RESOURCE = "DragResource";
     static bool BeginSource(ImGuiDragDropFlags const flags = 0);
     /**
      * \brief Ends the DragDrop Source. ONLY CALL IF BeginSource returns true

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

@@ -0,0 +1,164 @@
+#include "SHpch.h"
+#include "SHAssetBrowser.h"
+
+#include "Editor/IconsMaterialDesign.h"
+#include "Editor/SHImGuiHelpers.hpp"
+#include <imgui.h>
+#include <imgui_internal.h>
+
+#include "Assets/SHAssetManager.h"
+#include "Editor/IconsFontAwesome6.h"
+#include "Editor/DragDrop/SHDragDrop.hpp"
+
+namespace SHADE
+{
+  SHAssetBrowser::SHAssetBrowser()
+    :SHEditorWindow("\xee\x8b\x87 Asset Browser", ImGuiWindowFlags_MenuBar), rootFolder(SHAssetManager::GetRootFolder()), prevFolder(rootFolder), currentFolder(rootFolder)
+  {
+  }
+
+  void SHAssetBrowser::Init()
+  {
+    SHEditorWindow::Init();
+  }
+
+  void SHAssetBrowser::Update()
+  {
+    SHEditorWindow::Update();
+    if (Begin())
+    {
+      RecursivelyDrawTree(rootFolder);
+      DrawMenuBar();
+      DrawCurrentFolder();
+    }
+    ImGui::End();
+  }
+
+  void SHAssetBrowser::DrawMenuBar()
+  {
+    if (ImGui::BeginMenuBar())
+    {
+
+      ImGui::EndMenuBar();
+    }
+  }
+
+  ImRect SHAssetBrowser::RecursivelyDrawTree(FolderPointer folder)
+  {
+    auto const& subFolders = folder->subFolders;
+    auto const& files = folder->files;
+    const bool isSelected = std::ranges::find(selectedFolders, folder) != selectedFolders.end();
+    ImGuiTreeNodeFlags flags = (subFolders.empty() && files.empty()) ? ImGuiTreeNodeFlags_Leaf : ImGuiTreeNodeFlags_OpenOnArrow;
+    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());
+    const ImRect nodeRect = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
+    if(ImGui::IsItemClicked())
+    {
+      selectedFolders.clear();
+      selectedFolders.push_back(folder);
+    }
+    if (isOpen)
+    {
+      const ImColor treeLineColor = ImGui::GetColorU32(ImGuiCol_CheckMark);
+      const float horizontalOffset = 0.0f;
+      ImDrawList* drawList = ImGui::GetWindowDrawList();
+      ImVec2 vertLineStart = ImGui::GetCursorScreenPos();
+      vertLineStart.x += horizontalOffset;
+      ImVec2 vertLineEnd = vertLineStart;
+      for (auto const& subFolder : subFolders)
+      {
+        const float horizontalLineSize = 8.0f;
+        const ImRect childRect = RecursivelyDrawTree(subFolder);
+        const float midPoint = (childRect.Min.y + childRect.Max.y) * 0.5f;
+        drawList->AddLine(ImVec2(vertLineStart.x, midPoint), ImVec2(vertLineStart.x + horizontalLineSize, midPoint), treeLineColor, 1);
+        vertLineEnd.y = midPoint;
+      }
+      for (auto const& file : files)
+      {
+        const float horizontalLineSize = 25.0f;
+        const ImRect childRect = DrawFile(file);
+        const float midPoint = (childRect.Min.y + childRect.Max.y) * 0.5f;
+        drawList->AddLine(ImVec2(vertLineStart.x, midPoint), ImVec2(vertLineStart.x + horizontalLineSize, midPoint), treeLineColor, 1);
+        vertLineEnd.y = midPoint;
+      }
+      drawList->AddLine(vertLineStart, vertLineEnd, treeLineColor, 1);
+      ImGui::TreePop();
+    }
+    return nodeRect;
+  }
+
+  void SHAssetBrowser::DrawCurrentFolder()
+  {
+    //auto const& subFolders = currentFolder->subFolders;
+    //ImVec2 initialCursorPos = ImGui::GetCursorPos();
+    //ImVec2 initialRegionAvail = ImGui::GetContentRegionAvail();
+    //int maxTiles = initialRegionAvail.x / tileWidth;
+    //float maxX = (maxTiles - 1)*tileWidth;
+    //ImVec2 tilePos = initialCursorPos;
+    //for (auto const& subFolder : subFolders)
+    //{
+    //  ImGui::SetCursorPos(tilePos);
+    //  ImGui::BeginGroup();
+    //  ImGui::PushStyleVar(ImGuiStyleVar_ItemInnerSpacing, {0.0f, 0.0f});
+    //  ImGui::Button(ICON_MD_FOLDER, {tileWidth});
+    //  ImGui::Text(subFolder->name.data());
+    //  ImGui::PopStyleVar();
+    //  ImGui::EndGroup();
+    //  if(tilePos.x >= maxX)
+    //  {
+    //    tilePos.x = initialCursorPos.x;
+    //  }
+    //  else
+    //  {
+    //    ImGui::SameLine();
+    //    tilePos.x += tileWidth;
+    //  }
+    //}
+  }
+
+  ImRect SHAssetBrowser::DrawFile(SHFile const& file) noexcept
+  {
+    if (file.assetMeta == nullptr)
+      return ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
+    const bool isSelected = std::ranges::find(selectedAssets, file.assetMeta->id) != selectedAssets.end();
+    ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_Leaf;
+    if (isSelected)
+      flags |= ImGuiTreeNodeFlags_Selected;
+    std::string icon{};
+
+    switch(file.assetMeta->type)
+    {
+    case AssetType::INVALID: break;
+    case AssetType::SHADER: icon = ICON_FA_FILE_CODE; break;
+    case AssetType::SHADER_BUILT_IN: icon = ICON_FA_FILE_CODE; break;
+    case AssetType::TEXTURE: icon = ICON_FA_IMAGES; break;
+    case AssetType::MESH: icon = ICON_FA_CUBES; break;
+    case AssetType::SCENE: icon = ICON_MD_IMAGE; break;
+    case AssetType::PREFAB: icon = ICON_FA_BOX_OPEN; break;
+    case AssetType::MATERIAL: break;
+    case AssetType::MAX_COUNT: break;
+    default: ;
+    }
+
+    ImGui::TreeNodeEx(file.assetMeta, flags, "%s %s", icon.data(), file.assetMeta->name.data());
+    const ImRect nodeRect = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
+    if(SHDragDrop::BeginSource())
+    {
+      auto id = file.assetMeta->id;
+      ImGui::Text("Moving Asset: %s [%zu]", file.name.data(), file.assetMeta->id);
+      SHDragDrop::SetPayload<AssetID>(SHDragDrop::DRAG_RESOURCE, &id);
+      SHDragDrop::EndSource();
+    }
+    if(ImGui::IsItemClicked())
+    {
+      selectedAssets.clear();
+      selectedAssets.push_back(file.assetMeta->id);
+    }
+    ImGui::TreePop();
+    return nodeRect;
+  }
+}

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

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "imgui_internal.h"
+#include "Assets/SHAsset.h"
+#include "Editor/EditorWindow/SHEditorWindow.h"
+#include "Filesystem/SHFolder.h"
+
+namespace SHADE
+{
+  class SHAssetBrowser final : public SHEditorWindow
+  {
+  public:
+    SHAssetBrowser();
+
+    void Init();
+    void Update();
+
+    void Refresh();
+  private:
+    void DrawMenuBar();
+    ImRect RecursivelyDrawTree(FolderPointer folder);
+    void DrawCurrentFolder();
+    ImRect DrawFile(SHFile const& file) noexcept;
+
+    FolderPointer rootFolder, prevFolder, currentFolder;
+    std::vector<FolderPointer> selectedFolders;
+    std::vector<AssetID> selectedAssets;
+    static constexpr float tileWidth = 50.0f;
+    
+  };
+}

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

@@ -6,11 +6,11 @@
 //#==============================================================#
 //||                       SHADE Includes                       ||
 //#==============================================================#
+#include "Editor/SHEditor.h"
 #include "Editor/SHImGuiHelpers.hpp"
 #include "Editor/SHEditorWidgets.hpp"
 #include "SHHierarchyPanel.h"
 #include "ECS_Base/Managers/SHEntityManager.h"
-#include "Editor/SHEditor.hpp"
 #include "Scene/SHSceneManager.h"
 #include "Editor/DragDrop/SHDragDrop.hpp"
 #include "Tools/SHException.h"
@@ -21,6 +21,9 @@
 //#==============================================================#
 #include <imgui.h>
 
+#include "Serialization/SHSerialization.h"
+#include "Tools/SHClipboardUtilities.h"
+
 
 namespace SHADE
 {
@@ -45,14 +48,28 @@ namespace SHADE
 
     if (Begin())
     {
+      if (skipFrame)
+      {
+        ImGui::End();
+        skipFrame = false;
+        return;
+      }
       DrawMenuBar();
       auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
-      if(const auto root = sceneGraph.GetRoot())
+
+      if (const auto root = sceneGraph.GetRoot())
       {
         auto const& children = root->GetChildren();
+
         for (const auto child : children)
         {
-          RecursivelyDrawEntityNode(child);
+          if (child)
+            RecursivelyDrawEntityNode(child);
+          if (skipFrame)
+          {
+            ImGui::End();
+            return;
+          }
         }
       }
       else
@@ -60,13 +77,38 @@ namespace SHADE
         SHLOG_WARNING("Scene Graph root is null! Unable to render hierarchy.")
       }
 
-      if(ImGui::IsWindowHovered() && !SHDragDrop::hasDragDrop && !ImGui::IsAnyItemHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Left))
+      if (ImGui::IsWindowHovered() && !SHDragDrop::hasDragDrop && !ImGui::IsAnyItemHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Left))
       {
-        SHEditor::selectedEntities.clear();
+        if (auto editor = SHSystemManager::GetSystem<SHEditor>())
+          editor->selectedEntities.clear();
       }
       ImGui::SeparatorEx(ImGuiSeparatorFlags_Horizontal);
-      ImGui::End();
+      if (ImGui::IsWindowFocused())
+      {
+        if (ImGui::IsKeyDown(ImGuiKey_LeftCtrl) && ImGui::IsKeyReleased(ImGuiKey_A))
+        {
+          SelectAllEntities();
+        }
+        if (ImGui::IsKeyDown(ImGuiKey_LeftCtrl) && ImGui::IsKeyReleased(ImGuiKey_C))
+        {
+          CopySelectedEntities();
+        }
+        if (ImGui::IsKeyDown(ImGuiKey_LeftCtrl) && !ImGui::IsKeyDown(ImGuiKey_LeftShift) && ImGui::IsKeyReleased(ImGuiKey_V))
+        {
+          PasteEntities();
+        }
+        if (ImGui::IsKeyDown(ImGuiKey_LeftCtrl) && ImGui::IsKeyDown(ImGuiKey_LeftShift) && ImGui::IsKeyReleased(ImGuiKey_V))
+        {
+          const auto editor = SHSystemManager::GetSystem<SHEditor>();
+          if (editor->selectedEntities.size() == 1)
+          {
+            PasteEntities(editor->selectedEntities.back());
+          }
+        }
+      }
+
     }
+    ImGui::End();
   }
 
   void SHHierarchyPanel::Exit()
@@ -74,6 +116,13 @@ namespace SHADE
     SHEditorWindow::Exit();
   }
 
+  void SHHierarchyPanel::SetScrollTo(EntityID eid)
+  {
+    if (eid == MAX_EID)
+      return;
+    scrollTo = eid;
+  }
+
   //#==============================================================#
   //||                  Private Member Functions                  ||
   //#==============================================================#
@@ -81,9 +130,23 @@ namespace SHADE
   {
     if (ImGui::BeginMenuBar())
     {
-      if (ImGui::SmallButton(ICON_MD_ADD))
+      auto size = ImGui::GetWindowSize();
+      auto g = ImGui::GetCurrentContext();
+      ImGui::SetCursorPosX(size.x - g->Style.FramePadding.x * 15.0f);
+      if (ImGui::SmallButton(ICON_MD_CLEAR_ALL))
       {
-        SHEntityManager::CreateEntity();
+        auto editor = SHSystemManager::GetSystem<SHEditor>();
+        editor->selectedEntities.clear();
+      }
+      if (ImGui::IsItemHovered())
+      {
+        ImGui::BeginTooltip();
+        ImGui::Text("Clear Selections");
+        ImGui::EndTooltip();
+      }
+      if (ImGui::SmallButton(ICON_MD_ADD_CIRCLE))
+      {
+        SHCommandManager::PerformCommand(std::make_shared<SHCreateEntityCommand>());
       }
       if (ImGui::IsItemHovered())
       {
@@ -95,14 +158,25 @@ namespace SHADE
     }
   }
 
-  ImRect SHHierarchyPanel::RecursivelyDrawEntityNode(SHSceneNode* currentNode)
+  ImRect SHHierarchyPanel::RecursivelyDrawEntityNode(SHSceneNode* const currentNode)
   {
+    if (currentNode == nullptr)
+      return {};
     auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
 
     //Get node data (Children, eid, selected)
     auto& children = currentNode->GetChildren();
     EntityID eid = currentNode->GetEntityID();
-    const bool isSelected = (std::ranges::find(SHEditor::selectedEntities, eid) != SHEditor::selectedEntities.end());
+
+    if (scrollTo != MAX_EID && eid == scrollTo)
+    {
+      ImGui::SetScrollHereY();
+      scrollTo = MAX_EID;
+    }
+
+    auto editor = SHSystemManager::GetSystem<SHEditor>();
+
+    const bool isSelected = (std::ranges::find(editor->selectedEntities, eid) != editor->selectedEntities.end());
 
     const ImGuiTreeNodeFlags nodeFlags = ((isSelected) ? ImGuiTreeNodeFlags_Selected : 0) | ((children.empty()) ? ImGuiTreeNodeFlags_Leaf : ImGuiTreeNodeFlags_OpenOnArrow);
 
@@ -114,43 +188,70 @@ namespace SHADE
 
     auto* entity = SHEntityManager::GetEntityByID(currentNode->GetEntityID());
     //Draw Node
-    bool isNodeOpen = ImGui::TreeNodeEx((void*)eid, nodeFlags, "%u: %s", EntityHandleGenerator::GetIndex(eid), entity->name.c_str());
+    bool isNodeOpen = ImGui::TreeNodeEx(reinterpret_cast<void*>(entity), nodeFlags, "%u: %s", SHEntityManager::GetEntityIndex(eid), entity->name.c_str());
     const ImRect nodeRect = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
 
     //Check For Begin Drag
     if (SHDragDrop::BeginSource())
     {
-      ImGui::Text("Moving EID: %zu", eid);
+      std::string moveLabel = "Moving EID: ";
-      SHDragDrop::SetPayload<EntityID>(DRAG_EID, &eid);
+      if (!isSelected)
+        editor->selectedEntities.push_back(eid);
+      for (int i = 0; i < static_cast<int>(editor->selectedEntities.size()); ++i)
+      {
+        moveLabel.append(std::to_string(editor->selectedEntities[i]));
+        if (i + 1 < static_cast<int>(editor->selectedEntities.size()))
+        {
+          moveLabel.append(", ");
+        }
+      }
+      ImGui::Text(moveLabel.c_str());
+      SHDragDrop::SetPayload<std::vector<EntityID>>(SHDragDrop::DRAG_EID, &editor->selectedEntities);
       SHDragDrop::EndSource();
     }
     else if (SHDragDrop::BeginTarget()) //If Received DragDrop
     {
-      if (const EntityID* eidPayload = SHDragDrop::AcceptPayload<EntityID>(DRAG_EID)) //If payload is valid
+      if (const std::vector<EntityID>* eidPayload = SHDragDrop::AcceptPayload<std::vector<EntityID>>(SHDragDrop::DRAG_EID)) //If payload is valid
       {
-        EntityID const dropEID = *eidPayload;
+        ParentSelectedEntities(eid);
-        if(!sceneGraph.GetChild(dropEID, eid))
-          sceneGraph.SetParent(dropEID, eid); //Set dropEID parent to eid (belonging to current Node)
         SHDragDrop::EndTarget();
       }
     }
 
     //Context menu
-    if(ImGui::BeginPopupContextItem(std::to_string(eid).c_str()))
+    if (ImGui::BeginPopupContextItem(std::to_string(eid).c_str()))
     {
-      if(!isSelected)
+      if (!isSelected)
       {
-        SHEditor::selectedEntities.clear();
+        editor->selectedEntities.clear();
-        SHEditor::selectedEntities.push_back(eid);
+        editor->selectedEntities.push_back(eid);
       }
-      if(ImGui::Selectable(std::format("{} Delete", ICON_MD_DELETE).data()))
+      if (ImGui::Selectable("Copy"))
+      {
+        CopySelectedEntities();
+      }
+      if (ImGui::Selectable("Paste"))
+      {
+        PasteEntities();
+        skipFrame = true;
+        ImGui::EndPopup();
+        if (isNodeOpen)
+          ImGui::TreePop();
+        return nodeRect;
+      }
+      if (ImGui::Selectable("Paste as Child"))
+      {
+        PasteEntities(eid);
+        skipFrame = true;
+      }
+      if (ImGui::Selectable(std::format("{} Delete", ICON_MD_DELETE).data()))
       {
         SHEntityManager::DestroyEntity(eid);
       }
-      
+
-      if((currentNode->GetParent() != sceneGraph.GetRoot()) && ImGui::Selectable(std::format("{} Unparent Selected", ICON_MD_NORTH_WEST).data()))
+      if ((currentNode->GetParent() != sceneGraph.GetRoot()) && ImGui::Selectable(std::format("{} Unparent Selected", ICON_MD_NORTH_WEST).data()))
       {
-        sceneGraph.SetParent(currentNode->GetEntityID(), nullptr);
+        ParentSelectedEntities(MAX_EID);
       }
       ImGui::EndPopup();
     }
@@ -162,20 +263,28 @@ namespace SHADE
       {
         if (!isSelected)
         {
-          if (!ImGui::IsKeyDown(ImGuiKey_LeftCtrl))
+          if (ImGui::IsKeyDown(ImGuiKey_LeftShift))
-            SHEditor::selectedEntities.clear();
+          {
-          SHEditor::selectedEntities.push_back(eid);
+            if (editor->selectedEntities.size() >= 1)
+            {
+              SelectRangeOfEntities(editor->selectedEntities[0], eid);
+            }
+            else editor->selectedEntities.clear();
+          }
+          else if (!ImGui::IsKeyDown(ImGuiKey_LeftCtrl))
+            editor->selectedEntities.clear();
+          editor->selectedEntities.push_back(eid);
         }//if not selected
         else
         {
           if (!ImGui::IsKeyDown(ImGuiKey_LeftCtrl))
           {
-            auto it = std::ranges::remove(SHEditor::selectedEntities, eid).begin();
+            auto it = std::ranges::remove(editor->selectedEntities, eid).begin();
           }//if mod ctrl is not pressed
           else
           {
-            SHEditor::selectedEntities.clear();
+            editor->selectedEntities.clear();
-            SHEditor::selectedEntities.push_back(eid);
+            editor->selectedEntities.push_back(eid);
           }
         }//if selected
       }//if left mouse button released
@@ -209,4 +318,113 @@ namespace SHADE
   {
     SHEntityManager::CreateEntity(MAX_EID, "DefaultChild", parentEID);
   }
+
+  void SHHierarchyPanel::ParentSelectedEntities(EntityID parentEID) const noexcept
+  {
+    auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
+    auto const editor = SHSystemManager::GetSystem<SHEditor>();
+    SHEntityParentCommand::EntityParentData entityParentData;
+    std::vector<EntityID> parentedEIDS;
+    for (auto const& eid : editor->selectedEntities)
+    {
+      if (sceneGraph.GetChild(eid, parentEID) == nullptr)
+      {
+        parentedEIDS.push_back(eid);
+        if (auto parent = sceneGraph.GetParent(eid))
+          entityParentData[eid].oldParentEID = parent->GetEntityID();
+        entityParentData[eid].newParentEID = parentEID;
+      }
+    }
+    SHCommandManager::PerformCommand(std::make_shared<SHEntityParentCommand>(parentedEIDS, entityParentData));
+  }
+
+  void SHHierarchyPanel::SelectRangeOfEntities(EntityID beginEID, EntityID endEID)
+  {
+    bool startSelecting = false; bool endSelecting = false;
+    auto const editor = SHSystemManager::GetSystem<SHEditor>();
+    editor->selectedEntities.clear();
+    auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
+    sceneGraph.Traverse([&](SHSceneNode* nodePtr)
+      {
+        auto eid = nodePtr->GetEntityID();
+        if (!startSelecting)
+        {
+          if (eid == beginEID || eid == endEID)
+          {
+            startSelecting = true;
+            editor->selectedEntities.push_back(eid);
+          }
+        }
+        else
+        {
+          if (!endSelecting)
+          {
+            editor->selectedEntities.push_back(eid);
+            if (eid == endEID || eid == beginEID)
+            {
+              endSelecting = true;
+            }
+          }
+        }
+      });
+  }
+
+  void SHHierarchyPanel::SelectAllEntities()
+  {
+    const auto editor = SHSystemManager::GetSystem<SHEditor>();
+    editor->selectedEntities.clear();
+    auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
+    sceneGraph.Traverse([&](SHSceneNode* nodePtr)
+      {
+        auto eid = nodePtr->GetEntityID();
+        editor->selectedEntities.push_back(eid);
+      });
+  }
+
+  void SHHierarchyPanel::CopySelectedEntities()
+  {
+    const auto editor = SHSystemManager::GetSystem<SHEditor>();
+    SHClipboardUtilities::WriteToClipboard(SHSerialization::SerializeEntitiesToString(editor->selectedEntities));
+  }
+
+  void SHHierarchyPanel::PasteEntities(EntityID parentEID)
+  {
+    SetScrollTo(SHSerialization::DeserializeEntitiesFromString(SHClipboardUtilities::GetDataFromClipboard(), parentEID));
+  }
+
+  void SHCreateEntityCommand::Execute()
+  {
+    EntityID newEID = SHEntityManager::CreateEntity(eid);
+    if (eid == MAX_EID)
+      eid = newEID;
+  }
+
+  void SHCreateEntityCommand::Undo()
+  {
+    SHEntityManager::DestroyEntity(eid);
+  }
+
+  void SHEntityParentCommand::Execute()
+  {
+    auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
+    for (auto const& eid : entities)
+    {
+      if (entityParentData[eid].newParentEID == MAX_EID)
+        sceneGraph.SetParent(eid, nullptr);
+      else
+        sceneGraph.SetParent(eid, entityParentData[eid].newParentEID);
+    }
+  }
+
+  void SHEntityParentCommand::Undo()
+  {
+    auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
+    for (auto const& eid : entities)
+    {
+      if (entityParentData[eid].oldParentEID == MAX_EID)
+        sceneGraph.SetParent(eid, nullptr);
+      else
+        sceneGraph.SetParent(eid, entityParentData[eid].oldParentEID);
+    }
+  }
 }//namespace SHADE

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

@@ -10,7 +10,7 @@
 #include "imgui_internal.h"
 #include "ECS_Base/SHECSMacros.h"
 #include "Editor/EditorWindow/SHEditorWindow.h"
-
+#include "Editor/Command/SHCommand.hpp"
 namespace SHADE
 {
   class SHSceneNode;
@@ -23,11 +23,49 @@ namespace SHADE
     void Init() override;
     void Update() override;
     void Exit() override;
+    void SetScrollTo(EntityID eid);
   private:
     void DrawMenuBar() const noexcept;
-    ImRect RecursivelyDrawEntityNode(SHSceneNode*);
+    ImRect RecursivelyDrawEntityNode(SHSceneNode* const);
     void CreateChildEntity(EntityID parentEID) const noexcept;
+    void ParentSelectedEntities(EntityID parentEID) const noexcept;
+    void SelectRangeOfEntities(EntityID beginEID, EntityID EndEID);
+    void SelectAllEntities();
+    void CopySelectedEntities();
+    void PasteEntities(EntityID parentEID = MAX_EID);
+    bool skipFrame = false;
     std::string filter;
     bool isAnyNodeSelected = false;
+    EntityID scrollTo = MAX_EID;
   };//class SHHierarchyPanel
+
+  //Might move to a different file
+  class SHCreateEntityCommand final : public SHBaseCommand
+  {
+  public:
+    void Execute() override;
+    void Undo() override;
+  private:
+    EntityID eid = MAX_EID;
+  };
+
+  class SHEntityParentCommand final : public SHBaseCommand
+  {
+  public:
+    struct Data
+    {
+      EntityID oldParentEID = MAX_EID;
+      EntityID newParentEID = MAX_EID;
+    };
+    using EntityParentData = std::unordered_map<EntityID, Data>;
+
+    SHEntityParentCommand(std::vector<EntityID> entityIDs, EntityParentData inEntityParentData):entities(entityIDs),entityParentData(inEntityParentData){}
+
+    void Execute() override;
+    void Undo() override;
+  private:
+    std::vector<EntityID> entities;
+    std::unordered_map<EntityID, Data> entityParentData;
+  };
+
 }//namespace SHADE

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

@@ -0,0 +1,12 @@
+#pragma once
+#include "ECS_Base/Components/SHComponent.h"
+
+namespace SHADE
+{
+  template<typename T, std::enable_if_t<std::is_base_of<SHComponent, T>::value, bool> = true>
+  static void DrawContextMenu(T* component);
+  template<typename T, std::enable_if_t<std::is_base_of_v<SHComponent, T>, bool> = true>
+  static void DrawComponent(T* component);
+}
+
+#include "SHEditorComponentView.hpp"

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

@@ -10,21 +10,40 @@
 //||                       SHADE Includes                       ||
 //#==============================================================#
 #include "Editor/IconsMaterialDesign.h"
+#include "Editor/IconsFontAwesome6.h"
 #include "ECS_Base/Components/SHComponent.h"
 #include "Editor/SHEditorWidgets.hpp"
+#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
+#include "Graphics/MiddleEnd/Lights/SHLightComponent.h"
+#include "Physics/Components/SHColliderComponent.h"
 #include "Reflection/SHReflectionMetadata.h"
+#include "Resource/SHResourceManager.h"
+
 namespace SHADE
 {
-  template<typename T, std::enable_if_t<std::is_base_of<SHComponent, T>::value, bool> = true>
+  template<typename T>
+  std::vector<const char*> GetRTTREnumNames()
+  {
+    auto const rttrType = rttr::type::get<T>();
+    if (!rttrType.is_enumeration())
+      return {};
+    auto const enumAlign = rttrType.get_enumeration();
+    auto const names = enumAlign.get_names();
+    std::vector<const char*> result;
+    std::transform(names.begin(), names.end(), std::back_inserter(result), [](rttr::string_view const& name) {return name.data(); });
+    return result;
+  }
+
+  template<typename T, std::enable_if_t<std::is_base_of<SHComponent, T>::value, bool>>
   static void DrawContextMenu(T* component)
   {
-    if(!component)
+    if (!component)
       return;
     rttr::string_view componentName = rttr::type::get<T>().get_name();
 
     if (ImGui::BeginPopupContextItem(componentName.data()))
     {
-      
+
       if (ImGui::Selectable(std::format("{} Copy {}", ICON_MD_CONTENT_COPY, componentName.data()).data()))
       {
         //SHClipboardUtil::WriteStringToClipboard(SHClipboardUtil::CFNAME::CFCOMPONENT, SHComponentToString(component));
@@ -37,16 +56,22 @@ namespace SHADE
       {
         SHComponentManager::RemoveComponent<T>(component->GetEID());
       }
+      if (ImGui::Selectable(std::format("{} Reset {}", ICON_MD_RESTART_ALT, componentName.data()).data()))
+      {
+        *component = T();
+      }
       ImGui::EndPopup();
     }
   }
-  template<typename T, std::enable_if_t<std::is_base_of_v<SHComponent, T>, bool> = true>
+  template<typename T, std::enable_if_t<std::is_base_of_v<SHComponent, T>, bool>>
   static void DrawComponent(T* component)
   {
     if (!component)
       return;
-    auto componentType = rttr::type::get(*component);
+    const auto componentType = rttr::type::get<T>();
-    SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; });
+    ImGui::PushID(SHFamilyID<SHComponent>::GetID<T>());
+    SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active");
+    ImGui::PopID();
     ImGui::SameLine();
     if (ImGui::CollapsingHeader(componentType.get_name().data()))
     {
@@ -55,69 +80,66 @@ namespace SHADE
       for (auto const& property : properties)
       {
         auto const& type = property.get_type();
-
+        auto tooltip = property.get_metadata(META::tooltip);
-        if(type.is_enumeration())
+        bool const& isAngleInRad = property.get_metadata(META::angleInRad).is_valid() ? property.get_metadata(META::angleInRad).template get_value<bool>() : false;
+        if (type.is_enumeration())
         {
           auto enumAlign = type.get_enumeration();
           auto names = enumAlign.get_names();
           std::vector<const char*> list;
-          for(auto const& name : names)
+          for (auto const& name : names)
             list.push_back(name.data());
-          SHEditorWidgets::ComboBox(property.get_name().data(), list, [component, property]{return property.get_value(component).to_int();}, [component, property](int const& idx)
+          SHEditorWidgets::ComboBox(property.get_name().data(), list, [component, property] {return property.get_value(component).to_int(); }, [component, property](int const& idx)
-          {
+            {
-            auto enumAlign = property.get_enumeration();
+              auto enumAlign = property.get_enumeration();
-            auto values = enumAlign.get_values();
+              auto values = enumAlign.get_values();
-            auto it = std::next(values.begin(), idx);
+              auto it = std::next(values.begin(), idx);
-            property.set_value(component, *it);
+              property.set_value(component, *it);
-          });
+            }, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
         }
-        else if(type.is_arithmetic())
+        else if (type.is_arithmetic())
         {
           if (type == rttr::type::get<bool>())
           {
-            SHEditorWidgets::CheckBox(property.get_name().data(), [component, property]{return property.get_value(component).to_bool();}, [component, property](bool const& result){property.set_value(component, result);});
+            SHEditorWidgets::CheckBox(property.get_name().data(), [component, property] {return property.get_value(component).to_bool(); }, [component, property](bool const& result) {property.set_value(component, result); }, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
           }
-          //else if (type == rttr::type::get<char>())
-          //{
-          //  
-          //}
           else if (type == rttr::type::get<int8_t>() || type == rttr::type::get<int16_t>() || type == rttr::type::get<int32_t>() || type == rttr::type::get<int64_t>())
           {
             auto metaMin = property.get_metadata(META::min);
             auto metaMax = property.get_metadata(META::max);
-            if(metaMin && metaMax)
+            if (metaMin && metaMax)
             {
-              SHEditorWidgets::SliderInt(property.get_name().data(), metaMin.template get_value<int>(), metaMin.template get_value<int>(), [component, property]{return property.get_value(component).to_int();}, [component, property](int const& result){property.set_value(component, result);});
+              SHEditorWidgets::SliderInt(property.get_name().data(), metaMin.template get_value<int>(), metaMax.template get_value<int>(), [component, property] {return property.get_value(component).to_int(); }, [component, property](int const& result) {property.set_value(component, result); }, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
             }
             else
             {
-              SHEditorWidgets::DragInt(property.get_name().data(), [component, property]{return property.get_value(component).to_int();}, [component, property](int const& result){property.set_value(component, result);});
+              SHEditorWidgets::DragInt(property.get_name().data(), [component, property] {return property.get_value(component).to_int(); }, [component, property](int const& result) {property.set_value(component, result); }, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
             }
           }
           else if (type == rttr::type::get<uint8_t>())
           {
             auto metaMin = property.get_metadata(META::min);
             auto metaMax = property.get_metadata(META::max);
-            if(metaMin.is_valid() && metaMax.is_valid())
+            if (metaMin.is_valid() && metaMax.is_valid())
             {
-              SHEditorWidgets::SliderScalar<uint8_t>(property.get_name().data(), ImGuiDataType_U8, metaMin.template get_value<uint8_t>(), metaMax.template get_value<uint8_t>(), [component, property]{return property.get_value(component).to_uint8();}, [component, property](uint8_t const& result){property.set_value(component, result);},"%zu");
+              SHEditorWidgets::SliderScalar<uint8_t>(property.get_name().data(), ImGuiDataType_U8, metaMin.template get_value<uint8_t>(), metaMax.template get_value<uint8_t>(), [component, property] {return property.get_value(component).to_uint8(); }, [component, property](uint8_t const& result) {property.set_value(component, result); }, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string(), "%zu");
             }
             else
             {
-              SHEditorWidgets::DragScalar<uint8_t>(property.get_name().data(), ImGuiDataType_U8, [component, property]{return property.get_value(component).to_uint8();}, [component, property](uint8_t const& result){property.set_value(component, result);},0.1f,0,0,"%zu");
+              SHEditorWidgets::DragScalar<uint8_t>(property.get_name().data(), ImGuiDataType_U8, [component, property] {return property.get_value(component).to_uint8(); }, [component, property](uint8_t const& result) {property.set_value(component, result); }, 0.1f, 0, 0, "%zu", tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
             }
           }
           else if (type == rttr::type::get<uint16_t>())
           {
             auto metaMin = property.get_metadata(META::min);
             auto metaMax = property.get_metadata(META::max);
-            if(metaMin.is_valid() && metaMax.is_valid())
+            if (metaMin.is_valid() && metaMax.is_valid())
             {
-              SHEditorWidgets::SliderScalar<uint16_t>(property.get_name().data(), ImGuiDataType_U16, metaMin.template get_value<uint16_t>(), metaMin.template get_value<uint16_t>(), [component, property]{return property.get_value(component).to_uint16();}, [component, property](uint16_t const& result){property.set_value(component, result);},"%zu");
+              SHEditorWidgets::SliderScalar<uint16_t>(property.get_name().data(), ImGuiDataType_U16, metaMin.template get_value<uint16_t>(), metaMax.template get_value<uint16_t>(), [component, property] {return property.get_value(component).to_uint16(); }, [component, property](uint16_t const& result) {property.set_value(component, result); }, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string(), "%zu");
             }
             else
             {
-              SHEditorWidgets::DragScalar<uint16_t>(property.get_name().data(), ImGuiDataType_U16, [component, property]{return property.get_value(component).to_uint16();}, [component, property](uint16_t const& result){property.set_value(component, result);},0.1f,0,0,"%zu");
+              SHEditorWidgets::DragScalar<uint16_t>(property.get_name().data(), ImGuiDataType_U16, [component, property] {return property.get_value(component).to_uint16(); }, [component, property](uint16_t const& result) {property.set_value(component, result); }, 0.1f, 0, 0, "%zu", tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
             }
           }
           else if (type == rttr::type::get<uint32_t>())
@@ -126,68 +148,221 @@ namespace SHADE
             auto metaMax = property.get_metadata(META::max);
             if (metaMin.is_valid() && metaMax.is_valid())
             {
-              SHEditorWidgets::SliderScalar<uint32_t>(property.get_name().data(), ImGuiDataType_U32, metaMin.template get_value<uint32_t>(), metaMin.template get_value<uint32_t>(), [component, property]{ return property.get_value(component).to_uint32(); }, [component, property](uint32_t const& result){property.set_value(component, result); },"%zu");
+              SHEditorWidgets::SliderScalar<uint32_t>(property.get_name().data(), ImGuiDataType_U32, metaMin.template get_value<uint32_t>(), metaMax.template get_value<uint32_t>(), [component, property] { return property.get_value(component).to_uint32(); }, [component, property](uint32_t const& result) {property.set_value(component, result); }, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string(), "%zu");
             }
             else
             {
-              SHEditorWidgets::DragScalar<uint32_t>(property.get_name().data(), ImGuiDataType_U32, [component, property]{ return property.get_value(component).to_uint32(); }, [component, property](uint32_t const& result){property.set_value(component, result); },0.1f,0,0,"%zu");
+              SHEditorWidgets::DragScalar<uint32_t>(property.get_name().data(), ImGuiDataType_U32, [component, property] { return property.get_value(component).to_uint32(); }, [component, property](uint32_t const& result) {property.set_value(component, result); }, 0.1f, 0, 0, "%zu", tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
             }
           }
           else if (type == rttr::type::get<uint64_t>())
           {
             auto metaMin = property.get_metadata(META::min);
             auto metaMax = property.get_metadata(META::max);
-            if(metaMin.is_valid() && metaMax.is_valid())
+            if (metaMin.is_valid() && metaMax.is_valid())
             {
-              SHEditorWidgets::SliderScalar<uint64_t>(property.get_name().data(), ImGuiDataType_U64, metaMin.template get_value<uint64_t>(), metaMin.template get_value<uint64_t>(), [component, property]{return property.get_value(component).to_uint64();}, [component, property](uint64_t const& result){property.set_value(component, result);},"%zu");
+              SHEditorWidgets::SliderScalar<uint64_t>(property.get_name().data(), ImGuiDataType_U64, metaMin.template get_value<uint64_t>(), metaMax.template get_value<uint64_t>(), [component, property] {return property.get_value(component).to_uint64(); }, [component, property](uint64_t const& result) {property.set_value(component, result); }, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string(), "%zu");
             }
             else
             {
-              SHEditorWidgets::DragScalar<uint64_t>(property.get_name().data(), ImGuiDataType_U64, [component, property]{return property.get_value(component).to_uint64();}, [component, property](uint64_t const& result){property.set_value(component, result);},0.1f,0,0,"%zu");
+              SHEditorWidgets::DragScalar<uint64_t>(property.get_name().data(), ImGuiDataType_U64, [component, property] {return property.get_value(component).to_uint64(); }, [component, property](uint64_t const& result) {property.set_value(component, result); }, 0.1f, 0, 0, "%zu", tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
             }
           }
           else if (type == rttr::type::get<float>())
           {
             auto metaMin = property.get_metadata(META::min);
             auto metaMax = property.get_metadata(META::max);
-            if(metaMin.is_valid() && metaMax.is_valid())
+            float min{}, max{};
+            if (metaMin.is_valid())
+              min = std::max(metaMin.template get_value<float>(), -FLT_MAX * 0.5f);
+            if (metaMax.is_valid())
+              max = std::min(metaMax.template get_value<float>(), FLT_MAX * 0.5f);
+            if (metaMin.is_valid() && metaMax.is_valid())
             {
-              SHEditorWidgets::SliderFloat(property.get_name().data(), metaMin.template get_value<float>(), metaMin.template get_value<float>(), [component, property]{return property.get_value(component).to_float();}, [component, property](float const& result){property.set_value(component, result);});
+              SHEditorWidgets::SliderFloat(property.get_name().data(), min, max, [component, property] {return property.get_value(component).to_float(); }, [component, property](float const& result) {property.set_value(component, result); }, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
             }
             else
             {
-              SHEditorWidgets::DragFloat(property.get_name().data(), [component, property]{return property.get_value(component).to_float();}, [component, property](float const& result){property.set_value(component, result);});
+              SHEditorWidgets::DragFloat(property.get_name().data(), [component, property] {return property.get_value(component).to_float(); }, [component, property](float const& result) {property.set_value(component, result); }, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
             }
           }
           else if (type == rttr::type::get<double>())
           {
             auto metaMin = property.get_metadata(META::min);
             auto metaMax = property.get_metadata(META::max);
-            if(metaMin.is_valid() && metaMax.is_valid())
+            if (metaMin.is_valid() && metaMax.is_valid())
             {
-              SHEditorWidgets::SliderScalar<double>(property.get_name().data(), ImGuiDataType_Double, metaMin.template get_value<double>(), metaMin.template get_value<double>(), [component, property]{return property.get_value(component).to_double();}, [component, property](double const& result){property.set_value(component, result);});
+              SHEditorWidgets::SliderScalar<double>(property.get_name().data(), ImGuiDataType_Double, metaMin.template get_value<double>(), metaMax.template get_value<double>(), [component, property] {return property.get_value(component).to_double(); }, [component, property](double const& result) {property.set_value(component, result); }, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
             }
             else
             {
-              SHEditorWidgets::DragScalar<double>(property.get_name().data(), ImGuiDataType_Double, [component, property]{return property.get_value(component).to_double();}, [component, property](double const& result){property.set_value(component, result);}, 0.1f);
+              SHEditorWidgets::DragScalar<double>(property.get_name().data(), ImGuiDataType_Double, [component, property] {return property.get_value(component).to_double(); }, [component, property](double const& result) {property.set_value(component, result); }, 0.1f, {}, {}, "%.3f", tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
             }
           }
         }
         else if (type == rttr::type::get<SHVec4>())
         {
-          SHEditorWidgets::DragVec4(property.get_name().data(), { "X", "Y", "Z", "W" }, [component, property]() {return property.get_value(component).template convert<SHVec4>(); }, [component, property](SHVec4 vec) {return property.set_value(component, vec); });
+          SHEditorWidgets::DragVec4(property.get_name().data(), { "X", "Y", "Z", "W" }, [component, property]() {return property.get_value(component).template convert<SHVec4>(); }, [component, property](SHVec4 vec) {return property.set_value(component, vec); }, isAngleInRad, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
         }
         else if (type == rttr::type::get<SHVec3>())
         {
-          SHEditorWidgets::DragVec3(property.get_name().data(), { "X", "Y", "Z" }, [component, property]() {return property.get_value(component).template convert<SHVec3>(); }, [component, property](SHVec3 vec) {return property.set_value(component, vec); });
+          SHEditorWidgets::DragVec3(property.get_name().data(), { "X", "Y", "Z" }, [component, property]() {return property.get_value(component).template convert<SHVec3>(); }, [component, property](SHVec3 vec) {return property.set_value(component, vec); }, isAngleInRad, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
         }
         else if (type == rttr::type::get<SHVec2>())
         {
-          SHEditorWidgets::DragVec2(property.get_name().data(), { "X", "Y"}, [component, property]() {return property.get_value(component).template convert<SHVec2>(); }, [component, property](SHVec2 vec) {return property.set_value(component, vec); });
+          SHEditorWidgets::DragVec2(property.get_name().data(), { "X", "Y" }, [component, property]() {return property.get_value(component).template convert<SHVec2>(); }, [component, property](SHVec2 vec) {return property.set_value(component, vec); }, isAngleInRad, tooltip.is_valid() ? tooltip.template get_value<std::string>() : std::string());
         }
-        
+
       }
     }
     else DrawContextMenu(component);
   }
-}
+
+  template<>
+  static void DrawComponent(SHColliderComponent* component)
+  {
+    if (!component)
+      return;
+
+    // Get transform component for extrapolating relative sizes
+    auto* transformComponent = SHComponentManager::GetComponent_s<SHTransformComponent>(component->GetEID());
+
+    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);
+
+      auto& colliders = component->GetColliders();
+      int const size = static_cast<int>(colliders.size());
+      ImGui::BeginChild("Colliders", { 0.0f,  colliders.empty() ? 1.0f : 250.0f }, true);
+      std::optional<int> colliderToDelete{ std::nullopt };
+      for (int i{}; i < size; ++i)
+      {
+        ImGui::PushID(i);
+        SHCollider* collider = &component->GetCollider(i);
+        auto cursorPos = ImGui::GetCursorPos();
+
+        if (collider->GetType() == SHCollider::Type::BOX)
+        {
+          SHEditorWidgets::BeginPanel(std::format("{} Box Collider #{}", ICON_FA_CUBE, i).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y });
+          auto box = reinterpret_cast<SHBoundingBox*>(collider->GetShape());
+          SHEditorWidgets::DragVec3
+          (
+            "Half Extents", { "X", "Y", "Z" },
+            [box, transformComponent] { return (transformComponent->GetWorldScale() * 2.0f) * box->GetHalfExtents(); },
+            [collider](SHVec3 const& vec) { collider->SetBoundingBox(vec); });
+        }
+        else if (collider->GetType() == SHCollider::Type::SPHERE)
+        {
+          SHEditorWidgets::BeginPanel(std::format("{} Sphere Collider #{}", ICON_MD_CIRCLE, i).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y });
+          auto sphere = reinterpret_cast<SHBoundingSphere*>(collider->GetShape());
+          SHEditorWidgets::DragFloat
+          (
+            "Radius",
+            [sphere, transformComponent]
+            {
+              const SHVec3& TF_WORLD_SCALE = transformComponent->GetWorldScale();
+              const float MAX_SCALE = SHMath::Max({ TF_WORLD_SCALE.x, TF_WORLD_SCALE.y, TF_WORLD_SCALE.z });
+              return sphere->GetRadius() / MAX_SCALE;
+            },
+              [collider](float const& value) { collider->SetBoundingSphere(value); });
+        }
+        else if (collider->GetType() == SHCollider::Type::CAPSULE)
+        {
+
+        }
+        {
+          SHEditorWidgets::BeginPanel("Offset", { ImGui::GetContentRegionAvail().x, 30.0f });
+          SHEditorWidgets::DragVec3("Position", { "X", "Y", "Z" }, [&collider] {return collider->GetPositionOffset(); }, [&collider](SHVec3 const& vec) {collider->SetPositionOffset(vec); });
+          SHEditorWidgets::EndPanel();
+        }
+        if (ImGui::Button(std::format("{} Remove Collider #{}", ICON_MD_REMOVE, i).data()))
+        {
+          colliderToDelete = i;
+        }
+        SHEditorWidgets::EndPanel();
+        ImGui::PopID();
+      }
+      if (colliderToDelete.has_value())
+      {
+        component->RemoveCollider(colliderToDelete.value());
+      }
+      ImGui::EndChild();
+
+      if (ImGui::BeginMenu("Add Collider"))
+      {
+        if (ImGui::Selectable("Box Collider"))
+        {
+          component->AddBoundingBox();
+        }
+        if (ImGui::Selectable("Sphere Collider"))
+        {
+          component->AddBoundingSphere();
+        }
+        ImGui::EndMenu();
+      }
+    }
+    else DrawContextMenu(component);
+  }
+
+  template<>
+  static void DrawComponent(SHLightComponent* component)
+  {
+    if (!component)
+      return;
+    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);
+
+      static auto const enumAlign = rttr::type::get<SH_LIGHT_TYPE>().get_enumeration();
+      static std::vector<const char*> list(GetRTTREnumNames<SH_LIGHT_TYPE>());
+
+      SHEditorWidgets::ComboBox("Type", list, [component] {return static_cast<int>(component->GetType()); }, [component](int const& idx)
+        {
+          component->SetType(static_cast<SH_LIGHT_TYPE>(idx));
+        });
+      SHEditorWidgets::DragVec3("Position", { "X", "Y", "Z" }, [component]() {return component->GetPosition(); }, [component](SHVec3 const& vec) {component->SetPosition(vec); });
+      SHEditorWidgets::DragVec3("Direction", { "X", "Y", "Z" }, [component]() {return component->GetDirection(); }, [component](SHVec3 const& vec) {component->SetDirection(vec); });
+      SHEditorWidgets::ColorPicker("Color", [component]() {return component->GetColor(); }, [component](SHVec4 const& rgba) {component->SetColor(rgba); });
+      SHEditorWidgets::DragFloat("Strength", [component]() {return component->GetStrength(); }, [component](float const& value) {component->SetStrength(value); });
+    }
+    else
+    {
+      DrawContextMenu(component);
+    }
+  }
+
+  template<>
+  static void DrawComponent(SHRenderable* component)
+  {
+    if (!component)
+      return;
+    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<SHMesh> const& mesh = component->GetMesh();
+
+      SHEditorWidgets::DragDropReadOnlyField<AssetID>("Mesh", std::to_string(SHResourceManager::GetAssetID<SHMesh>(mesh).value_or(0)).data(), [component]()
+      {
+        Handle<SHMesh> const& mesh = component->GetMesh();
+        return SHResourceManager::GetAssetID<SHMesh>(mesh).value_or(0);
+      },
+        [component](AssetID const& id)
+        {
+          component->SetMesh(SHResourceManager::LoadOrGet<SHMesh>(id));
+        }, SHDragDrop::DRAG_RESOURCE);
+    }
+    else
+    {
+      DrawContextMenu(component);
+    }
+  }
+}

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

@@ -1,5 +1,6 @@
 #include "SHpch.h"
 
+#include "Editor/SHEditor.h"
 #include "SHEditorInspector.h"
 
 #include "ECS_Base/SHECSMacros.h"
@@ -7,27 +8,68 @@
 #include "ECS_Base/Managers/SHEntityManager.h"
 #include "Math/Transform/SHTransformComponent.h"
 
-#include "Editor/SHEditor.hpp"
 #include "Editor/SHImGuiHelpers.hpp"
 #include "Editor/SHEditorWidgets.hpp"
-#include "SHEditorComponentView.hpp"
-#include "ECS_Base/UnitTesting/SHTestComponents.h"
 #include "Graphics/MiddleEnd/Interface/SHRenderable.h"
 #include "Scripting/SHScriptEngine.h"
 #include "ECS_Base/Managers/SHSystemManager.h"
 
-#include "ECS_Base/Managers/SHSystemManager.h"
+#include "Physics/Components/SHRigidBodyComponent.h"
-#include "AudioSystem/SHAudioSystem.h"
+#include "Physics/Components/SHColliderComponent.h"
+#include "Camera/SHCameraComponent.h"
+#include "SHEditorComponentView.h"
 
 namespace SHADE
 {
   template<typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
-  void DrawAddComponentButton(EntityID const& eid)
+  bool DrawAddComponentButton(EntityID const& eid)
   {
-    if(!SHComponentManager::HasComponent<ComponentType>(eid) && ImGui::Selectable(std::format("Add {}", rttr::type::get<ComponentType>().get_name().data()).data()))
+    bool selected = false;
+    if(!SHComponentManager::HasComponent<ComponentType>(eid))
     {
-      SHComponentManager::AddComponent<ComponentType>(eid);
+      const char* componentName = rttr::type::get<ComponentType>().get_name().data();
+      if(selected = ImGui::Selectable(std::format("Add {}", componentName).data()); selected)
+        SHComponentManager::AddComponent<ComponentType>(eid);
+      if(ImGui::IsItemHovered())
+      {
+        ImGui::BeginTooltip();
+        ImGui::Text("Adds", componentName); ImGui::SameLine();
+        ImGui::TextColored(ImGuiColors::green, "%s", componentName); ImGui::SameLine();
+        ImGui::Text("to this entity", componentName);
+        ImGui::EndTooltip();
+      }
     }
+    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>
+  bool DrawAddComponentWithEnforcedComponentButton(EntityID const& eid)
+  {
+    bool selected = false;
+    if (!SHComponentManager::HasComponent<ComponentType>(eid))
+    {
+      const char* componentName = rttr::type::get<ComponentType>().get_name().data();
+
+      if(selected = ImGui::Selectable(std::format("Add {}", componentName).data()); selected)
+      {
+        if(SHComponentManager::GetComponent_s<EnforcedComponent>(eid) == nullptr)
+          SHComponentManager::AddComponent<EnforcedComponent>(eid);
+
+        SHComponentManager::AddComponent<ComponentType>(eid);
+      }
+      if(ImGui::IsItemHovered())
+      {
+        ImGui::BeginTooltip();
+        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::EndTooltip();
+      }
+    }
+    return selected;
   }
 
   SHEditorInspector::SHEditorInspector()
@@ -45,11 +87,16 @@ namespace SHADE
     SHEditorWindow::Update();
     if (Begin())
     {
-      if (!SHEditor::selectedEntities.empty())
+      auto editor = SHSystemManager::GetSystem<SHEditor>();
+      if (editor && !editor->selectedEntities.empty())
       {
-        EntityID const& eid = SHEditor::selectedEntities[0];
+        EntityID const& eid = editor->selectedEntities[0];
         SHEntity* entity = SHEntityManager::GetEntityByID(eid);
-
+        if(!entity)
+        {
+          ImGui::End();
+          return;
+        }
         ImGui::TextColored(ImGuiColors::green, "EID: %zu", eid);
         SHEditorWidgets::CheckBox("##IsActive", [entity]()->bool {return entity->GetActive(); }, [entity](bool const& active) {entity->SetActive(active); });
         ImGui::SameLine();
@@ -64,26 +111,46 @@ namespace SHADE
         {
           DrawComponent(renderableComponent);
         }
-        if(auto testComponent = SHComponentManager::GetComponent_s<SHComponent_ENUM>(eid))
+        if(auto colliderComponent = SHComponentManager::GetComponent_s<SHColliderComponent>(eid))
         {
-          DrawComponent(testComponent);
+          DrawComponent(colliderComponent);
         }
+        if(auto rigidbodyComponent = SHComponentManager::GetComponent_s<SHRigidBodyComponent>(eid))
+        {
+          DrawComponent(rigidbodyComponent);
+        }
+        if(auto lightComponent = SHComponentManager::GetComponent_s<SHLightComponent>(eid))
+        {
+          DrawComponent(lightComponent);
+        }
+        if (auto cameraComponent = SHComponentManager::GetComponent_s<SHCameraComponent>(eid))
+        {
+          DrawComponent(cameraComponent);
+        }
+        ImGui::Separator();
+        // Render Scripts
+        SHScriptEngine* scriptEngine = static_cast<SHScriptEngine*>(SHSystemManager::GetSystem<SHScriptEngine>());
+        scriptEngine->RenderScriptsInInspector(eid);
         ImGui::Separator();
         if(ImGui::BeginMenu(std::format("{} Add Component", ICON_MD_LIBRARY_ADD).data()))
         {
           DrawAddComponentButton<SHTransformComponent>(eid);
-          DrawAddComponentButton<SHRenderable>(eid);
+          DrawAddComponentButton<SHCameraComponent>(eid);
-          DrawAddComponentButton<SHComponent_ENUM>(eid);
+          DrawAddComponentButton<SHLightComponent>(eid);
+
+          // Components that require Transforms
+
+          DrawAddComponentWithEnforcedComponentButton<SHRenderable, SHTransformComponent>(eid);
+          DrawAddComponentWithEnforcedComponentButton<SHRigidBodyComponent, SHTransformComponent>(eid);
+          DrawAddComponentWithEnforcedComponentButton<SHColliderComponent, SHTransformComponent>(eid);
+          
+
           ImGui::EndMenu();
         }
 
-        // Render Scripts
-		SHScriptEngine* scriptEngine = static_cast<SHScriptEngine*>(SHSystemManager::GetSystem<SHScriptEngine>());
-		scriptEngine->RenderScriptsInInspector(eid);
-
       }
-      ImGui::End();
     }
+    ImGui::End();
   }
 
   void SHEditorInspector::Exit()

SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp

@@ -3,11 +3,11 @@
 //#==============================================================#
 //||                       SHADE Includes                       ||
 //#==============================================================#
+#include "Editor/SHEditor.h"
 #include "SHEditorMenuBar.h"
 #include "Editor/IconsMaterialDesign.h"
 #include "Editor/Command/SHCommandManager.h"
 #include "Scripting/SHScriptEngine.h"
-#include "Editor/SHEditor.hpp"
 #include "ECS_Base/Managers/SHSystemManager.h"
 
 //#==============================================================#
@@ -17,6 +17,8 @@
 #include <imgui_internal.h>
 #include <rttr/type>
 
+#include "Serialization/SHSerialization.h"
+
 namespace SHADE
 {
   constexpr ImGuiWindowFlags editorMenuBarFlags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse |
@@ -36,6 +38,11 @@ namespace SHADE
   void SHEditorMenuBar::Init()
   {
     SHEditorWindow::Init();
+    constexpr std::string_view path = "../../Assets/Editor/Layouts";
+    for(auto const& entry : std::filesystem::directory_iterator(path))
+    {
+      layoutPaths.push_back(entry.path());
+    }
   }
 
   void SHEditorMenuBar::Update()
@@ -68,7 +75,14 @@ namespace SHADE
       {
         if (ImGui::BeginMenu("File"))
         {
-
+          if(ImGui::Selectable("Save"))
+          {
+            SHSerialization::SerializeSceneToFile("../../Assets/Scenes/Test.SHADE");
+          }
+          if(ImGui::Selectable("Load"))
+          {
+            SHSerialization::DeserializeSceneFromFile("../../Assets/Scenes/Test.SHADE");
+          }
           ImGui::EndMenu();
         }
         if(ImGui::BeginMenu("Edit"))
@@ -87,19 +101,6 @@ namespace SHADE
           ImGui::EndDisabled();
           ImGui::EndMenu();
         }
-        if(ImGui::BeginMenu("Theme"))
-        {
-          auto styles = rttr::type::get<SHEditor::Style>().get_enumeration();
-          auto values = styles.get_values();
-          for (auto style : values)
-          {
-            if(ImGui::Selectable(style.to_string().c_str()))
-            {
-              SHEditor::SetStyle(style.convert<SHEditor::Style>());
-            }
-          }
-          ImGui::EndMenu();
-        }
         if (ImGui::BeginMenu("Scripts"))
         {
           if (ImGui::Selectable("Generate Visual Studio Project"))
@@ -119,18 +120,79 @@ namespace SHADE
           }
           ImGui::EndMenu();
         }
+
+        if (ImGui::BeginMenu("Window"))
+        {
+          for (const auto& window : SHEditorWindowManager::editorWindows | std::views::values)
+          {
+            if (window.get() != this)
+              ImGui::Checkbox(window->windowName.data(), &window->isOpen);
+          }
+          ImGui::EndMenu();
+        }
+        if (ImGui::BeginMenu("Theme"))
+        {
+          const auto styles = rttr::type::get<SHEditor::Style>().get_enumeration();
+          auto values = styles.get_values();
+          for (auto style : values)
+          {
+            if (ImGui::Selectable(style.to_string().c_str()))
+            {
+              if (auto editor = SHSystemManager::GetSystem<SHEditor>())
+                editor->SetStyle(style.convert<SHEditor::Style>());
+            }
+          }
+          ImGui::EndMenu();
+        }
+        if(ImGui::BeginMenu("Layout"))
+        {
+          for(auto const& entry : layoutPaths)
+          {
+            if(ImGui::Selectable(entry.stem().string().c_str()))
+            {
+              ImGui::LoadIniSettingsFromDisk(entry.string().c_str());
+            }
+          }
+          ImGui::EndMenu();
+        }
         ImGui::EndMainMenuBar();
       }
 
-      const ImGuiID dockspace_id = ImGui::GetID("DockSpace");
+      const ImGuiID dockspaceId = ImGui::GetID("DockSpace");
-      ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspaceFlags);
+      ImGui::DockSpace(dockspaceId, ImVec2(0.0f, 0.0f), dockspaceFlags);
       ImGui::End();
     }
   }
 
   void SHEditorMenuBar::DrawSecondaryBar() const noexcept
   {
-
+    ImGuiViewport* viewport = ImGui::GetMainViewport();
+    if(ImGui::BeginViewportSideBar("##SecondaryMenuBar", viewport, ImGuiDir_Up, ImGui::GetFrameHeight(), ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoNav | ImGuiWindowFlags_MenuBar))
+    {
+      ImGui::BeginMenuBar();
+      ImGui::SetCursorPosX(ImGui::GetContentRegionAvail().x * 0.5f - 80.f);
+      const auto editor = SHSystemManager::GetSystem<SHEditor>();
+      ImGui::BeginDisabled(editor->editorState == SHEditor::State::PLAY);
+      if(ImGui::SmallButton(ICON_MD_PLAY_ARROW))
+      {
+        editor->editorState = SHEditor::State::PLAY;
+      }
+      ImGui::EndDisabled();
+      ImGui::BeginDisabled(editor->editorState == SHEditor::State::PAUSE);
+      if(ImGui::SmallButton(ICON_MD_PAUSE))
+      {
+        editor->editorState = SHEditor::State::PAUSE;
+      }
+      ImGui::EndDisabled();
+      ImGui::BeginDisabled(editor->editorState == SHEditor::State::STOP);
+      if(ImGui::SmallButton(ICON_MD_STOP))
+      {
+        editor->editorState = SHEditor::State::STOP;
+      }
+      ImGui::EndDisabled();
+      ImGui::EndMenuBar();
+    }
+    ImGui::End();
   }
 
   void SHEditorMenuBar::DrawStatusBar() const noexcept
@@ -141,8 +203,8 @@ namespace SHADE
     if (ImGui::BeginViewportSideBar("MainStatusBar", ImGui::GetMainViewport(), ImGuiDir_Down, menuBarHeight, editorMenuBarFlags))
     {
       ImGui::Text("Entity count: ");
-      ImGui::End();
     }
+    ImGui::End();
     ImGui::PopStyleVar(3);
 
   }

SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.h

@@ -18,5 +18,6 @@ namespace SHADE
     void DrawSecondaryBar() const noexcept;
     void DrawStatusBar() const noexcept;
     float menuBarHeight = 20.0f;
+    std::vector<std::filesystem::path> layoutPaths;
   };//class SHEditorMenuBar
 }//namespace SHADE