Merge branch 'main' into SP3-1-RenderOnlyActive

2022-11-18 21:34:28 +08:00 · 2022-11-18 21:34:28 +08:00 · 5ec8475842
parent ab869348f1 fa05d8d719
commit 5ec8475842
189 changed files with 4088 additions and 1230 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -0,0 +1,27 @@
+---
+name: Bug report
+about: Report a bug that should be fixed
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest a feature for the project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
--- a/Assets/Audio/Master.bank
+++ b/Assets/Audio/Master.bank
--- a/Assets/Audio/Master.strings.bank
+++ b/Assets/Audio/Master.strings.bank
--- a/Assets/Audio/Music.bank
+++ b/Assets/Audio/Music.bank
--- a/Assets/Audio/SFX.bank
+++ b/Assets/Audio/SFX.bank
--- a/Assets/Audio/UI.bank
+++ b/Assets/Audio/UI.bank
--- a/Assets/Scenes/M2Scene.shade
+++ b/Assets/Scenes/M2Scene.shade
@ -21,141 +21,6 @@
      Layer: 4294967295
      Strength: 0
  Scripts: ~
- EID: 1
-  Name: Floor
-  IsActive: true
-  NumberOfChildren: 0
-  Components:
-    Transform Component:
-      Translate: {x: -1.440328, y: -4.41369677, z: -5}
-      Rotate: {x: -0, y: 0, z: -0}
-      Scale: {x: 49.4798889, y: 0.5, z: 17.5}
-    Renderable Component:
-      Mesh: 149697411
-      Material: 126974645
-    RigidBody Component:
-      Type: Static
-      Mass: 1
-      Drag: 0.00999999978
-      Angular Drag: 0.00999999978
-      Use Gravity: true
-      Interpolate: true
-      Freeze Position X: false
-      Freeze Position Y: false
-      Freeze Position Z: false
-      Freeze Rotation X: false
-      Freeze Rotation Y: false
-      Freeze Rotation Z: false
-    Collider Component:
-      Colliders:
-        - Is Trigger: false
-          Type: Box
-          Half Extents: {x: 1, y: 1, z: 1}
-          Friction: 0.400000006
-          Bounciness: 0
-          Density: 1
-          Position Offset: {x: 0, y: 0, z: 0}
-  Scripts: ~
- EID: 10
-  Name: Default
-  IsActive: true
-  NumberOfChildren: 0
-  Components:
-    Transform Component:
-      Translate: {x: -4.40482807, y: 2.57871056, z: -5.21213436}
-      Rotate: {x: -0.361265004, y: 1.11661232, z: -0.626627684}
-      Scale: {x: 0.999982238, y: 0.999987125, z: 0.999981165}
-    RigidBody Component:
-      Type: Dynamic
-      Mass: 1
-      Drag: 0
-      Angular Drag: 0
-      Use Gravity: true
-      Interpolate: true
-      Freeze Position X: false
-      Freeze Position Y: false
-      Freeze Position Z: false
-      Freeze Rotation X: false
-      Freeze Rotation Y: false
-      Freeze Rotation Z: false
-    Collider Component:
-      Colliders:
-        - Is Trigger: false
-          Type: Box
-          Half Extents: {x: 1, y: 1, z: 1}
-          Friction: 0.400000006
-          Bounciness: 0
-          Density: 1
-          Position Offset: {x: 0, y: 0, z: 0}
-  Scripts: ~
- EID: 3
-  Name: Empty
-  IsActive: true
-  NumberOfChildren: 0
-  Components:
-    Transform Component:
-      Translate: {x: -0.0094268322, y: 0, z: 0}
-      Rotate: {x: -0, y: 0, z: -0}
-      Scale: {x: 1, y: 1, z: 1}
-  Scripts: ~
- EID: 4
-  Name: Empty2
-  IsActive: true
-  NumberOfChildren: 0
-  Components:
-    Transform Component:
-      Translate: {x: 0, y: 0, z: 0}
-      Rotate: {x: 0, y: 0, z: 0}
-      Scale: {x: 1, y: 1, z: 1}
-  Scripts: ~
- EID: 9
-  Name: Bag
-  IsActive: true
-  NumberOfChildren: 0
-  Components:
-    Transform Component:
-      Translate: {x: 0, y: 0, z: 0}
-      Rotate: {x: 0, y: 0, z: 0}
-      Scale: {x: 1, y: 1, z: 1}
-    Renderable Component:
-      Mesh: 144838771
-      Material: 123745521
-  Scripts: ~
- EID: 6
-  Name: AI
-  IsActive: true
-  NumberOfChildren: 0
-  Components:
-    Transform Component:
-      Translate: {x: -8, y: -2, z: 2.5}
-      Rotate: {x: 0, y: 0, z: 0}
-      Scale: {x: 1, y: 1, z: 1}
-    Renderable Component:
-      Mesh: 149697411
-      Material: 126974645
-    RigidBody Component:
-      Type: Dynamic
-      Mass: 1
-      Drag: 0
-      Angular Drag: 0
-      Use Gravity: true
-      Interpolate: false
-      Freeze Position X: false
-      Freeze Position Y: false
-      Freeze Position Z: false
-      Freeze Rotation X: true
-      Freeze Rotation Y: true
-      Freeze Rotation Z: true
-    Collider Component:
-      Colliders:
-        - Is Trigger: false
-          Type: Box
-          Half Extents: {x: 0.5, y: 0.5, z: 0.5}
-          Friction: 0.400000006
-          Bounciness: 0
-          Density: 1
-          Position Offset: {x: 0, y: 0.5, z: 0}
-  Scripts: ~
 - EID: 7
  Name: BigBoi
  IsActive: true
@ -182,50 +47,3 @@
      Layer: 4294967295
      Strength: 0.25
  Scripts: ~
- EID: 5
-  Name: item
-  IsActive: true
-  NumberOfChildren: 0
-  Components:
-    Transform Component:
-      Translate: {x: 0, y: -2, z: -5}
-      Rotate: {x: 0, y: 0, z: 0}
-      Scale: {x: 2, y: 2, z: 2}
-    Renderable Component:
-      Mesh: 144838771
-      Material: 123745521
-    RigidBody Component:
-      Type: Dynamic
-      Mass: 1
-      Drag: 0
-      Angular Drag: 0
-      Use Gravity: true
-      Interpolate: false
-      Freeze Position X: false
-      Freeze Position Y: false
-      Freeze Position Z: false
-      Freeze Rotation X: true
-      Freeze Rotation Y: true
-      Freeze Rotation Z: true
-    Collider Component:
-      Colliders:
-        - Is Trigger: false
-          Type: Box
-          Half Extents: {x: 1, y: 1, z: 1}
-          Friction: 0.400000006
-          Bounciness: 0
-          Density: 1
-          Position Offset: {x: 0, y: 0.5, z: 0}
-        - Is Trigger: true
-          Type: Box
-          Half Extents: {x: 2, y: 2, z: 2}
-          Friction: 0.400000006
-          Bounciness: 0
-          Density: 1
-          Position Offset: {x: 0, y: 0.5, z: 0}
-  Scripts:
-    - Type: Item
-      currCategory: 0
-    - Type: PickAndThrow
-      throwForce: [100, 200, 100]
-      item: 51000
--- a/Assets/Scenes/PlayerControllerTest.shade
+++ b/Assets/Scenes/PlayerControllerTest.shade
@ -0,0 +1,454 @@
+- EID: 0
+  Name: ScoreZone
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Camera Component:
+      Position: {x: 0, y: 0, z: 0}
+      Pitch: 0
+      Yaw: 0
+      Roll: 0
+      Width: 1920
+      Height: 1080
+      Near: 0.00999999978
+      Far: 10000
+      Perspective: true
+      IsActive: true
+    Light Component:
+      Position: {x: 0, y: 0, z: 0}
+      Type: Directional
+      Direction: {x: 1.79999995, y: 0, z: 1}
+      Color: {x: 0.951541841, y: 0.921719015, z: 0.553319454, w: 1}
+      Layer: 4294967295
+      Strength: 0
+      IsActive: true
+  Scripts: ~
+- EID: 1
+  Name: Default
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Transform Component:
+      Translate: {x: -1.440328, y: -4.41369677, z: -5}
+      Rotate: {x: -0, y: 0, z: -0}
+      Scale: {x: 49.4798889, y: 0.5, z: 17.5}
+      IsActive: true
+    Renderable Component:
+      Mesh: 149697411
+      Material: 126974645
+      IsActive: true
+    RigidBody Component:
+      Type: Static
+      Mass: 1
+      Drag: 0.00999999978
+      Angular Drag: 0.00999999978
+      Use Gravity: true
+      Interpolate: true
+      Freeze Position X: false
+      Freeze Position Y: false
+      Freeze Position Z: false
+      Freeze Rotation X: false
+      Freeze Rotation Y: false
+      Freeze Rotation Z: false
+      IsActive: true
+    Collider Component:
+      Colliders:
+        - Is Trigger: false
+          Type: Box
+          Half Extents: {x: 1, y: 1, z: 1}
+          Friction: 0.400000006
+          Bounciness: 0
+          Density: 1
+          Position Offset: {x: 0, y: 0, z: 0}
+      IsActive: true
+  Scripts: ~
+- EID: 2
+  Name: Player
+  IsActive: true
+  NumberOfChildren: 3
+  Components:
+    Transform Component:
+      Translate: {x: -18.9007454, y: -3.67369723, z: -5.23871422}
+      Rotate: {x: -0, y: 0, z: 0}
+      Scale: {x: 2, y: 2, z: 2}
+      IsActive: true
+    Renderable Component:
+      Mesh: 149697411
+      Material: 126974645
+      IsActive: true
+    RigidBody Component:
+      Type: Dynamic
+      Mass: 1
+      Drag: 2
+      Angular Drag: 0
+      Use Gravity: false
+      Interpolate: false
+      Freeze Position X: false
+      Freeze Position Y: false
+      Freeze Position Z: false
+      Freeze Rotation X: true
+      Freeze Rotation Y: true
+      Freeze Rotation Z: true
+      IsActive: true
+    Collider Component:
+      Colliders:
+        - Is Trigger: false
+          Type: Box
+          Half Extents: {x: 1, y: 1, z: 1}
+          Friction: 0.400000006
+          Bounciness: 0
+          Density: 1
+          Position Offset: {x: 0, y: 0.5, z: 0}
+      IsActive: true
+  Scripts:
+    - Type: PlayerController
+      currentState: 0
+      maxMoveVel: 4
+      moveForce: 50
+      sprintMultiplier: 1.5
+      rotationFactorPerFrame: 1
+      maxJumpHeight: 4
+      maxJumpTime: 0.75
+      fallMultipler: 2
+      lightMultiper: 0.75
+      mediumMultiper: 0.5
+      heavyMultiper: 0.25
+    - Type: PickAndThrow
+      holdPosition: [0, 1.20000005, 0]
+      throwForce: [200, 300, 200]
+- EID: 3
+  Name: Default
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Transform Component:
+      Translate: {x: 0, y: 1.20000005, z: 0}
+      Rotate: {x: -0, y: 0, z: -0}
+      Scale: {x: 1, y: 1, z: 1}
+      IsActive: true
+  Scripts: ~
+- EID: 4
+  Name: Default
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Transform Component:
+      Translate: {x: 0, y: 0, z: 0}
+      Rotate: {x: -0.785401046, y: 1.65799224, z: 0}
+      Scale: {x: 1, y: 1, z: 1}
+      IsActive: true
+    Camera Component:
+      Position: {x: -18.9007454, y: -3.67369723, z: -5.23871422}
+      Pitch: -45.000164
+      Yaw: 94.9959564
+      Roll: 0
+      Width: 1920
+      Height: 1080
+      Near: 0.00999999978
+      Far: 10000
+      Perspective: true
+      IsActive: true
+  Scripts:
+    - Type: SHADE_Scripting.ThirdPersonCamera
+      armLength: 2
+      turnSpeedPitch: 0.300000012
+      turnSpeedYaw: 0.5
+      pitchClamp: 45
+- EID: 9
+  Name: Default
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Transform Component:
+      Translate: {x: 0, y: 0, z: 0}
+      Rotate: {x: 0, y: 0, z: 0}
+      Scale: {x: 1, y: 1, z: 1}
+      IsActive: true
+    Renderable Component:
+      Mesh: 144838771
+      Material: 123745521
+      IsActive: true
+  Scripts: ~
+- EID: 6
+  Name: AI
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Transform Component:
+      Translate: {x: -8, y: -4.42369843, z: 2.5}
+      Rotate: {x: -0, y: 0, z: 0}
+      Scale: {x: 1, y: 1, z: 1}
+      IsActive: true
+    Renderable Component:
+      Mesh: 149697411
+      Material: 126974645
+      IsActive: true
+    RigidBody Component:
+      Type: Dynamic
+      Mass: 1
+      Drag: 0
+      Angular Drag: 0
+      Use Gravity: true
+      Interpolate: false
+      Freeze Position X: false
+      Freeze Position Y: false
+      Freeze Position Z: false
+      Freeze Rotation X: true
+      Freeze Rotation Y: true
+      Freeze Rotation Z: true
+      IsActive: true
+    Collider Component:
+      Colliders:
+        - Is Trigger: false
+          Type: Box
+          Half Extents: {x: 0.5, y: 0.5, z: 0.5}
+          Friction: 0.400000006
+          Bounciness: 0
+          Density: 1
+          Position Offset: {x: 0, y: 0.5, z: 0}
+      IsActive: true
+  Scripts: ~
+- EID: 7
+  Name: Default
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Transform Component:
+      Translate: {x: 0, y: -16.8647861, z: -14.039052}
+      Rotate: {x: -0, y: 0, z: -0}
+      Scale: {x: 28.1434975, y: 28.1434975, z: 28.1434975}
+      IsActive: true
+    Renderable Component:
+      Mesh: 149697411
+      Material: 126974645
+      IsActive: true
+  Scripts: ~
+- EID: 8
+  Name: Default
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Light Component:
+      Position: {x: 0, y: 0, z: 0}
+      Type: Ambient
+      Direction: {x: 0, y: 0, z: 1}
+      Color: {x: 1, y: 1, z: 1, w: 1}
+      Layer: 4294967295
+      Strength: 0.25
+      IsActive: true
+  Scripts: ~
+- EID: 11
+  Name: GameManager
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Transform Component:
+      Translate: {x: 0, y: 0, z: 0}
+      Rotate: {x: 0, y: 0, z: 0}
+      Scale: {x: 1, y: 1, z: 1}
+      IsActive: true
+    RigidBody Component:
+      Type: Static
+      Mass: 1
+      Drag: 0.00999999978
+      Angular Drag: 0.00999999978
+      Use Gravity: true
+      Interpolate: true
+      Freeze Position X: false
+      Freeze Position Y: false
+      Freeze Position Z: false
+      Freeze Rotation X: false
+      Freeze Rotation Y: false
+      Freeze Rotation Z: false
+      IsActive: true
+    Collider Component:
+      Colliders: ~
+      IsActive: true
+  Scripts:
+    - Type: GameManager
+      itemPool: 12
+      zonePool: 51000
+      currGameState: 0
+      totalItemCount: -202
+      Score: 204
+      timer: 0
+- EID: 12
+  Name: ItemPool
+  IsActive: true
+  NumberOfChildren: 2
+  Components: ~
+  Scripts: ~
+- EID: 10
+  Name: item
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Transform Component:
+      Translate: {x: 3.19870043, y: -3.67369723, z: -5}
+      Rotate: {x: -0, y: 0, z: 0}
+      Scale: {x: 2, y: 2, z: 2}
+      IsActive: true
+    Renderable Component:
+      Mesh: 144838771
+      Material: 123745521
+      IsActive: true
+    RigidBody Component:
+      Type: Dynamic
+      Mass: 1
+      Drag: 0
+      Angular Drag: 0
+      Use Gravity: true
+      Interpolate: false
+      Freeze Position X: false
+      Freeze Position Y: false
+      Freeze Position Z: false
+      Freeze Rotation X: true
+      Freeze Rotation Y: true
+      Freeze Rotation Z: true
+      IsActive: true
+    Collider Component:
+      Colliders:
+        - Is Trigger: false
+          Type: Box
+          Half Extents: {x: 1, y: 1, z: 1}
+          Friction: 0.400000006
+          Bounciness: 0
+          Density: 1
+          Position Offset: {x: 0, y: 0.5, z: 0}
+        - Is Trigger: true
+          Type: Box
+          Half Extents: {x: 2, y: 2, z: 2}
+          Friction: 0.400000006
+          Bounciness: 0
+          Density: 1
+          Position Offset: {x: 0, y: 0.5, z: 0}
+      IsActive: true
+  Scripts:
+    - Type: Item
+      Score: 1
+      currCategory: 0
+- EID: 5
+  Name: item
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Transform Component:
+      Translate: {x: -20.6163979, y: -0.0419634879, z: -5.08873653}
+      Rotate: {x: -0, y: 0, z: 0}
+      Scale: {x: 2, y: 2, z: 2}
+      IsActive: false
+    Renderable Component:
+      Mesh: 144838771
+      Material: 123745521
+      IsActive: false
+    RigidBody Component:
+      Type: Dynamic
+      Mass: 1
+      Drag: 0
+      Angular Drag: 0
+      Use Gravity: true
+      Interpolate: false
+      Freeze Position X: false
+      Freeze Position Y: false
+      Freeze Position Z: false
+      Freeze Rotation X: true
+      Freeze Rotation Y: true
+      Freeze Rotation Z: true
+      IsActive: false
+    Collider Component:
+      Colliders:
+        - Is Trigger: false
+          Type: Box
+          Half Extents: {x: 1, y: 1, z: 1}
+          Friction: 0.400000006
+          Bounciness: 0
+          Density: 1
+          Position Offset: {x: 0, y: 0.5, z: 0}
+        - Is Trigger: true
+          Type: Box
+          Half Extents: {x: 2, y: 2, z: 2}
+          Friction: 0.400000006
+          Bounciness: 0
+          Density: 1
+          Position Offset: {x: 0, y: 0.5, z: 0}
+      IsActive: false
+  Scripts:
+    - Type: Item
+      Score: 1
+      currCategory: 0
+- EID: 15
+  Name: ScoreZonePool
+  IsActive: true
+  NumberOfChildren: 2
+  Components: ~
+  Scripts: ~
+- EID: 13
+  Name: ScoreZone
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Transform Component:
+      Translate: {x: -24.5947151, y: -3.15127993, z: -3.29243231}
+      Rotate: {x: 0, y: 0, z: 0}
+      Scale: {x: 1, y: 1, z: 1}
+      IsActive: true
+    RigidBody Component:
+      Type: Static
+      Mass: 1
+      Drag: 0.00999999978
+      Angular Drag: 0.00999999978
+      Use Gravity: true
+      Interpolate: true
+      Freeze Position X: false
+      Freeze Position Y: false
+      Freeze Position Z: false
+      Freeze Rotation X: false
+      Freeze Rotation Y: false
+      Freeze Rotation Z: false
+      IsActive: true
+    Collider Component:
+      Colliders:
+        - Is Trigger: true
+          Type: Box
+          Half Extents: {x: 1, y: 20, z: 20}
+          Friction: 0.400000006
+          Bounciness: 0
+          Density: 1
+          Position Offset: {x: 0, y: 0, z: 0}
+      IsActive: true
+  Scripts: ~
+- EID: 14
+  Name: ScoreZone
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Transform Component:
+      Translate: {x: -6.64785767, y: 0, z: -14.217104}
+      Rotate: {x: -0, y: 0, z: -0}
+      Scale: {x: 1, y: 1, z: 1}
+      IsActive: true
+    RigidBody Component:
+      Type: Static
+      Mass: 1
+      Drag: 0.00999999978
+      Angular Drag: 0.00999999978
+      Use Gravity: true
+      Interpolate: true
+      Freeze Position X: false
+      Freeze Position Y: false
+      Freeze Position Z: false
+      Freeze Rotation X: false
+      Freeze Rotation Y: false
+      Freeze Rotation Z: false
+      IsActive: true
+    Collider Component:
+      Colliders:
+        - Is Trigger: true
+          Type: Box
+          Half Extents: {x: 20, y: 20, z: 1}
+          Friction: 0.400000006
+          Bounciness: 0
+          Density: 1
+          Position Offset: {x: 0, y: 0, z: 0}
+      IsActive: true
+  Scripts: ~
--- a/Assets/Scenes/PlayerControllerTest.shade.shmeta
+++ b/Assets/Scenes/PlayerControllerTest.shade.shmeta
@ -0,0 +1,3 @@
+Name: PlayerControllerTest
+ID: 92100024
+Type: 5
--- a/Assets/Scripts/SC_GameManager.cs
+++ b/Assets/Scripts/SC_GameManager.cs
@ -0,0 +1,62 @@
+using SHADE;
+using System;
+using System.Collections.Generic;
+
+public class GameManager : Script
+{
+  public enum GameState
+  { 
+    MAINMENU,
+    WIN,
+    LOSE,
+    TOTAL
+  }
+
+  public GameObject itemPool;
+  public GameObject zonePool;
+  public GameState currGameState;
+
+  [NonSerialized]
+  public int totalItemCount;
+  [NonSerialized]
+  public int Score;
+  [NonSerialized]
+  public float timer;
+
+  private IEnumerable<Item> listOfItems;
+  private IEnumerable<ScoringZone> listOfZone;
+
+  protected override void awake()
+  {
+    totalItemCount = 0;
+    Score = 0;
+    currGameState = GameState.MAINMENU;
+
+    if (itemPool)
+    {
+      listOfItems = itemPool.GetScriptsInChildren<Item>();
+      foreach (Item i in listOfItems)
+        totalItemCount += 1;
+    }
+
+    if (zonePool)
+    {
+      listOfZone = itemPool.GetScriptsInChildren<ScoringZone>();
+      foreach (ScoringZone i in listOfZone)
+        i.gameManger = Owner.GetScript<GameManager>();
+    }
+  }
+
+  protected override void update()
+  {
+    if (timer > 0)
+      timer -= Time.DeltaTimeF;
+    else
+      currGameState = GameState.LOSE;
+  }
+
+  protected override void onTriggerEnter(CollisionInfo info)
+  {
+  }
+
+}
--- a/Assets/Scripts/SC_GameManager.cs.shmeta
+++ b/Assets/Scripts/SC_GameManager.cs.shmeta
@ -0,0 +1,3 @@
+Name: SC_GameManager
+ID: 161629605
+Type: 9
--- a/Assets/Scripts/SC_Item.cs
+++ b/Assets/Scripts/SC_Item.cs
@ -9,9 +9,16 @@ public class Item : Script
    HEAVY
  }

+  public int Score = 10;
+
  public ItemCategory currCategory;

  protected override void awake()
  {
  }
+
+  protected override void onTriggerEnter(CollisionInfo info)
+  {
+  }
+
 }
--- a/Assets/Scripts/SC_Item.cs.shmeta
+++ b/Assets/Scripts/SC_Item.cs.shmeta
@ -0,0 +1,3 @@
+Name: SC_Item
+ID: 153136539
+Type: 9
--- a/Assets/Scripts/SC_PickAndThrow.cs
+++ b/Assets/Scripts/SC_PickAndThrow.cs
@ -4,8 +4,9 @@ using static PlayerController;

 public class PickAndThrow : Script
 {
+  public Vector3 holdPosition = new Vector3(0.0f, 1.0f, 0.0f);
  public Vector3 throwForce = new Vector3(100.0f, 200.0f, 100.0f);
-  public GameObject item;
+  public GameObject item { get; set; }
  private PlayerController pc;
  private Camera cam;
  private Transform itemTransform;
@ -22,36 +23,13 @@ public class PickAndThrow : Script
    if (raccoonHoldLocation == null)
      Debug.Log("CHILD EMPTY");
    else
-      raccoonHoldLocation.LocalPosition = new Vector3(0.0f, 1.0f, 0.0f);
+      raccoonHoldLocation.LocalPosition = holdPosition;
  }
  protected override void update()
  {
-    if (cam == null)
-      cam = GetComponentInChildren<Camera>();
-    else if (cam != null)
-    {
-      Vector3 camerAixs = cam.GetForward();
-      camerAixs.y = 0;
-      camerAixs.Normalise();
-      lastXDir = camerAixs.x;
-      lastZDir = camerAixs.z;
-    }
+    CalculateDir();

-    if (item.GetScript<Item>() != null && itemTransform == null && itemRidibody == null)
-    {
-      itemTransform = item.GetComponent<Transform>();
-      if (itemTransform == null)
-        Debug.Log("Item transform EMPTY");
-
-      itemRidibody = item.GetComponent<RigidBody>();
-      if (itemRidibody == null)
-        Debug.Log("Item rb EMPTY");
-    }
-
-    if (pc != null && inRange && !pc.holdItem && Input.GetKey(Input.KeyCode.E))
-      pc.holdItem = true;
-
-    if (pc != null && itemRidibody != null && itemTransform != null && pc.holdItem)
+    if (pc != null && pc.holdItem && itemRidibody != null && itemTransform != null)
    {
      itemTransform.LocalPosition = raccoonHoldLocation.GlobalPosition;
      itemRidibody.IsGravityEnabled = false;
@ -65,17 +43,60 @@ public class PickAndThrow : Script
        itemRidibody.IsGravityEnabled = true;
        itemRidibody.AddForce(new Vector3(throwForce.x * lastXDir, throwForce.y, throwForce.z * lastZDir));
        itemRidibody.LinearVelocity += pc.rb.LinearVelocity;
+        ResetItemObject();
      }
    }
    else if(!pc.holdItem && itemRidibody != null)
      itemRidibody.IsGravityEnabled = true;
+
+    if (pc != null && !pc.holdItem && inRange && Input.GetMouseButtonDown(Input.MouseCode.LeftButton))
+    {
+      pc.holdItem = true;
+      RetrieveItemComponets();
    }
+  }
+
+  private void ResetItemObject()
+  {
+    itemRidibody = null;
+    itemTransform = null;
+    item = new GameObject();
+  }
+
+  private void RetrieveItemComponets()
+  {
+    //get the transform of the given item
+    if (item.GetScript<Item>() != null && itemTransform == null && itemRidibody == null)
+    {
+      itemTransform = item.GetComponent<Transform>();
+      if (itemTransform == null)
+        Debug.Log("Item transform EMPTY");
+
+      itemRidibody = item.GetComponent<RigidBody>();
+      if (itemRidibody == null)
+        Debug.Log("Item rb EMPTY");
+    }
+  }
+
+  private void CalculateDir()
+  {
+    if (cam == null)
+      cam = GetComponentInChildren<Camera>();
+    else if (cam != null)
+    {
+      Vector3 camerAixs = cam.GetForward();
+      camerAixs.y = 0;
+      camerAixs.Normalise();
+      lastXDir = camerAixs.x;
+      lastZDir = camerAixs.z;
+    }
+  }
+
  protected override void onCollisionEnter(CollisionInfo info)
  {
  }
  protected override void onTriggerEnter(CollisionInfo info)
  {
-    //Debug.Log("ENTER");
    if (info.GameObject.GetScript<Item>() != null && !pc.holdItem)
    {
      item = info.GameObject;
--- a/Assets/Scripts/SC_PickAndThrow.cs.shmeta
+++ b/Assets/Scripts/SC_PickAndThrow.cs.shmeta
@ -0,0 +1,3 @@
+Name: SC_PickAndThrow
+ID: 154802724
+Type: 9
--- a/Assets/Scripts/SC_PlayerController.cs
+++ b/Assets/Scripts/SC_PlayerController.cs
@ -1,40 +1,47 @@
 using SHADE;
 using System;
+using System.Collections.Generic;  
 using static Item;

 public class PlayerController : Script
 {
  public enum RaccoonStates
  {
-    IDILE,
+    IDLE,
    WALKING,
    RUNNING,
    JUMP,
    FALLING,
+    LANDED,
    CAUGHT,
    TOTAL
  }

+  public enum WalkingState
+  {
+    CARRY,
+    AIMING,
+    THROW,
+    WALK,
+    TOTAL
+  }
+
  public RigidBody rb { get; set; }
  private Transform tranform;
  private Camera cam;
  private PickAndThrow pat;
+  private StateMachine stateMachine;

-  //to be remove
-  public float drag = 2.0f;
  public bool holdItem { get; set; }
-  [SerializeField]
+
  [Tooltip("The current state fo the raccoon")]
-  public RaccoonStates currentState = RaccoonStates.IDILE;
+  public RaccoonStates currentState = RaccoonStates.IDLE;

  //Movement variables============================================================
-  [SerializeField]
  [Tooltip("Max vel for walking")]
  public float maxMoveVel = 2.0f;
-  [SerializeField]
  [Tooltip("how much force is apply for walking")]
-  public float moveForce = 50.0f;
-  [SerializeField]
+  public float moveForce = 2.0f;
  [Tooltip("increase the moveForce and maxMoveVel by its amt")]
  public float sprintMultiplier = 2.0f;

@ -49,7 +56,6 @@ public class PlayerController : Script

  public bool isMoveKeyPress { get; set; }

-  [SerializeField]
  [Tooltip("curr not working")]
  public float rotationFactorPerFrame = 1.0f;

@ -75,6 +81,7 @@ public class PlayerController : Script

  protected override void awake()
  {
+    Audio.PlayBGMOnce2D("event:/Music/player_undetected");
    //default setup
    isMoveKeyPress = false;
    holdItem = false;
@ -91,10 +98,6 @@ public class PlayerController : Script
    else
    {
      rb.IsGravityEnabled = false;
-      rb.FreezeRotationX = true;
-      rb.FreezeRotationY = true;
-      rb.FreezeRotationZ = true;
-      rb.Drag = drag;
      rb.Interpolating = false;
    }

@ -103,14 +106,18 @@ public class PlayerController : Script
    if(tranform == null)
      Debug.LogError("tranform is NULL!");

-    //PickAndThrow checl
+    //PickAndThrow check
    pat = GetScript<PickAndThrow>();
    if (pat == null)
      Debug.LogError("PickAndThrow is NULL!");

-    //toRemove
-    tranform.LocalPosition = new Vector3(-3.0f, -2.0f, -5.0f);
-    tranform.LocalRotation = Quaternion.Euler(0.0f, 0.0f, 0.0f);
+    stateMachine = AddScript<StateMachine>();
+    Dictionary<Type, BaseState> dictionary = new Dictionary<Type, BaseState>();
+    dictionary.Add(typeof(IdleState), new IdleState(stateMachine));
+    dictionary.Add(typeof(WalkState), new WalkState(stateMachine));
+    dictionary.Add(typeof(RunState), new RunState(stateMachine));
+    stateMachine.InitStateMachine(dictionary);
+
  }

  protected override void update()
@ -118,118 +125,103 @@ public class PlayerController : Script
    if (cam == null)
      cam = GetComponentInChildren<Camera>();

-    //toRemove
-    if (Input.GetKey(Input.KeyCode.G))
-    {
-      tranform.LocalRotation = Quaternion.Euler(0.0f, 0.0f, 0.0f);
-      tranform.LocalPosition = new Vector3(-3.0f, -2.0f, -5.0f);
-    }
-
    GotCaught();
-    MoveKey();
-
-
-
+    //Debug.Log($"{currentState}");
+    //Debug.Log($" axisX: {axisMove.x} axisY:{axisMove.y}");
+    //Debug.Log($"X: {rb.LinearVelocity.x}" + $" Z: {rb.LinearVelocity.z}");
    //Debug.Log(currentState.ToString() + " x:" + rb.LinearVelocity.x.ToString() + " y:" + rb.LinearVelocity.y.ToString() + " z:" + rb.LinearVelocity.z.ToString());
  }

  protected override void fixedUpdate()
  {
    //Rotation();
+
+
+    MoveKey();
    Move();
    Sprint();
    Jump();
    Gravity();
+    //Debug.Log($"X: {rb.LinearVelocity.x}" + $" Z: {rb.LinearVelocity.z}");
  }


  private void MoveKey()
  {
-    /*    if (Input.GetKey(Input.KeyCode.A))
-          xAxisMove = -1;
-        else if (Input.GetKey(Input.KeyCode.D))
-          xAxisMove = 1;
-        else
-          xAxisMove = 0;
-
-        if (Input.GetKey(Input.KeyCode.W))
-          zAxisMove = -1;
-        else if (Input.GetKey(Input.KeyCode.S))
-          zAxisMove = 1;
-        else
-          zAxisMove = 0;*/
-
-
-    xAxisMove = 0;
-    zAxisMove = 0;
    axisMove = Vector2.Zero;
    if (Input.GetKey(Input.KeyCode.W))
    {
      Vector3 camerAixs = cam.GetForward();
      camerAixs.y = 0;
      camerAixs.Normalise();
-      xAxisMove = camerAixs.x;
-      zAxisMove = camerAixs.z;
      axisMove += new Vector2(camerAixs.x, camerAixs.z);
    }
+
    if (Input.GetKey(Input.KeyCode.S))
    {
      Vector3 camerAixs = cam.GetForward();
      camerAixs.y = 0;
      camerAixs.Normalise();
-      xAxisMove = -camerAixs.x;
-      zAxisMove = -camerAixs.z;
      axisMove -= new Vector2(camerAixs.x, camerAixs.z);
    }
+
    if (Input.GetKey(Input.KeyCode.A))
    {
      Vector3 camerAixs = cam.GetRight();
      camerAixs.y = 0;
      camerAixs.Normalise();
-      xAxisMove = -camerAixs.x;
-      zAxisMove = -camerAixs.z;
      axisMove -= new Vector2(camerAixs.x, camerAixs.z);
    }
+
    if (Input.GetKey(Input.KeyCode.D))
    {
      Vector3 camerAixs = cam.GetRight();
      camerAixs.y = 0;
      camerAixs.Normalise();
-      xAxisMove = camerAixs.x;
-      zAxisMove = camerAixs.z;
      axisMove += new Vector2(camerAixs.x, camerAixs.z);
    }
-    axisMove.Normalise();
-    isMoveKeyPress = xAxisMove != 0 || zAxisMove != 0;

-    if(isMoveKeyPress && currentState != RaccoonStates.RUNNING && isGrounded)
+    axisMove.Normalise();
+    isMoveKeyPress = axisMove.x != 0 || axisMove.y != 0;
+
+    if (isMoveKeyPress && isGrounded && !Input.GetKey(Input.KeyCode.LeftShift))
+    { 
      currentState = RaccoonStates.WALKING;

+      if(stateMachine && !stateMachine.IsState(typeof(WalkState)))
+        stateMachine.SetState(typeof(WalkState));
+    }
+
    if (!isMoveKeyPress && isGrounded)
-      currentState = RaccoonStates.IDILE;
+    { 
+      currentState = RaccoonStates.IDLE;
+
+      if(stateMachine && !stateMachine.IsState(typeof(IdleState)))
+        stateMachine.SetState(typeof(IdleState));
+    }
  }

  private void Move()
  {
    if (rb != null)
    {
-      rb.AddForce(new Vector3(axisMove.x, 0.0f,axisMove.y) * moveForce);
+      rb.LinearVelocity += new Vector3(axisMove.x * moveForce, 0.0f, axisMove.y * moveForce) * Time.DeltaTimeF;

      if (isMoveKeyPress)
      {
-        if (rb.LinearVelocity.x > maxMoveVel || rb.LinearVelocity.x < -maxMoveVel)
+        if (rb)
        {
-          Vector3 v = rb.LinearVelocity;
-          v.x = System.Math.Clamp(v.x, -maxMoveVel, maxMoveVel);
-          rb.LinearVelocity = v;
-        }
-        if (rb.LinearVelocity.z > maxMoveVel || rb.LinearVelocity.z < -maxMoveVel)
+          Vector3 velNor = rb.LinearVelocity;
+          velNor.y = 0.0f;
+          if (velNor.GetMagnitude() > maxMoveVel)
          {
-          Vector3 v = rb.LinearVelocity;
-          v.z = System.Math.Clamp(v.z, -maxMoveVel, maxMoveVel);
-          rb.LinearVelocity = v;
+            velNor.Normalise();
+            velNor *= maxMoveVel;
+            rb.LinearVelocity = new Vector3(velNor.x, rb.LinearVelocity.y, velNor.z);
          }
        }
+
+      }
    }
  }

@ -238,6 +230,9 @@ public class PlayerController : Script
    if (Input.GetKey(Input.KeyCode.LeftShift) && isMoveKeyPress && isGrounded)
    {
      currentState = RaccoonStates.RUNNING;
+      if (stateMachine && !stateMachine.IsState(typeof(RunState)))
+        stateMachine.SetState(typeof(RunState));
+
      holdItem = false;
      if (!sprintIncreaseOnce)
      {
@ -252,8 +247,12 @@ public class PlayerController : Script

    if (Input.GetKeyUp(Input.KeyCode.LeftShift))
    {
-      if(isMoveKeyPress)
+      if (isMoveKeyPress)
+      { 
        currentState = RaccoonStates.WALKING;
+        if(stateMachine && !stateMachine.IsState(typeof(WalkState)))
+          stateMachine.SetState(typeof(WalkState));
+      }
      sprintIncreaseOnce = false;
      moveForce = oldForce;
      maxMoveVel = maxOldVel;
@ -263,37 +262,38 @@ public class PlayerController : Script
  //press and hold jump 
  private void Jump()
  {
-    if (currentState == RaccoonStates.WALKING || currentState == RaccoonStates.RUNNING || currentState == RaccoonStates.IDILE)
+    if (currentState == RaccoonStates.WALKING || currentState == RaccoonStates.RUNNING || currentState == RaccoonStates.IDLE)
    {
      if (Input.GetKeyDown(Input.KeyCode.Space) && isGrounded && rb != null)
      {
        currentState = RaccoonStates.JUMP;
        Vector3 v = rb.LinearVelocity;
        v.y = initialJumpVel * 0.5f;
-        if (pat != null && pat.item.GetScript<Item>() != null && holdItem)
+        if (holdItem && pat != null && pat.item.GetScript<Item>() != null)
        {
          Item item = pat.item.GetScript<Item>();
-          if (item.currCategory == ItemCategory.LIGHT)
+          if (item != null && item.currCategory == ItemCategory.LIGHT)
            v.y *= lightMultiper;
-          if (item.currCategory == ItemCategory.MEDIUM)
+          if (item != null && item.currCategory == ItemCategory.MEDIUM)
            v.y *= mediumMultiper;
-          if (item.currCategory == ItemCategory.HEAVY)
+          if (item != null && item.currCategory == ItemCategory.HEAVY)
            v.y *= heavyMultiper;
        }
        rb.LinearVelocity = v;
      }
    }

-    if(rb != null && !isGrounded && (rb.LinearVelocity.y < 0.0f || Input.GetKeyUp(Input.KeyCode.Space)))
+    if(!isGrounded && rb != null && (rb.LinearVelocity.y < 0.0f || Input.GetKeyUp(Input.KeyCode.Space)))
      currentState = RaccoonStates.FALLING;
+   
  }

  private void Rotation()
  {
    Vector3 poitionToLookAt;
-    poitionToLookAt.x = xAxisMove;
+    poitionToLookAt.x = axisMove.x;
    poitionToLookAt.y = 0.0f;
-    poitionToLookAt.z = zAxisMove;
+    poitionToLookAt.z = axisMove.y;

    if (tranform != null)
    {
@ -312,7 +312,11 @@ public class PlayerController : Script
    {
      //check player vel.y if its close to zero its on the ground
      if (SHADE.Math.CompareFloat(rb.LinearVelocity.y, 0.0f))
+      { 
        isGrounded = true;
+        if (currentState == RaccoonStates.FALLING)
+          currentState = RaccoonStates.LANDED;
+      }
      else
        isGrounded = false;

@ -344,7 +348,9 @@ public class PlayerController : Script
  {
    if (currentState == RaccoonStates.CAUGHT && tranform != null)
    {
-      currentState = RaccoonStates.IDILE;
+      currentState = RaccoonStates.IDLE;
+      if (stateMachine && !stateMachine.IsState(typeof(IdleState)))
+        stateMachine.SetState(typeof(IdleState));
      tranform.LocalPosition = new Vector3(-3.0f, -2.0f, -5.0f);
    }
  }
@ -353,6 +359,82 @@ public class PlayerController : Script
  {
  }

+}
+
+public class WalkState : BaseState
+{
+  public WalkState(StateMachine stateMachine) : base(stateMachine)
+  {
+    stateName = "Walk State";
+  }
+  public override void OnEnter()
+  {
+    //Debug.Log("WALK ENTER");
+  }
+  public override void update()
+  {
+    //Debug.Log("WALKING");
+  }
+  public override void fixedUpdate()
+  {
+    //Debug.Log("FIXED WALKING");
+  }
+  public override void OnExit()
+  {
+    //Debug.Log("WALK EXIT");
+  }
+  public override void onTriggerEnter(CollisionInfo info)
+  {
+    //Debug.Log("TRIGGER");
+  }

 }

+public class RunState : BaseState
+{
+  public RunState(StateMachine stateMachine) : base(stateMachine)
+  {
+    stateName = "Run State";
+  }
+  public override void OnEnter()
+  {
+    //Debug.Log("Run ENTER");
+  }
+  public override void update()
+  {
+    //Debug.Log("RUNING");
+  }
+  public override void fixedUpdate()
+  {
+    //Debug.Log("FIXED RUNNING");
+  }
+  public override void OnExit()
+  {
+    //Debug.Log("Run EXIT");
+  }
+}
+
+public class IdleState : BaseState
+{
+  public IdleState(StateMachine stateMachine) : base(stateMachine)
+  {
+    stateName = "Idle State";
+  }
+  public override void OnEnter()
+  {
+    //Debug.Log("IDLE ENTER");
+  }
+  public override void update()
+  {
+    //Debug.Log("IDLING");
+  }
+  public override void fixedUpdate()
+  {
+    //Debug.Log("FIXED IDLING");
+  }
+  public override void OnExit()
+  {
+    //Debug.Log("IDLE EXIT");
+  }
+}
+
--- a/Assets/Scripts/SC_PlayerController.cs.shmeta
+++ b/Assets/Scripts/SC_PlayerController.cs.shmeta
@ -0,0 +1,3 @@
+Name: SC_PlayerController
+ID: 160432754
+Type: 9
--- a/Assets/Scripts/SC_ScoringZone.cs
+++ b/Assets/Scripts/SC_ScoringZone.cs
@ -0,0 +1,21 @@
+using SHADE;
+using System;
+public class ScoringZone : Script
+{
+  public GameManager gameManger { get; set; }
+
+  protected override void awake()
+  {
+  }
+
+  protected override void onTriggerEnter(CollisionInfo info)
+  {
+    if (gameManger && info.GameObject.GetScript<Item>())
+    {
+      gameManger.Score += info.GameObject.GetScript<Item>().Score;
+      gameManger.totalItemCount -= 1;
+      info.GameObject.SetActive(false);
+    }
+  }
+
+}
--- a/Assets/Scripts/SC_ScoringZone.cs.shmeta
+++ b/Assets/Scripts/SC_ScoringZone.cs.shmeta
@ -0,0 +1,3 @@
+Name: SC_ScoringZone
+ID: 153171688
+Type: 9
--- a/Assets/Scripts/UT_BaseSate.cs
+++ b/Assets/Scripts/UT_BaseSate.cs
@ -0,0 +1,68 @@
+using SHADE;
+using System;
+
+public abstract class BaseState
+{
+
+  protected string stateName = "Base State";
+  protected StateMachine machine;
+  protected string animationName = "";
+
+  public BaseState(StateMachine stateMachine, string animName = "")
+  {
+    machine = stateMachine;
+    animationName = animName;
+  }
+
+  public virtual void OnEnter()
+  {
+  }
+
+  public abstract void update();
+
+  public abstract void fixedUpdate();
+
+  public virtual void OnExit()
+  {
+
+  }
+
+  public string GetStateName()
+  {
+    return stateName;
+  }
+
+  public string GetAnimName()
+  {
+    return animationName;
+  }
+
+  public virtual float GetAnimPercent()
+  {
+    return 1.0f;
+  }
+
+  public virtual void onCollisionEnter(CollisionInfo info)
+  {
+  }
+
+  public virtual void onCollisionStay(CollisionInfo info)
+  {
+  }
+
+  public virtual void onCollisionExit(CollisionInfo info)
+  {
+  }
+
+  public virtual void onTriggerEnter(CollisionInfo info)
+  {
+  }
+
+  public virtual void onTriggerStay(CollisionInfo info)
+  {
+  }
+
+  public virtual void onTriggerExit(CollisionInfo info)
+  {
+  }
+}
--- a/Assets/Scripts/UT_BaseSate.cs.shmeta
+++ b/Assets/Scripts/UT_BaseSate.cs.shmeta
@ -0,0 +1,3 @@
+Name: UT_BaseSate
+ID: 154709755
+Type: 9
--- a/Assets/Scripts/UT_StateMachine.cs
+++ b/Assets/Scripts/UT_StateMachine.cs
@ -0,0 +1,126 @@
+using SHADE;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class StateMachine : Script
+{
+  private Dictionary<Type, BaseState> stateDictionary;
+  public BaseState currentState = null;
+  public string currentStateName;
+  public string currentAnimName;
+
+  public void InitStateMachine(Dictionary<Type, BaseState> dictionary)
+  {
+
+    stateDictionary = dictionary;
+    currentState = stateDictionary.First().Value;
+    currentStateName = currentState.GetStateName();
+    currentAnimName = currentState.GetAnimName();
+    currentState.OnEnter();
+  }
+
+  public bool HasState(Type type)
+  {
+    if (!type.IsSubclassOf(typeof(BaseState)))
+    {
+      return false;
+    }
+    else
+    {
+      return stateDictionary.ContainsKey(type);
+    }
+  }
+
+  public void SetState(Type type)
+  {
+    if (!type.IsSubclassOf(typeof(BaseState)))
+    {
+      return;
+    }
+
+
+    if (stateDictionary.ContainsKey(type))
+    {
+      currentState.OnExit();
+      currentState = stateDictionary[type];
+      currentState.OnEnter();
+    }
+    else
+    {
+      SetState(stateDictionary.First().Key);
+    }
+  }
+
+  public BaseState GetState(Type type)
+  {
+    if (!stateDictionary.ContainsKey(type))
+      return null;
+
+    return stateDictionary[type];
+  }
+  public bool IsState(Type type)
+  {
+    return (currentState.GetType() == type);
+  }
+
+  protected override void update()
+  {
+    if (currentState != (null))
+    {
+      currentStateName = currentState.GetStateName();
+      currentAnimName = currentState.GetAnimName();
+      currentState.update();
+    }
+
+  }
+
+  protected override void fixedUpdate()
+  {
+    if (currentState != (null))
+    {
+      currentStateName = currentState.GetStateName();
+      currentAnimName = currentState.GetAnimName();
+      currentState.fixedUpdate();
+    }
+  }
+
+  protected override void onCollisionEnter(CollisionInfo info)
+  {
+    if (currentState != (null))
+      currentState.onCollisionEnter(info);
+  }
+
+  protected override void onCollisionStay(CollisionInfo info)
+  {
+    if (currentState != (null))
+      currentState.onCollisionStay(info);
+  }
+
+  protected override void onCollisionExit(CollisionInfo info)
+  {
+    if (currentState != (null))
+      currentState.onCollisionExit(info);
+  }
+
+  protected override void onTriggerEnter(CollisionInfo info)
+  {
+    if (currentState != (null))
+      currentState.onTriggerEnter(info);
+  }
+
+  protected override void onTriggerStay(CollisionInfo info)
+  {
+    if (currentState != (null))
+      currentState.onTriggerStay(info);
+  }
+
+  protected override void onTriggerExit(CollisionInfo info)
+  {
+    if (currentState != (null))
+      currentState.onTriggerExit(info);
+  }
+
+
+}
+
--- a/Assets/Scripts/UT_StateMachine.cs.shmeta
+++ b/Assets/Scripts/UT_StateMachine.cs.shmeta
@ -0,0 +1,3 @@
+Name: UT_StateMachine
+ID: 166010611
+Type: 9
--- a/Assets/Shaders/Normals_FS.glsl
+++ b/Assets/Shaders/Normals_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 = normals * texture(textures[nonuniformEXT(MatProp.data[In2.materialIndex].textureIndex)], In.uv) * MatProp.data[In2.materialIndex].color;
+
+  outEntityID = In2.eid;
+  lightLayerIndices = In2.lightLayerIndex;
+}
--- a/Assets/Shaders/Normals_FS.shshaderb
+++ b/Assets/Shaders/Normals_FS.shshaderb
--- a/Assets/Shaders/Normals_FS.shshaderb.shmeta
+++ b/Assets/Shaders/Normals_FS.shshaderb.shmeta
@ -0,0 +1,3 @@
+Name: Normals_FS
+ID: 48689301
+Type: 2
--- a/SHADE_Application/premake5.lua
+++ b/SHADE_Application/premake5.lua
@ -75,7 +75,8 @@ project "SHADE_Application"
    "26439",
    "26451",
    "26437",
-    "4275"
+    "4275",
+    "4635"
  }

  linkoptions { "-IGNORE:4006" }
--- a/SHADE_Application/src/Application/SBApplication.cpp
+++ b/SHADE_Application/src/Application/SBApplication.cpp
@ -8,8 +8,8 @@
 //#include "Scenes/SBEditorScene.h"
 #endif // SHEDITOR

-#include "Tools/SHLogger.h"
-#include "Tools/SHFileUtilties.h"
+#include "Tools/Logger/SHLogger.h"
+#include "Tools/Utilities/SHFileUtilties.h"

 #include <chrono>
 #include <ratio>
@ -33,6 +33,7 @@
 #include "Physics/System/SHPhysicsSystem.h"
 #include "Physics/System/SHPhysicsDebugDrawSystem.h"
 #include "Scripting/SHScriptEngine.h"
+#include "UI/SHUISystem.h"

 // Components
 #include "Graphics/MiddleEnd/Interface/SHRenderable.h"
@ -44,7 +45,7 @@
 #include "Scenes/SBMainScene.h"
 #include "Serialization/Configurations/SHConfigurationManager.h"

-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "Tools/SHDebugDraw.h"

 using namespace SHADE;
@ -60,6 +61,8 @@ namespace Sandbox
    _In_      INT       nCmdShow
  )
  {
+    SHLOG_INFO_D("Initialising SHADE engine")
+
    // Set working directory
    SHFileUtilities::SetWorkDirToExecDir();
    WindowData wndData{};
@ -75,6 +78,7 @@ namespace Sandbox

    SHSystemManager::CreateSystem<SHAudioSystem>();
    SHSystemManager::CreateSystem<SHCameraSystem>();
+    SHSystemManager::CreateSystem<SHUISystem>();


    SHSystemManager::CreateSystem<SHGraphicsSystem>();
@ -113,10 +117,13 @@ namespace Sandbox
    SHSystemManager::RegisterRoutine<SHDebugDrawSystem, SHDebugDrawSystem::ProcessPointsRoutine>();

    SHSystemManager::RegisterRoutine<SHScriptEngine, SHScriptEngine::GizmosDrawRoutine>();
+    SHSystemManager::RegisterRoutine<SHGraphicsSystem, SHGraphicsSystem::PrepareRenderRoutine>();
    SHSystemManager::RegisterRoutine<SHGraphicsSystem, SHGraphicsSystem::BatcherDispatcherRoutine>();
    SHSystemManager::RegisterRoutine<SHGraphicsSystem, SHGraphicsSystem::BeginRoutine>();

    //SHSystemManager::RegisterRoutine<SHCameraSystem, SHCameraSystem::EditorCameraUpdate>();
+    SHSystemManager::RegisterRoutine<SHUISystem, SHUISystem::AddUIComponentRoutine>();
+    SHSystemManager::RegisterRoutine<SHUISystem, SHUISystem::UpdateUIMatrixRoutine>();
    SHSystemManager::RegisterRoutine<SHCameraSystem, SHCameraSystem::CameraSystemUpdate>();
    
 #ifdef SHEDITOR
--- a/SHADE_Application/src/WinMain.cpp
+++ b/SHADE_Application/src/WinMain.cpp
@ -1,6 +1,6 @@
 #include "SBpch.h"
 #include <Engine/SHEngine.h>
-#include <Tools/SHLogger.h>
+#include <Tools/Logger/SHLogger.h>
 #include <Tools/SHExceptionHandler.h>
 #include "Application/SBApplication.h"

--- a/SHADE_CSharp/premake5.lua
+++ b/SHADE_CSharp/premake5.lua
@ -27,6 +27,12 @@ project "SHADE_CSharp"

  warnings 'Extra'
  
+  postbuildcommands 
+  {
+    "xcopy  /r /y /q \"%{outputdir}\\net5.0\\SHADE_CSharp.xml\" \"%{outputdir}\"",
+    "xcopy  /r /y /q \"%{outputdir}\\net5.0\\SHADE_CSharp.pdb\" \"%{outputdir}\""
+  }
+
  filter "configurations:Debug"
    symbols "On"
    defines {"_DEBUG"}
@ -41,12 +47,18 @@ project "SHADE_CSharp"

  require "vstudio"

-  function platformsElement(cfg)
+  function platformsElementCS(cfg)
    _p(2,'<Platforms>x64</Platforms>')
  end
+  function docsElementCS(cfg)
+    _p(2,'<GenerateDocumentationFile>true</GenerateDocumentationFile>')
+  end
+  function docsLocationElementCS(cfg)
+    _p(2,'<DocumentationFile>$(OutDir)</DocumentationFile>')
+  end

  premake.override(premake.vstudio.cs2005.elements, "projectProperties", function (oldfn, cfg)
    return table.join(oldfn(cfg), {
-      platformsElement,
+      platformsElementCS, docsElementCS, docsLocationElementCS,
    })
  end)
--- a/SHADE_Engine/premake5.lua
+++ b/SHADE_Engine/premake5.lua
@ -78,7 +78,8 @@ project "SHADE_Engine"
    "26439",
    "26451",
    "26437",
-    "4275"
+    "4275",
+    "4635"
  }

  linkoptions { "-IGNORE:4006" }
--- a/SHADE_Engine/src/Assets/SHAssetManager.cpp
+++ b/SHADE_Engine/src/Assets/SHAssetManager.cpp
@ -143,6 +143,28 @@ namespace SHADE
 		return result;
 	}

+    AssetType SHAssetManager::GetType(AssetID id) noexcept
+    {
+      if (assetCollection.contains(id))
+      {
+        return assetCollection[id].type;
+      }
+      
+      SHLOG_WARNING("AssetID {}, does not belong to an asset", id)
+
+      return AssetType::INVALID;
+    }
+
+    std::optional<SHADE::SHAsset> SHAssetManager::GetAsset(AssetID id) noexcept
+    {
+      if (assetCollection.contains(id))
+      {
+        return assetCollection[id];
+      }
+
+      return {};
+    }
+
    /****************************************************************************
 	 * \brief Create record for new asset. CAN ONLY CREATE FOR CUSTOM
 	 *				ASSETS CREATED BY THE ENGINE.
@ -161,21 +183,39 @@ namespace SHADE
      newPath += PREFAB_FOLDER;
      newPath += name;
      newPath += PREFAB_EXTENSION;
-      data = new SHPrefabAsset();
+      {
+        auto prefab = new SHPrefabAsset();
+        prefab->name = name;
+
+        data = prefab;
+      }
+
      break;

    case AssetType::SCENE:
      newPath += SCENE_FOLDER;
      newPath += name;
      newPath += SCENE_EXTENSION;
-      data = new SHSceneAsset();
+
+      {
+        auto scene = new SHSceneAsset();
+      scene->name = name;
+
+      data = scene;
+      }
      break;

    case AssetType::MATERIAL:
      newPath += MATERIAL_FOLDER;
      newPath += name;
      newPath += MATERIAL_EXTENSION;
-      data = new SHMaterialAsset();
+
+      {
+        auto material = new SHMaterialAsset();
+      material->name = name;
+
+      data = material;
+      }
      break;

    default:
@ -192,7 +232,7 @@ namespace SHADE
      false
    };

-    assetCollection.insert({
+    auto result = assetCollection.emplace(
      id,
        SHAsset(
          name,
@ -201,10 +241,13 @@ namespace SHADE
          newPath,
          false
          )
-    });
+    );

    assetData.emplace(id, data);

+    SHAssetMetaHandler::WriteMetaData(asset);
+    SaveAsset(id);
+
 		return id;
 	}

@ -361,6 +404,21 @@ namespace SHADE
      modelPath += MODEL_EXTENSION;
      newPath = modelPath;
    }
+    else if (ext == DDS_EXTENSION.data())
+    {
+      auto pathGen = SHTextureCompiler::CompileTextureAsset(path);
+      if (!pathGen.has_value())
+      {
+        SHLOG_ERROR("Texture Compilation Failed for: {}", path.string());
+        return;
+      }
+      newPath = pathGen.value();
+    }
+    else
+    {
+      SHLOG_WARNING("File Type compilation not yet Implemented: {}", path.string());
+      return;
+    }

    if (genMeta)
    {
@ -376,7 +434,7 @@ namespace SHADE
  void SHAssetManager::RefreshDirectory() noexcept
  {
    SHFileSystem::DestroyDirectory(folderRoot);
-    assetCollection.clear();
+    //assetCollection.clear();
    BuildAssetCollection();
  }

@ -507,7 +565,7 @@ namespace SHADE
    {
      SHAsset newAsset{
        path.stem().string(),
-        GenerateAssetID(AssetType::SHADER_BUILT_IN),
+        GenerateAssetID(AssetType::TEXTURE),
        AssetType::SHADER_BUILT_IN,
        path,
        false
@ -560,6 +618,34 @@ namespace SHADE
      assetCollection.emplace(newAsset.id, newAsset);
      SHAssetMetaHandler::WriteMetaData(newAsset);

+      return newAsset.id;
+    }
+    else if (ext == SCENE_EXTENSION)
+    {
+      SHAsset newAsset{
+        path.stem().string(),
+        GenerateAssetID(AssetType::SCENE),
+        AssetType::SCENE,
+        path,
+        false
+      };
+      assetCollection.emplace(newAsset.id, newAsset);
+      SHAssetMetaHandler::WriteMetaData(newAsset);
+
+      return newAsset.id;
+    }
+    else if (ext == FONT_EXTENSION)
+    {
+      SHAsset newAsset{
+        path.stem().string(),
+        GenerateAssetID(AssetType::FONT),
+        AssetType::FONT,
+        path,
+        false
+      };
+      assetCollection.emplace(newAsset.id, newAsset);
+      SHAssetMetaHandler::WriteMetaData(newAsset);
+
      return newAsset.id;
    }
  }
@ -571,8 +657,11 @@ namespace SHADE

    for (auto& file : toGenNew)
    {
-      auto newID{ GenerateNewMeta(file->path).value() };
-      file->assetMeta = &assetCollection[newID];
+      auto newID{ GenerateNewMeta(file->path) };
+      if (newID.has_value())
+      {
+      file->assetMeta = &assetCollection[newID.value()];
+      }
    }

    for (auto& asset : std::ranges::views::values(assetCollection))
@ -583,6 +672,12 @@ namespace SHADE
        for (auto i{ 0 }; i < asset.subAssets.size(); ++i)
        {
          auto const id = asset.subAssets[i]->id;
+          
+          if (assetCollection.contains(id))
+          {
+            continue;
+          }
+
          assetCollection[id] = *asset.subAssets[i];
          delete asset.subAssets[i];
          asset.subAssets[i] = &assetCollection[id];
--- a/SHADE_Engine/src/Assets/SHAssetManager.h
+++ b/SHADE_Engine/src/Assets/SHAssetManager.h
@ -50,6 +50,9 @@ namespace SHADE
 		 * \return const& to unordered_map<AssetName, AssetID>
 		****************************************************************************/
 		static std::vector<SHAsset> GetAllAssets() noexcept;
+        static std::optional<SHAsset> GetAsset(AssetID id) noexcept;
+
+    static AssetType GetType(AssetID id) noexcept;

 		/****************************************************************************
 		 * \brief Create record for new resource. CAN ONLY CREATE FOR CUSTOM
--- a/SHADE_Engine/src/Assets/SHAssetMetaHandler.cpp
+++ b/SHADE_Engine/src/Assets/SHAssetMetaHandler.cpp
@ -138,6 +138,7 @@ namespace SHADE
 		metaFile.close();

 		meta.path = path.parent_path().string() + "/" + path.stem().string();
+    meta.path.make_preferred();

 		return meta;
 	}
--- a/SHADE_Engine/src/AudioSystem/SHAudioSystem.cpp
+++ b/SHADE_Engine/src/AudioSystem/SHAudioSystem.cpp
@ -84,12 +84,32 @@ namespace SHADE
    LoadBank((AUDIO_FOLDER_PATH + "Master.bank").data());
    LoadBank((AUDIO_FOLDER_PATH + "Master.strings.bank").data());
    //LoadBank((AUDIO_FOLDER_PATH + "Music.bank").data());
-    LoadBank((AUDIO_FOLDER_PATH + "footsteps.bank").data());
+    //LoadBank((AUDIO_FOLDER_PATH + "footsteps.bank").data());
+    LoadBank((AUDIO_FOLDER_PATH + "Music.bank").data());
+    LoadBank((AUDIO_FOLDER_PATH + "SFX.bank").data());
+    LoadBank((AUDIO_FOLDER_PATH + "UI.bank").data());

    //auto clip = CreateAudioClip("event:/Characters/sfx_footsteps_human");
    //clip->Play();
    //PlayEventOnce("event:/Characters/sfx_footsteps_raccoon");
    //PlayEventOnce("event:/SFX/Dawn/Dawn_Attack");
+
+  #ifdef SHEDITOR
+
+    // Subscribe to Editor State Change Events
+    const std::shared_ptr ON_PLAY_RECEIVER{ std::make_shared<SHEventReceiverSpec<SHAudioSystem>>(this, &SHAudioSystem::onPlay) };
+    const ReceiverPtr ON_PLAY_RECEIVER_PTR = std::dynamic_pointer_cast<SHEventReceiver>(ON_PLAY_RECEIVER);
+    SHEventManager::SubscribeTo(SH_EDITOR_ON_PLAY_EVENT, ON_PLAY_RECEIVER_PTR);
+
+    const std::shared_ptr ON_STOP_RECEIVER{ std::make_shared<SHEventReceiverSpec<SHAudioSystem>>(this, &SHAudioSystem::onStop) };
+    const ReceiverPtr ON_STOP_RECEIVER_PTR = std::dynamic_pointer_cast<SHEventReceiver>(ON_STOP_RECEIVER);
+    SHEventManager::SubscribeTo(SH_EDITOR_ON_STOP_EVENT, ON_STOP_RECEIVER_PTR);
+
+    const std::shared_ptr ON_PAUSE_RECEIVER{ std::make_shared<SHEventReceiverSpec<SHAudioSystem>>(this, &SHAudioSystem::onPause) };
+    const ReceiverPtr ON_PAUSE_RECEIVER_PTR = std::dynamic_pointer_cast<SHEventReceiver>(ON_PAUSE_RECEIVER);
+    SHEventManager::SubscribeTo(SH_EDITOR_ON_PAUSE_EVENT, ON_PAUSE_RECEIVER_PTR);
+
+  #endif
  }
  
  void SHADE::SHAudioSystem::Run(double dt)
@ -179,7 +199,6 @@ namespace SHADE
          it->second->createInstance(&event);
          if (event)
          {
-
              event->setVolume(masterVolume * (isSFX ? sfxVolume : bgmVolume));
              if (spatial)
              {
@ -285,6 +304,7 @@ namespace SHADE
      if (channel->isPlaying(&isPlaying) == FMOD_OK && isPlaying)
        channel->stop();
    }
+    masterGroup->stop();
  }

  std::optional<FMOD_GUID> SHAudioSystem::GetEventGUID(const char* path)
@ -410,6 +430,7 @@ namespace SHADE
  void SHAudioSystem::SetPaused(bool pause)
  {
    paused = pause;
+    masterGroup->setPaused(pause);
    for (auto const& channel : audioChannels)
    {
      channel->setPaused(paused);
@ -552,6 +573,27 @@ namespace SHADE
    return value;
  }

+  SHEventHandle SHAudioSystem::onStop(SHEventPtr onStopEvent)
+  {
+    StopAllSounds();
+
+    return onStopEvent->handle;
+  }
+
+  SHEventHandle SHAudioSystem::onPause(SHEventPtr onStopEvent)
+  {
+    SetPaused(true);
+
+    return onStopEvent->handle;
+  }
+  SHEventHandle SHAudioSystem::onPlay(SHEventPtr onStopEvent)
+  {
+    if(GetPaused())
+      SetPaused(false);
+
+    return onStopEvent->handle;
+  }
+
 }

 #pragma warning(pop)
--- a/SHADE_Engine/src/AudioSystem/SHAudioSystem.h
+++ b/SHADE_Engine/src/AudioSystem/SHAudioSystem.h
@ -7,9 +7,11 @@
 #include "ECS_Base/System/SHSystem.h"
 #include "ECS_Base/System/SHSystemRoutine.h"
 #include "ECS_Base/SHECSMacros.h"
-#include "Math/SHMath.h"
+#include "Math/Vector/SHVec3.h"
 #include <optional>
 #include <FMOD/fmod_studio.hpp>
+#include "Events/SHEvent.h"
+
 #include "SH_API.h"
 #define AUDIO_SYS_MAX_CHANNELS 1024

@ -104,6 +106,10 @@ namespace SHADE
    
    std::vector<SHAudioListenerComponent>* denseListener;
    AudioClipID clipID = 0;
+
+    SHEventHandle onPlay(SHEventPtr onStopEvent);
+    SHEventHandle onStop(SHEventPtr onStopEvent);
+    SHEventHandle onPause(SHEventPtr onStopEvent);
  };

 }
--- a/SHADE_Engine/src/Camera/SHCameraComponent.cpp
+++ b/SHADE_Engine/src/Camera/SHCameraComponent.cpp
@ -12,7 +12,7 @@ namespace SHADE
 		: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()
+		, viewMatrix(), perspProjMatrix(), orthoProjMatrix()
 		, position(), offset()
 	{
 		ComponentFamily::GetID<SHCameraComponent>();
@ -213,7 +213,20 @@ namespace SHADE

 	const SHMatrix& SHCameraComponent::GetProjMatrix() const noexcept
 	{
-		return projMatrix;
+    if (perspProj)
+      return perspProjMatrix;
+    else
+      return orthoProjMatrix;
+	}
+
+  const SHMatrix& SHCameraComponent::GetOrthoMatrix() const noexcept
+  {
+    return orthoProjMatrix;
+  }
+
+  const SHMatrix& SHCameraComponent::GetPerspectiveMatrix() const noexcept
+  {
+    return orthoProjMatrix;
  }

 	//void SHCameraComponent::SetMainCamera(size_t directorCameraIndex) noexcept
--- a/SHADE_Engine/src/Camera/SHCameraComponent.h
+++ b/SHADE_Engine/src/Camera/SHCameraComponent.h
@ -29,7 +29,8 @@ namespace SHADE


 		SHMatrix viewMatrix;
-		SHMatrix projMatrix;
+		SHMatrix perspProjMatrix;
+		SHMatrix orthoProjMatrix;
 		SHVec3 position;

 		bool perspProj;
@ -37,6 +38,7 @@ namespace SHADE

    

+
 	public:
 		friend class SHCameraSystem;

@ -78,6 +80,8 @@ namespace SHADE

 		const SHMatrix& GetViewMatrix() const noexcept;
 		const SHMatrix& GetProjMatrix() const noexcept;
+    const SHMatrix& GetOrthoMatrix() const noexcept;
+    const SHMatrix& GetPerspectiveMatrix() const noexcept;

 		//void SetMainCamera(size_t cameraDirectorIndex = 0) noexcept;
 		
--- a/SHADE_Engine/src/Camera/SHCameraDirector.cpp
+++ b/SHADE_Engine/src/Camera/SHCameraDirector.cpp
@ -5,7 +5,7 @@
 #include "ECS_Base/Managers/SHComponentManager.h"
 #include "ECS_Base/SHECSMacros.h"
 #include "ECS_Base/Managers/SHEntityManager.h"
-#include "Tools/SHLog.h"
+#include "Tools/Logger/SHLog.h"

 namespace SHADE
 {
@ -15,27 +15,27 @@ namespace SHADE
 	}


-	SHMatrix SHCameraDirector::GetViewMatrix() const noexcept
+	SHMatrix const& SHCameraDirector::GetViewMatrix() const noexcept
 	{
 		return viewMatrix;
 	}
-	SHMatrix SHCameraDirector::GetProjMatrix() const noexcept
+	SHMatrix const& SHCameraDirector::GetProjMatrix() const noexcept
 	{
 		return projMatrix;
 	}
-	SHMatrix SHCameraDirector::GetVPMatrix() const noexcept
+	SHMatrix const& SHCameraDirector::GetVPMatrix() const noexcept
 	{
 		return projMatrix * viewMatrix;
 	}

-	void SHCameraDirector::UpdateMatrix() noexcept
+  SHCameraComponent* SHCameraDirector::GetMainCameraComponent() noexcept
  {
    if (mainCameraEID == MAX_EID)
    {
      auto& dense = SHComponentManager::GetDense<SHCameraComponent>();
      if (dense.size() == 0)
      {
-				return;
+        return nullptr;
      }
      mainCameraEID = dense[0].GetEID();
    }
@ -44,7 +44,13 @@ namespace SHADE
    {
      SHLOG_WARNING("Camera Director warning: Entity does not have a camera");
    }
-		else
+  }
+
+
+	void SHCameraDirector::UpdateMatrix() noexcept
+	{
+    SHCameraComponent* camComponent = GetMainCameraComponent();
+		if(camComponent)
 		{
 			viewMatrix = camComponent->GetViewMatrix();
 			projMatrix = camComponent->GetProjMatrix();
@ -62,6 +68,24 @@ namespace SHADE
 		mainCameraEID = camera.GetEID();
 	}

+  SHMatrix const& SHCameraDirector::GetOrthoMatrix() noexcept
+  {
+
+    SHCameraComponent* camComponent = GetMainCameraComponent();
+    if (camComponent)
+      return camComponent->GetOrthoMatrix();
+    else
+      return SHMatrix::Identity;
+  }
+
+  SHMatrix const& SHCameraDirector::GetPerspectiveMatrix() noexcept
+  {
+    SHCameraComponent* camComponent = GetMainCameraComponent();
+    if (camComponent)
+      return camComponent->GetPerspectiveMatrix();
+    else
+      return SHMatrix::Identity;
+  }


 }
--- a/SHADE_Engine/src/Camera/SHCameraDirector.h
+++ b/SHADE_Engine/src/Camera/SHCameraDirector.h
@ -23,20 +23,20 @@ namespace SHADE
 		EntityID transitionCameraEID;
    

-		SHMatrix GetViewMatrix() const noexcept;
-		SHMatrix GetProjMatrix() const noexcept;
-		SHMatrix GetVPMatrix() const noexcept;
+		SHMatrix const& GetViewMatrix() const noexcept;
+		SHMatrix const& GetProjMatrix() const noexcept;
+		SHMatrix const& GetVPMatrix() const noexcept;
 		void UpdateMatrix() noexcept;
 		void SetMainCamera(SHCameraComponent& cam) noexcept;
-
+    SHMatrix const& GetOrthoMatrix() noexcept;
+    SHMatrix const& GetPerspectiveMatrix() noexcept;

 	private:
-
-
-	protected:
    SHMatrix viewMatrix;
    SHMatrix projMatrix;

+    SHCameraComponent* GetMainCameraComponent() noexcept;
+
 	};

 	typedef Handle<SHCameraDirector> DirectorHandle;
--- a/SHADE_Engine/src/Camera/SHCameraSystem.cpp
+++ b/SHADE_Engine/src/Camera/SHCameraSystem.cpp
@ -107,7 +107,11 @@ namespace SHADE
    editorCamera.SetPitch(0.0f);
    editorCamera.SetYaw(0.0f);
    editorCamera.SetRoll(0.0f);
+    editorCamera.SetWidth(1080.0f);
+    editorCamera.SetHeight(720.0f);
+    editorCamera.SetFar(10000000.0f);
    editorCamera.movementSpeed = 2.0f;
+    editorCamera.perspProj = true;

    SHComponentManager::CreateComponentSparseSet<SHCameraComponent>();
    SHComponentManager::CreateComponentSparseSet<SHCameraArmComponent>();
@ -210,39 +214,43 @@ namespace SHADE
 		}
    if (camera.dirtyProj == true)
    {
-      if (camera.perspProj == true)
-      {
+        //Perspective projection matrix.
        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.perspProjMatrix = SHMatrix::Identity;
+        camera.perspProjMatrix(0, 0) = 1.0f / (ASPECT_RATIO * TAN_HALF_FOV);
+        camera.perspProjMatrix(1, 1) = 1.0f / TAN_HALF_FOV;
+        camera.perspProjMatrix(2, 2) = camera.zFar / (camera.zFar - camera.zNear);
+        camera.perspProjMatrix(3, 3) = 0.0f;
               
-        camera.projMatrix(3, 2) = 1.0f;
-        camera.projMatrix(2, 3) = -(camera.zFar * camera.zNear) / (camera.zFar - camera.zNear);
+        camera.perspProjMatrix(3, 2) = 1.0f;
+        camera.perspProjMatrix(2, 3) = -(camera.zFar * camera.zNear) / (camera.zFar - camera.zNear);
        
        
+        
+        //Orthographic projection matrix
+
+        const float right = camera.GetWidth() * 0.5f;
+        const float left = -right;
+        const float top = camera.GetHeight() * 0.5f;
+        const float btm = -top;
+        const float n = camera.GetNear();
+        const float f = camera.GetFar();
+
+        camera.orthoProjMatrix = SHMatrix::Identity;
+        camera.orthoProjMatrix(0, 0) = 2.0f / (right - left);
+        camera.orthoProjMatrix(1, 1) = 2.0f / (btm - top);
+        camera.orthoProjMatrix(2, 2) = 1.0f / (f-n);
+        camera.orthoProjMatrix(0, 3) = -(right + left) / (right - left);
+        camera.orthoProjMatrix(1, 3) = -(btm + top) / (btm - top);
+        camera.orthoProjMatrix(2, 3) = -n / (f-n);
+        camera.orthoProjMatrix(3, 3) = 1.0f;
+
+        camera.orthoProjMatrix = SHMatrix::OrthographicRH(camera.GetWidth(), camera.GetHeight(), camera.GetNear(), camera.GetFar());
+        //camera.projMatrix.Transpose();
+
        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;
-      }
    }
 	}

@ -252,8 +260,6 @@ namespace SHADE
    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;
@ -287,6 +293,9 @@ namespace SHADE
      if (SHSceneManager::CheckNodeAndComponentsActive<SHCameraComponent>(cam.GetEID()))
        system->UpdateCameraComponent(cam);
    }
+
+    
+
    for (auto& handle : system->directorHandleList)
    {
      handle->UpdateMatrix();
--- a/SHADE_Engine/src/Camera/SHCameraSystem.h
+++ b/SHADE_Engine/src/Camera/SHCameraSystem.h
@ -37,8 +37,6 @@ namespace SHADE
 		void Exit (void);


-		friend class EditorCameraUpdate;
-
 		class SH_API CameraSystemUpdate final: public SHSystemRoutine
 		{
 		public:
--- a/SHADE_Engine/src/ECS_Base/Managers/SHEntityManager.cpp
+++ b/SHADE_Engine/src/ECS_Base/Managers/SHEntityManager.cpp
@ -218,7 +218,7 @@ namespace SHADE
    EntityID result = MAX_EID;
    for (auto& entity : entityVec)
    {
-      if (entity->name == name)
+      if (entity && entity->name == name)
        result = entity->GetEID();
    }
    return result;
--- a/SHADE_Engine/src/ECS_Base/UnitTesting/SHECSUnitTest.cpp
+++ b/SHADE_Engine/src/ECS_Base/UnitTesting/SHECSUnitTest.cpp
@ -5,7 +5,7 @@
 #include "../Managers/SHSystemManager.h"
 #include "SHTestComponents.h"
 #include "SHTestSystems.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"



--- a/SHADE_Engine/src/Editor/DragDrop/SHDragDrop.cpp
+++ b/SHADE_Engine/src/Editor/DragDrop/SHDragDrop.cpp
@ -5,6 +5,7 @@
 namespace SHADE
 {
  bool SHDragDrop::hasDragDrop = false;
+  SHDragDrop::DragDropTag SHDragDrop::currentDragDropTag{};

  bool SHDragDrop::BeginSource(ImGuiDragDropFlags const flags)
  { return ImGui::BeginDragDropSource(flags); }
@ -16,6 +17,10 @@ namespace SHADE
  { return ImGui::BeginDragDropTarget(); }

  void SHDragDrop::EndTarget()
-  { ImGui::EndDragDropTarget(); hasDragDrop = false;}
+  {
+    ImGui::EndDragDropTarget(); 
+    hasDragDrop = false;
+    currentDragDropTag = {};
+  }

 }
--- a/SHADE_Engine/src/Editor/DragDrop/SHDragDrop.hpp
+++ b/SHADE_Engine/src/Editor/DragDrop/SHDragDrop.hpp
@ -19,9 +19,13 @@ namespace SHADE
    static void EndSource();

    template<typename T>
-    static bool SetPayload(std::string_view const type, T* object, ImGuiCond const cond = 0)
+    static bool SetPayload(DragDropTag const& type, T* object, ImGuiCond const cond = 0)
    {
-      hasDragDrop = ImGui::SetDragDropPayload(type.data(), static_cast<void*>(object), sizeof(T), cond);
+      ImGui::SetDragDropPayload(type.data(), static_cast<void*>(object), sizeof(T), cond);
+
+      hasDragDrop = true;
+      currentDragDropTag = type;
+      
      return hasDragDrop;
    }

@ -32,13 +36,16 @@ namespace SHADE
    static void EndTarget();

    template<typename T>
-    static T* AcceptPayload(std::string_view const type, ImGuiDragDropFlags const flags = 0)
+    static T* AcceptPayload(DragDropTag const& type, ImGuiDragDropFlags const flags = 0)
    {
      if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(type.data(), flags))
+      {
        return static_cast<T*>(payload->Data);
+      }
      return nullptr;
    }

    static bool hasDragDrop;
+    static DragDropTag currentDragDropTag;
  };
 }
--- a/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp
@ -109,7 +109,7 @@ namespace SHADE
      ImVec2 vertLineEnd = vertLineStart;
      for (auto const& subFolder : subFolders)
      {
-        const float horizontalLineSize = 8.0f;
+        const float horizontalLineSize = (subFolder->subFolders.empty() && subFolder->files.empty()) ? 25.0f : 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);
@ -117,7 +117,7 @@ namespace SHADE
      }
      for (auto& file : files)
      {
-        const float horizontalLineSize = 25.0f;
+        const float horizontalLineSize = (file.assetMeta && !file.assetMeta->subAssets.empty()) ? 8.0f : 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);
@ -182,7 +182,10 @@ namespace SHADE
      return nodeRect;
    }
    if(file.assetMeta)
-      DrawAsset(file.assetMeta, file.ext);
+    {
+      const ImRect childRect = DrawAsset(file.assetMeta, file.ext);
+      return childRect;
+    }
  }

  ImRect SHAssetBrowser::DrawAsset(SHAsset const* const asset, FileExt const& ext /*= ""*/) noexcept
--- a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp
@ -23,7 +23,7 @@
 #include <imgui.h>

 #include "Serialization/SHSerialization.h"
-#include "Tools/SHClipboardUtilities.h"
+#include "Tools/Utilities/SHClipboardUtilities.h"


 namespace SHADE
@ -116,12 +116,15 @@ namespace SHADE
    if(ImGui::IsWindowHovered() && !ImGui::IsAnyItemHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Left))
    {
      if(ImGui::IsDragDropActive())
+      {
+        if (SHDragDrop::currentDragDropTag == SHDragDrop::DRAG_EID)
        {
          ParentSelectedEntities(MAX_EID, draggingEntities);
          draggingEntities.clear();
          ImGui::ClearDragDrop();
        }
      }
+    }
    ImGui::End();
  }

@ -233,8 +236,9 @@ namespace SHADE
      {
        ParentSelectedEntities(eid, draggingEntities);
        draggingEntities.clear();
-        SHDragDrop::EndTarget();
+        //ImGui::ClearDragDrop();
      }
+      SHDragDrop::EndTarget();
    }

    //Context menu
@ -342,13 +346,16 @@ namespace SHADE
    SHEntityManager::CreateEntity(MAX_EID, "DefaultChild", parentEID);
  }

-  void SHHierarchyPanel::ParentSelectedEntities(EntityID parentEID, std::vector<EntityID> const& entities) const noexcept
+  void SHHierarchyPanel::ParentSelectedEntities(EntityID parentEID, std::vector<EntityID> const& entities) noexcept
  {
    auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
+    
+    std::vector<EntityID> entitiesToParent = CleanUpEIDList(entities);
+    
    //auto const editor = SHSystemManager::GetSystem<SHEditor>();
    SHEntityParentCommand::EntityParentData entityParentData;
    std::vector<EntityID> parentedEIDS;
-    for (auto const& eid : entities)
+    for (auto const& eid : entitiesToParent)
    {
      if(eid == parentEID)
        continue;
@ -411,14 +418,7 @@ namespace SHADE
  void SHHierarchyPanel::CopySelectedEntities()
  {
    const auto editor = SHSystemManager::GetSystem<SHEditor>();
-    auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
-    std::vector<EntityID> entitiesToCopy{};
-    std::ranges::copy_if(editor->selectedEntities, std::back_inserter(entitiesToCopy), [&sceneGraph](EntityID const& eid)
-      {
-        if(sceneGraph.GetParent(eid)->GetEntityID() == MAX_EID)
-          return true;
-        return false;
-      });
+    std::vector<EntityID> entitiesToCopy = CleanUpEIDList(editor->selectedEntities);
    SHClipboardUtilities::WriteToClipboard(SHSerialization::SerializeEntitiesToString(entitiesToCopy));
  }

@ -431,19 +431,25 @@ namespace SHADE
  void SHHierarchyPanel::DeleteSelectedEntities()
  {
    const auto editor = SHSystemManager::GetSystem<SHEditor>();
+    std::vector<EntityID> entitiesToDelete = CleanUpEIDList(editor->selectedEntities);
+    SHCommandManager::PerformCommand(std::make_shared<SHDeleteEntitiesCommand>(entitiesToDelete));
+  }
+
+  std::vector<EntityID> SHHierarchyPanel::CleanUpEIDList(std::vector<EntityID> const& entities)
+  {
+    std::vector<EntityID> result;
    auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();

-    std::vector<EntityID> entitiesToDelete{};
-    std::ranges::copy_if(editor->selectedEntities, std::back_inserter(entitiesToDelete), [&sceneGraph, &selectedEntities = editor->selectedEntities](EntityID const& eid)
+    std::ranges::copy_if(entities, std::back_inserter(result), [&sceneGraph, &entities](EntityID const& eid)
      {
        EntityID parentEID = sceneGraph.GetParent(eid)->GetEntityID();
        if (parentEID == MAX_EID)
          return true;
-        else if(std::ranges::find(selectedEntities, parentEID) == selectedEntities.end())
+        if (std::ranges::find(entities, parentEID) == entities.end())
          return true;
        return false;
      });
-    SHCommandManager::PerformCommand(std::make_shared<SHDeleteEntitiesCommand>(entitiesToDelete));
+    return result;
  }

 }//namespace SHADE
--- a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h
+++ b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h
@ -27,12 +27,13 @@ namespace SHADE
    void DrawMenuBar() const noexcept;
    ImRect RecursivelyDrawEntityNode(SHSceneNode* const);
    void CreateChildEntity(EntityID parentEID) const noexcept;
-    void ParentSelectedEntities(EntityID parentEID, std::vector<EntityID> const& entities) const noexcept;
+    void ParentSelectedEntities(EntityID parentEID, std::vector<EntityID> const& entities) noexcept;
    void SelectRangeOfEntities(EntityID beginEID, EntityID EndEID);
    void SelectAllEntities();
    void CopySelectedEntities();
    void PasteEntities(EntityID parentEID = MAX_EID);
    void DeleteSelectedEntities();
+    std::vector<EntityID> CleanUpEIDList(std::vector<EntityID> const& entities);
    bool skipFrame = false;
    std::string filter;
    bool isAnyNodeSelected = false;
--- a/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp
@ -68,10 +68,10 @@ namespace SHADE
  {
    if (!component)
      return;
+    
    const auto componentType = rttr::type::get<T>();
    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()))
    {
@ -216,6 +216,90 @@ namespace SHADE
      }
    }
    else DrawContextMenu(component);
+    ImGui::PopID();
+
+  }
+
+  template<>
+  static void DrawComponent(SHRigidBodyComponent* component)
+  {
+    if(!component)
+      return;
+    ImGui::PushID(SHFamilyID<SHComponent>::GetID<SHRigidBodyComponent>());
+
+    const auto componentType = rttr::type::get<SHRigidBodyComponent>();
+    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);
+      
+      SHRigidBodyComponent::Type rbType = component->GetType();
+
+      auto enumAlign = rttr::type::get<SHRigidBodyComponent::Type>().get_enumeration();
+      auto names = enumAlign.get_names();
+      std::vector<const char*> list;
+      for (auto const& name : names)
+        list.push_back(name.data());
+      SHEditorWidgets::ComboBox("Type", list, [component] {return static_cast<int>(component->GetType()); }, [component, enumAlign](int const& idx)
+        {
+          auto values = enumAlign.get_values();
+          auto it = std::next(values.begin(), idx);
+          component->SetType((*it).convert<SHRigidBodyComponent::Type>());
+        }, "RigidBody Type");
+      
+      
+      if(rbType == SHRigidBodyComponent::Type::DYNAMIC) //Dynamic only fields
+      {
+        SHEditorWidgets::CheckBox("Use Gravity", [component]{return component->IsGravityEnabled();}, [component](bool const& value){component->SetGravityEnabled(value);}, "Gravity");
+        SHEditorWidgets::DragFloat("Mass", [component] {return component->GetMass(); }, [component](float const& value) {component->SetMass(value); }, "Mass");
+      }
+      if (rbType == SHRigidBodyComponent::Type::DYNAMIC || rbType == SHRigidBodyComponent::Type::KINEMATIC) //Dynamic or Kinematic only fields
+      {
+        SHEditorWidgets::DragFloat("Drag", [component] {return component->GetDrag(); }, [component](float const& value) {component->SetDrag(value); }, "Drag");
+        SHEditorWidgets::DragFloat("Angular Drag", [component] {return component->GetAngularDrag(); }, [component](float const& value) {component->SetAngularDrag(value); }, "Angular Drag");
+
+        SHEditorWidgets::CheckBox("Interpolate", [component] {return component->IsInterpolating(); }, [component](bool const& value) {component->SetInterpolate(value); }, "Interpolate");
+
+        SHEditorWidgets::BeginPanel(std::format("{} Constraints", ICON_FA_LOCK).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y });
+
+        SHEditorWidgets::TextLabel("Freeze Position");
+        SHEditorWidgets::CheckBox("X", [component] {return component->GetFreezePositionX(); }, [component](bool const& value) {component->SetFreezePositionX(value); }, "Freeze Position - X"); ImGui::SameLine();
+        SHEditorWidgets::CheckBox("Y", [component] {return component->GetFreezePositionY(); }, [component](bool const& value) {component->SetFreezePositionY(value); }, "Freeze Position - Y"); ImGui::SameLine();
+        SHEditorWidgets::CheckBox("Z", [component] {return component->GetFreezePositionZ(); }, [component](bool const& value) {component->SetFreezePositionZ(value); }, "Freeze Position - Z");
+
+        SHEditorWidgets::TextLabel("Freeze Rotation");
+        SHEditorWidgets::CheckBox("X", [component] {return component->GetFreezeRotationX(); }, [component](bool const& value) {component->SetFreezeRotationX(value); }, "Freeze Rotation - X"); ImGui::SameLine();
+        SHEditorWidgets::CheckBox("Y", [component] {return component->GetFreezeRotationY(); }, [component](bool const& value) {component->SetFreezeRotationY(value); }, "Freeze Rotation - Y"); ImGui::SameLine();
+        SHEditorWidgets::CheckBox("Z", [component] {return component->GetFreezeRotationZ(); }, [component](bool const& value) {component->SetFreezeRotationZ(value); }, "Freeze Rotation - Z");
+
+        SHEditorWidgets::EndPanel();
+      }
+
+      //Debug Info (Read-Only)
+      if(ImGui::CollapsingHeader("Debug Information", ImGuiTreeNodeFlags_DefaultOpen))//Dynamic or Kinematic only fields
+      {
+        SHEditorWidgets::DragVec3("Position", { "X", "Y", "Z" }, [component] {return component->GetPosition(); }, [](SHVec3 const& value) {}, false, "Position", 0.1f, "%.3f", 0.0f, 0.0f, ImGuiSliderFlags_ReadOnly);
+        SHEditorWidgets::DragVec3("Rotation", { "X", "Y", "Z" }, [component] {return component->GetRotation(); }, [](SHVec3 const& value) {}, false, "Rotation", 0.1f, "%.3f", 0.0f, 0.0f, ImGuiSliderFlags_ReadOnly);
+        if (rbType == SHRigidBodyComponent::Type::DYNAMIC || rbType == SHRigidBodyComponent::Type::KINEMATIC) //Dynamic or Kinematic only fields
+        {
+          SHEditorWidgets::DragVec3("Velocity", { "X", "Y", "Z" }, [component] {return component->GetLinearVelocity(); }, [](SHVec3 const& value) {}, false, "Linear Velocity", 0.1f, "%.3f", 0.0f, 0.0f, ImGuiSliderFlags_ReadOnly);
+          SHEditorWidgets::DragVec3("Angular\nVelocity", { "X", "Y", "Z" }, [component] {return component->GetAngularVelocity(); }, [](SHVec3 const& value) {}, false, "Angular Velocity", 0.1f, "%.3f", 0.0f, 0.0f, ImGuiSliderFlags_ReadOnly);
+        }
+        if (rbType == SHRigidBodyComponent::Type::DYNAMIC) //Dynamic only fields
+        {
+          SHEditorWidgets::DragVec3("Force", { "X", "Y", "Z" }, [component] {return component->GetForce(); }, [](SHVec3 const& value) {}, false, "Force", 0.1f, "%.3f", 0.0f, 0.0f, ImGuiSliderFlags_ReadOnly);
+          SHEditorWidgets::DragVec3("Torque", { "X", "Y", "Z" }, [component] {return component->GetTorque(); }, [](SHVec3 const& value) {}, false, "Torque", 0.1f, "%.3f", 0.0f, 0.0f, ImGuiSliderFlags_ReadOnly);
+          SHEditorWidgets::CheckBox("Is Asleep", [component] {return component->GetIsSleeping(); }, [](bool value) {}, "If the Rigid Body is asleep");
+        } 
+      }
+
+    }
+    else
+    {
+      DrawContextMenu(component);
+    }
+    ImGui::PopID();
  }

  template<>
@ -223,6 +307,7 @@ namespace SHADE
  {
    if (!component)
      return;
+    ImGui::PushID(SHFamilyID<SHComponent>::GetID<SHColliderComponent>());

    const auto componentType = rttr::type::get(*component);
    SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active");
@ -246,7 +331,7 @@ namespace SHADE
        if (collider->GetType() == SHCollisionShape::Type::BOX)
        {
          SHEditorWidgets::BeginPanel(std::format("{} Box #{}", ICON_FA_CUBE, i).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y });
-          const auto* BOX = reinterpret_cast<const SHBoundingBox*>(collider->GetShape());
+          const auto* BOX = reinterpret_cast<const SHBox*>(collider->GetShape());
          SHEditorWidgets::DragVec3
          (
            "Half Extents", { "X", "Y", "Z" },
@ -256,7 +341,7 @@ namespace SHADE
        else if (collider->GetType() == SHCollisionShape::Type::SPHERE)
        {
          SHEditorWidgets::BeginPanel(std::format("{} Sphere #{}", ICON_MD_CIRCLE, i).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y });
-          const auto* SPHERE = reinterpret_cast<const SHBoundingSphere*>(collider->GetShape());
+          const auto* SPHERE = reinterpret_cast<const SHSphere*>(collider->GetShape());
          SHEditorWidgets::DragFloat
          (
            "Radius",
@ -275,21 +360,12 @@ namespace SHADE
          [&collider]
          {
            auto offset = collider->GetRotationOffset();
-            offset.x = SHMath::RadiansToDegrees(offset.x);
-            offset.y = SHMath::RadiansToDegrees(offset.y);
-            offset.z = SHMath::RadiansToDegrees(offset.z);
            return offset;
          }, 
          [&collider](SHVec3 const& vec)
          {
-            const SHVec3 vecInRad
-            {
-              SHMath::DegreesToRadians(vec.x)
-            , SHMath::DegreesToRadians(vec.y)
-            , SHMath::DegreesToRadians(vec.z)
-            };
-            collider->SetRotationOffset(vecInRad);
-          });
+            collider->SetRotationOffset(vec);
+          }, true);
          SHEditorWidgets::EndPanel();
        }

@ -322,6 +398,7 @@ namespace SHADE
      }
    }
    else DrawContextMenu(component);
+    ImGui::PopID();
  }

  template<>
@ -329,6 +406,7 @@ namespace SHADE
  {
    if (!component)
      return;
+    ImGui::PushID(SHFamilyID<SHComponent>::GetID<SHLightComponent>());
    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();
@ -352,6 +430,7 @@ namespace SHADE
    {
      DrawContextMenu(component);
    }
+    ImGui::PopID();
  }

  template<>
@ -359,6 +438,7 @@ namespace SHADE
  {
    if (!component)
      return;
+    ImGui::PushID(SHFamilyID<SHComponent>::GetID<SHRenderable>());
    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();
@ -367,27 +447,39 @@ namespace SHADE
      DrawContextMenu(component);
      Handle<SHMesh> const& mesh = component->GetMesh();
      Handle<SHMaterialInstance> const& mat = component->GetMaterial();
-
-      SHEditorWidgets::DragDropReadOnlyField<AssetID>("Mesh", std::to_string(SHResourceManager::GetAssetID<SHMesh>(mesh).value_or(0)).data(), [component]()
+      const auto MESH_NAME = SHResourceManager::GetAssetName<SHMesh>(mesh).value_or("");
+      SHEditorWidgets::DragDropReadOnlyField<AssetID>("Mesh", MESH_NAME, [component]()
      {
        Handle<SHMesh> const& mesh = component->GetMesh();
        return SHResourceManager::GetAssetID<SHMesh>(mesh).value_or(0);
      },
        [component](AssetID const& id)
        {
+          if(SHAssetManager::GetType(id) != AssetType::MESH)
+          {
+            SHLOG_WARNING("Attempted to assign non mesh asset to Renderable Mesh property!")
+            return;
+          }
          component->SetMesh(SHResourceManager::LoadOrGet<SHMesh>(id));
          SHResourceManager::FinaliseChanges();
        }, SHDragDrop::DRAG_RESOURCE);

-      SHEditorWidgets::DragDropReadOnlyField<AssetID>("Material", mat ? std::to_string(SHResourceManager::GetAssetID<SHMaterial>(mat->GetBaseMaterial()).value_or(0)).data() : "", [component]()
+      const auto MAT_NAME = mat ? SHResourceManager::GetAssetName<SHMaterial>(mat->GetBaseMaterial()).value_or("") : "";
+      SHEditorWidgets::DragDropReadOnlyField<AssetID>("Material", MAT_NAME,
+        [component]()
        {
          Handle<SHMaterialInstance> const& mat = component->GetMaterial();
-        if(!mat)
+          if (!mat)
            return static_cast<AssetID>(0);
          return SHResourceManager::GetAssetID<SHMaterial>(mat->GetBaseMaterial()).value_or(0);
        },
        [component](AssetID const& id)
        {
+        if (SHAssetManager::GetType(id) != AssetType::MATERIAL)
+        {
+          SHLOG_WARNING("Attempted to assign non material asset to Renderable Mesh property!")
+            return;
+        }
          auto gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
          component->SetMaterial(gfxSystem->AddOrGetBaseMaterialInstance(SHResourceManager::LoadOrGet<SHMaterial>(id)));
        }, SHDragDrop::DRAG_RESOURCE);
@ -396,5 +488,6 @@ namespace SHADE
    {
      DrawContextMenu(component);
    }
+    ImGui::PopID();
  }
 }
--- a/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorInspector.cpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorInspector.cpp
@ -18,7 +18,10 @@
 #include "Physics/Interface/SHColliderComponent.h"
 #include "Camera/SHCameraComponent.h"
 #include "Camera/SHCameraArmComponent.h"
+#include "UI/SHUIComponent.h"
+#include "UI/SHCanvasComponent.h"
 #include "SHEditorComponentView.h"
+#include "AudioSystem/SHAudioListenerComponent.h"

 namespace SHADE
 {
@ -128,10 +131,19 @@ namespace SHADE
        if (auto cameraComponent = SHComponentManager::GetComponent_s<SHCameraComponent>(eid))
        {
          DrawComponent(cameraComponent);
-        }if (auto cameraArmComponent = SHComponentManager::GetComponent_s<SHCameraArmComponent>(eid))
+        }
+        if (auto cameraArmComponent = SHComponentManager::GetComponent_s<SHCameraArmComponent>(eid))
        {
          DrawComponent(cameraArmComponent);
        }
+        if (auto canvasComponent= SHComponentManager::GetComponent_s<SHCanvasComponent>(eid))
+        {
+          DrawComponent(canvasComponent);
+        }
+        if (auto uiComponent = SHComponentManager::GetComponent_s<SHUIComponent>(eid))
+        {
+          DrawComponent(uiComponent);
+        }
        ImGui::Separator();
        // Render Scripts
        SHScriptEngine* scriptEngine = static_cast<SHScriptEngine*>(SHSystemManager::GetSystem<SHScriptEngine>());
@ -143,6 +155,7 @@ namespace SHADE
          DrawAddComponentButton<SHCameraComponent>(eid);
          DrawAddComponentButton<SHCameraArmComponent>(eid);
          DrawAddComponentButton<SHLightComponent>(eid);
+          DrawAddComponentButton<SHCanvasComponent>(eid);

          // Components that require Transforms

--- a/SHADE_Engine/src/Editor/EditorWindow/MaterialInspector/SHMaterialInspector.cpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/MaterialInspector/SHMaterialInspector.cpp
@ -78,7 +78,26 @@ namespace SHADE
      ImGui::BeginDisabled(!isDirty);
      if(ImGui::Button(std::format("{} Save", ICON_MD_SAVE).data()))
      {
-        //save
+        auto gfxSystem  = SHSystemManager::GetSystem<SHGraphicsSystem>();
+        // Replace Material if it's been instantiated
+        auto matHandle = SHResourceManager::Get<SHMaterial>(currentViewedMaterial);
+        if (matHandle)
+        {
+          // - Get Shader Modules
+          auto vertShader = SHResourceManager::LoadOrGet<SHVkShaderModule>(currentMatSpec->vertexShader);
+          auto fragShader = SHResourceManager::LoadOrGet<SHVkShaderModule>(currentMatSpec->fragShader);
+          if (vertShader && fragShader && gfxSystem)
+          {
+            // - Retrieve pipeline from pipeline library
+            auto renderPass = gfxSystem->GetPrimaryRenderpass();
+            auto subPass = renderPass->GetSubpass(currentMatSpec->subpassName);
+            auto pipeline = renderPass->GetOrCreatePipeline({ vertShader, fragShader }, subPass);
+            // - Set Pipeline
+            matHandle->SetPipeline(pipeline);
+          }
+        }
+
+        // Save Properties
        if(auto matAsset = SHAssetManager::GetData<SHMaterialAsset>(currentViewedMaterial))
        {
          YAML::Emitter out;
@ -102,7 +121,20 @@ namespace SHADE
                currentMaterial->SetProperty(VARIABLE->offset, PROP_NODE.as<float>());
                break;
              case SHADE::SHShaderBlockInterface::Variable::Type::INT:
-                currentMaterial->SetProperty(VARIABLE->offset, PROP_NODE.as<int>());
+              {
+                Handle<SHTexture> texture = SHResourceManager::LoadOrGet<SHTexture>(PROP_NODE.as<int>());
+                // HACK: Need to split this out to a separate pass before loading the materials and subsequently, the scenes
+                gfxSystem->BuildTextures();
+                if (texture)
+                {
+                  matHandle->SetProperty(VARIABLE->offset, texture->TextureArrayIndex);
+                }
+                else
+                {
+                  SHLOG_WARNING("[] Attempted to load invalid texture! Setting to 0.");
+                  matHandle->SetProperty(VARIABLE->offset, 0);
+                }
+              }
                break;
              case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR2:
                currentMaterial->SetProperty(VARIABLE->offset, PROP_NODE.as<SHVec2>());
@ -136,12 +168,38 @@ namespace SHADE
  {
    /*if(!shaderModule)
      return;*/
-    auto gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
-    auto interface = gfxSystem->GetDefaultMaterialInstance()->GetBaseMaterial()->GetShaderBlockInterface();
    //auto interface = shaderModule->GetReflectedData().GetDescriptorBindingInfo().GetShaderBlockInterface(SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE, SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA);

-    int const varCount = static_cast<int>(interface->GetVariableCount());
+    // Shader
+    bool shaderChanged = false;
+    const auto* SHADER_INFO = SHAssetManager::GetData<SHShaderAsset>(currentMatSpec->fragShader);
+    const std::string SHADER_NAME = SHADER_INFO ? SHADER_INFO->name : "Unknown Shader";
+    ImGui::BeginDisabled();
+    isDirty |= SHEditorWidgets::DragDropReadOnlyField<AssetID>
+    (
+      "Fragment Shader", SHADER_NAME.data(),
+      [this]() { return currentMatSpec->fragShader; }, 
+      [this](const AssetID& id) { currentMatSpec->fragShader = id; },
+      SHDragDrop::DRAG_RESOURCE
+    );
+    ImGui::EndDisabled();

+    // Load the shader to access it's data
+    auto fragShader = SHResourceManager::LoadOrGet<SHVkShaderModule>(currentMatSpec->fragShader);
+    if (!fragShader)
+      return;
+
+    // Get interface for the shader combination
+    auto interface = fragShader->GetReflectedData().GetDescriptorBindingInfo().GetShaderBlockInterface
+    (
+      SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE,
+      SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA
+    );
+    if (!interface)
+      return;
+
+    // Properties
+    int const varCount = static_cast<int>(interface->GetVariableCount());
    for (int i = 0; i < varCount; ++i)
    {
      auto variable = interface->GetVariable(i);
--- a/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp
@ -221,13 +221,20 @@ namespace SHADE
      ImGui::BeginDisabled(editor->editorState == SHEditor::State::PLAY);
      if(ImGui::SmallButton(ICON_MD_PLAY_ARROW))
      {
-        if(editor->SaveScene())
+        if(editor->editorState == SHEditor::State::STOP)
+        {
+          if (editor->SaveScene())
+          {
+            editor->Play();
+          }
+        }
+        else
        {
          editor->Play();
        }
      }
      ImGui::EndDisabled();
-      ImGui::BeginDisabled(editor->editorState == SHEditor::State::PAUSE);
+      ImGui::BeginDisabled(editor->editorState == SHEditor::State::STOP || editor->editorState == SHEditor::State::PAUSE);
      if(ImGui::SmallButton(ICON_MD_PAUSE))
      {
        editor->Pause();
--- a/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowManager.h
+++ b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowManager.h
@ -3,7 +3,7 @@
 #include <memory>
 #include <unordered_map>
 #include "SHEditorWindow.h"
-#include "Tools/SHLog.h"
+#include "Tools/Logger/SHLog.h"

 namespace SHADE
 {
--- a/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.cpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.cpp
@ -14,6 +14,7 @@

 #include "Camera/SHCameraSystem.h"
 #include "FRC/SHFramerateController.h"
+#include "../../SHEditorWidgets.hpp"

 constexpr std::string_view windowName = "\xef\x80\x95 Viewport";

@ -85,7 +86,7 @@ namespace SHADE

      shouldUpdateCamArm = ImGui::IsWindowHovered() && ImGui::IsKeyDown(ImGuiKey_LeftAlt) && ImGui::IsMouseDown(ImGuiMouseButton_Left);
      
-      if (editor->editorState != SHEditor::State::PLAY && ImGui::IsWindowFocused() && !ImGui::IsMouseDown(ImGuiMouseButton_Right))
+      if (editor->editorState != SHEditor::State::PLAY && !ImGui::IsAnyItemActive() && !ImGui::IsMouseDown(ImGuiMouseButton_Right))
      {
        if (ImGui::IsKeyReleased(ImGuiKey_W))
        {
@ -151,7 +152,7 @@ namespace SHADE
      if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
      {
        ImGui::BeginTooltip();
-        ImGui::Text("Translate [Q]");
+        ImGui::Text("Translate [W]");
        ImGui::EndTooltip();
      }
      if (isTranslate)
@ -169,7 +170,7 @@ namespace SHADE
      if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
      {
        ImGui::BeginTooltip();
-        ImGui::Text("Rotate [W]");
+        ImGui::Text("Rotate [E]");
        ImGui::EndTooltip();
      }
      if (isRotate)
@ -187,12 +188,19 @@ namespace SHADE
      if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
      {
        ImGui::BeginTooltip();
-        ImGui::Text("Scale [E]");
+        ImGui::Text("Scale [R]");
        ImGui::EndTooltip();
      }
      if (isScale)
        ImGui::PopStyleColor();
      ImGui::EndDisabled();
+
+      auto camSystem = SHSystemManager::GetSystem<SHCameraSystem>();
+      auto editorCamera = camSystem->GetEditorCamera();
+      //ImGui::SetNextItemWidth(10.0f);
+      SHEditorWidgets::SliderFloat("CamSpeed", 0.0f, 5.0f, [editorCamera] {return editorCamera->movementSpeed; }, [editorCamera](float const& value) {editorCamera->movementSpeed = value; });
+      SHEditorWidgets::DragVec3("TurnSpeed", { "X", "Y", "Z" }, [editorCamera] {return editorCamera->turnSpeed; }, [editorCamera](SHVec3 const& value) {editorCamera->turnSpeed = value; });
+
      ImGui::EndMenuBar();
    }
  }
--- a/SHADE_Engine/src/Editor/SHEditor.cpp
+++ b/SHADE_Engine/src/Editor/SHEditor.cpp
@ -10,7 +10,7 @@
 //#==============================================================#
 //||                       SHADE Includes                       ||
 //#==============================================================#
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "Tools/SHException.h"

 #include "ECS_Base/Managers/SHSystemManager.h"
--- a/SHADE_Engine/src/Editor/SHEditor.h
+++ b/SHADE_Engine/src/Editor/SHEditor.h
@ -15,7 +15,7 @@
 #include "ECS_Base/System/SHSystemRoutine.h"
 #include "Resource/SHHandle.h"
 #include "EditorWindow/SHEditorWindow.h"
-#include "Tools/SHLog.h"
+#include "Tools/Logger/SHLog.h"
 #include "Gizmos/SHTransformGizmo.h"
 #include "Events/SHEventDefines.h"
 #include "Events/SHEvent.h"
--- a/SHADE_Engine/src/Editor/SHEditorWidgets.hpp
+++ b/SHADE_Engine/src/Editor/SHEditorWidgets.hpp
@ -166,14 +166,14 @@ namespace SHADE
      const ImGuiWindow* const window = ImGui::GetCurrentWindow();
      if (window->SkipItems)
        return false;
-
+      static constexpr float defaultLabelColWidth = 80.0f;
      const ImGuiContext& g = *GImGui;
      bool valueChanged = false;
      ImGui::BeginGroup();
      ImGui::PushID(label.c_str());
      PushMultiItemsWidthsAndLabels(componentLabels, 0.0f);
      ImGui::BeginColumns("DragVecCol", 2, ImGuiOldColumnFlags_NoBorder | ImGuiOldColumnFlags_NoResize);
-      ImGui::SetColumnWidth(-1, 80.0f);
+      ImGui::SetColumnWidth(-1, defaultLabelColWidth);
      ImGui::Text(label.c_str());
      if (isHovered)
        *isHovered |= ImGui::IsItemHovered();
@ -219,7 +219,7 @@ namespace SHADE
      }
      bool const changed = DragN<float, 2>(label, componentLabels, { &values.x, &values.y }, speed, displayFormat, valueMin, valueMax, flags);
      static bool startRecording = false;
-      if (changed)
+      if (!(flags & ImGuiSliderFlags_ReadOnly) && changed)
      {
        if(isAnAngleInRad)
        {
@ -255,7 +255,7 @@ namespace SHADE
      bool isHovered = false;
      bool const changed = DragN<float, 3>(label, componentLabels, { &values.x, &values.y, &values.z }, speed, displayFormat, valueMin, valueMax, flags, &isHovered);
      static bool startRecording = false;
-      if (changed)
+      if (!(flags & ImGuiSliderFlags_ReadOnly) && changed)
      {
        SHVec3 old = get();
        if(isAnAngleInRad)
@ -293,7 +293,7 @@ namespace SHADE
      }
      bool const changed = DragN<float, 4>(label, componentLabels, { &values.x, &values.y, &values.z, &values.w }, speed, displayFormat, valueMin, valueMax, flags);
      static bool startRecording = false;
-      if (changed)
+      if (!(flags & ImGuiSliderFlags_ReadOnly) && changed)
      {
        if(isAnAngleInRad)
        {
@ -422,7 +422,7 @@ namespace SHADE
      ImGui::BeginGroup();
      ImGui::PushID(label.data());
      TextLabel(label);
-      bool changed = ImGui::InputText("##", &text, ImGuiInputTextFlags_ReadOnly, nullptr, nullptr);
+      bool changed = ImGui::InputText("##inputText", &text, ImGuiInputTextFlags_ReadOnly, nullptr, nullptr);
      if(SHDragDrop::BeginTarget())
      {
        if(T* payload = SHDragDrop::AcceptPayload<T>(dragDropTag))
@ -454,7 +454,7 @@ namespace SHADE
      ImGui::BeginGroup();
      ImGui::PushID(label.data());
      TextLabel(label);
-      const bool hasChange = ImGui::DragScalar("##", data_type, &value, speed, &p_min, &p_max, displayFormat, flags);
+      const bool hasChange = ImGui::DragScalar("##dragScalar", data_type, &value, speed, &p_min, &p_max, displayFormat, flags);
      static bool startRecording = false;
      if (hasChange)
      {
@ -487,7 +487,7 @@ namespace SHADE
      ImGui::BeginGroup();
      ImGui::PushID(label.data());
      TextLabel(label);
-      const bool hasChange = ImGui::DragFloat("##", &value, speed, p_min, p_max, displayFormat, flags);
+      const bool hasChange = ImGui::DragFloat("##dragFloat", &value, speed, p_min, p_max, displayFormat, flags);
      static bool startRecording = false;
      if (hasChange)
      {
@ -520,7 +520,7 @@ namespace SHADE
      ImGui::BeginGroup();
      ImGui::PushID(label.data());
      TextLabel(label);
-      const bool hasChange = ImGui::DragInt("##", &value, speed, p_min, p_max, displayFormat, flags);
+      const bool hasChange = ImGui::DragInt("##dragInt", &value, speed, p_min, p_max, displayFormat, flags);
      static bool startRecording = false;
      if (hasChange)
      {
@ -553,7 +553,7 @@ namespace SHADE
      ImGui::BeginGroup();
      ImGui::PushID(label.data());
      TextLabel(label);
-      bool const hasChange = ImGui::SliderScalar("##", data_type, &value, &min, &max, displayFormat, flags);
+      bool const hasChange = ImGui::SliderScalar("##sliderScalar", data_type, &value, &min, &max, displayFormat, flags);
      static bool startRecording = false;
      if (hasChange)
      {
@ -587,7 +587,8 @@ namespace SHADE
      ImGui::BeginGroup();
      ImGui::PushID(label.data());
      TextLabel(label);
-      bool const hasChange = ImGui::SliderFloat("##", &value, min, max, displayFormat, flags);
+      ImGui::SetNextItemWidth(ImGui::CalcTextSize(displayFormat).x + ImGui::GetStyle().ItemInnerSpacing.x * 2.0f);
+      bool const hasChange = ImGui::SliderFloat("##sliderFloat", &value, min, max, displayFormat, flags);
      static bool startRecording = false;
      if (hasChange)
      {
@ -621,7 +622,7 @@ namespace SHADE
      ImGui::BeginGroup();
      ImGui::PushID(label.data());
      TextLabel(label);
-      bool const hasChange = ImGui::SliderInt("##", &value, min, max, displayFormat, flags);
+      bool const hasChange = ImGui::SliderInt("##sliderInt", &value, min, max, displayFormat, flags);
      static bool startRecording = false;
      if (hasChange)
      {
--- a/SHADE_Engine/src/FRC/SHFramerateController.cpp
+++ b/SHADE_Engine/src/FRC/SHFramerateController.cpp
@ -12,11 +12,11 @@

 //TODO Legacy code. Delete soon

+#include <SHpch.h>
+
 #include <chrono>
 #include <cassert>
-#include <SHpch.h>
 #include "SHFramerateController.h"
-#include "../Tools/SHLogger.h"

 namespace SHADE
 {
--- a/SHADE_Engine/src/Filesystem/SHFileSystem.cpp
+++ b/SHADE_Engine/src/Filesystem/SHFileSystem.cpp
@ -130,6 +130,14 @@ namespace SHADE
 				}

        // If item is folder
+        if (path.stem().string() == "bin"
+          || path.stem().string() == "obj"
+          || !std::filesystem::exists(path))
+        {
+          SHLOG_INFO("[FileSystem] Skipped paths in directory building: {}", path.string());
+          continue;
+        }
+
        auto newFolder{ folder->CreateSubFolderHere(path.stem().string()) };
        folderStack.push(newFolder);
 			}
@ -143,8 +151,11 @@ namespace SHADE

        bool found{ false };
        for (auto const& asset : assets)
+        {
+          if (!assetCollection.contains(asset.id))
          {
            assetCollection.emplace(asset.id, asset);
+          }
          if (file.name == asset.name)
          {
            AssetPath path{ file.path };
@ -162,22 +173,6 @@ namespace SHADE
          toGenerate.push_back(&file);
        }
      }
-      //for (auto const& asset : assets)
-      //{
-      //  assetCollection.emplace(asset.id, asset);
-      //  for(auto& file : folder->files)
-      //  {
-      //    if (file.name == asset.name)
-      //    {
-      //      AssetPath path{ file.path };
-      //      if (SHAssetMetaHandler::GetTypeFromExtension(path.extension().string()) == asset.type)
-      //      {
-      //        file.assetMeta = &assetCollection[asset.id];
-      //        break;
-      //      }
-      //    }
-      //  }
-      //}

      for (auto i {0}; i < folder->files.size(); ++i)
      {
--- a/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp
+++ b/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp
@ -3,7 +3,7 @@
 #include "SHVkCommandPool.h"
 #include "Graphics/Devices/SHVkLogicalDevice.h"
 #include "SHVkCommandPool.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "Graphics/Renderpass/SHVkRenderpass.h"
 #include "Graphics/Framebuffer/SHVkFramebuffer.h"
 #include "Graphics/Pipeline/SHVkPipeline.h"
--- a/SHADE_Engine/src/Graphics/Commands/SHVkCommandPool.cpp
+++ b/SHADE_Engine/src/Graphics/Commands/SHVkCommandPool.cpp
@ -3,7 +3,7 @@
 #include "Graphics/Devices/SHVkLogicalDevice.h"
 #include "Graphics/Instance/SHVkInstance.h"
 #include "Resource/SHResourceLibrary.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"

 namespace SHADE
 {
--- a/SHADE_Engine/src/Graphics/Debugging/SHValidationLayersQuery.cpp
+++ b/SHADE_Engine/src/Graphics/Debugging/SHValidationLayersQuery.cpp
@ -1,6 +1,6 @@
 #include "SHPch.h"
 #include "SHValidationLayersQuery.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"

 namespace SHADE
 {
--- a/SHADE_Engine/src/Graphics/Debugging/SHVkDebugMessenger.cpp
+++ b/SHADE_Engine/src/Graphics/Debugging/SHVkDebugMessenger.cpp
@ -3,8 +3,8 @@
 #include "SHVkDebugMessenger.h"
 #include "SHVulkanDebugUtil.h"
 #include "Graphics/Instance/SHVkInstance.h"
-#include "Tools/SHLogger.h"
-//#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
+//#include "Tools/Logger/SHLogger.h"

 namespace SHADE
 {
--- a/SHADE_Engine/src/Graphics/Debugging/SHVulkanDebugUtil.cpp
+++ b/SHADE_Engine/src/Graphics/Debugging/SHVulkanDebugUtil.cpp
@ -1,6 +1,6 @@
 #include "SHPch.h"
 #include "SHVulkanDebugUtil.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"

 namespace SHADE
 {
--- a/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorPool.h
+++ b/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorPool.h
@ -38,11 +38,11 @@ namespace SHADE
            /// </summary>
            std::vector<vk::DescriptorPoolSize> Limits =
            {
-                { vk::DescriptorType::eCombinedImageSampler, 100 },
-                { vk::DescriptorType::eUniformBuffer, 100 },
-                { vk::DescriptorType::eUniformBufferDynamic, 100 },
-                { vk::DescriptorType::eStorageImage, 100},
-                { vk::DescriptorType::eStorageBufferDynamic, 100 }
+                { vk::DescriptorType::eCombinedImageSampler, 1000 },
+                { vk::DescriptorType::eUniformBuffer, 1000 },
+                { vk::DescriptorType::eUniformBufferDynamic, 1000 },
+                { vk::DescriptorType::eStorageImage, 1000 },
+                { vk::DescriptorType::eStorageBufferDynamic, 1000 }
            };
            /// <summary>
            /// Maximum number of descriptor sets allowed
--- a/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetGroup.cpp
+++ b/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetGroup.cpp
@ -6,7 +6,7 @@
 #include "SHVkDescriptorPool.h"
 #include "Graphics/Devices/SHVkLogicalDevice.h"
 #include "Graphics/Descriptors/SHVkDescriptorSetLayout.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "Graphics/Images/SHVkImage.h"
 #include "Graphics/Images/SHVkImageView.h"
 #include "Graphics/Images/SHVkSampler.h"
--- a/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp
+++ b/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp
@ -2,7 +2,7 @@
 #include "SHVkLogicalDevice.h"
 #include "SHVkPhysicalDevice.h"
 #include "Graphics/Instance/SHVkInstance.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "Graphics/Windowing/Surface/SHVkSurface.h"
 #include "Graphics/Swapchain/SHVkSwapchain.h"
 #include "Graphics/Commands/SHVkCommandPool.h"
--- a/SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDevice.cpp
+++ b/SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDevice.cpp
@ -3,7 +3,7 @@
 #include <iostream>
 #include <vector>
 #include <set>
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"

 namespace SHADE
 {
--- a/SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDeviceLibrary.cpp
+++ b/SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDeviceLibrary.cpp
@ -3,7 +3,7 @@
 #include <unordered_map>
 #include "SHVkPhysicalDeviceLibrary.h"
 #include "Graphics/Instance/SHVkInstance.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"

 namespace SHADE
 {
--- a/SHADE_Engine/src/Graphics/Framebuffer/SHVkFramebuffer.cpp
+++ b/SHADE_Engine/src/Graphics/Framebuffer/SHVkFramebuffer.cpp
@ -3,7 +3,7 @@
 #include "Graphics/Images/SHVkImageView.h"
 #include "Graphics/Images/SHVkImage.h"
 #include "Graphics/Renderpass/SHVkRenderpass.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "Graphics/Devices/SHVkLogicalDevice.h"

 namespace SHADE
--- a/SHADE_Engine/src/Graphics/Images/SHVkImage.cpp
+++ b/SHADE_Engine/src/Graphics/Images/SHVkImage.cpp
@ -2,7 +2,7 @@
 #include "SHVkImage.h"
 #include "Graphics/Devices/SHVkLogicalDevice.h"
 #include "Graphics/Debugging/SHVulkanDebugUtil.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "SHVkImageView.h"
 #include "Graphics/Instance/SHVkInstance.h"
 #include "Graphics/Buffers/SHVkBuffer.h"
--- a/SHADE_Engine/src/Graphics/Images/SHVkImageView.cpp
+++ b/SHADE_Engine/src/Graphics/Images/SHVkImageView.cpp
@ -2,7 +2,7 @@
 #include "SHVkImageView.h"
 #include "SHVkImage.h"
 #include "Graphics/Devices/SHVkLogicalDevice.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"

 namespace SHADE
 {
--- a/SHADE_Engine/src/Graphics/Instance/SHVkInstance.cpp
+++ b/SHADE_Engine/src/Graphics/Instance/SHVkInstance.cpp
@ -3,7 +3,7 @@
 #include "Graphics/Debugging/SHValidationLayersQuery.h"
 #include "Graphics/Debugging/SHVkDebugMessenger.h"
 #include "Graphics/Devices/SHVkPhysicalDeviceLibrary.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "Graphics/Devices/SHVkPhysicalDeviceLibrary.h"
 //#include <vulkan/vulkan_win32.h>

--- a/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.cpp
@ -44,6 +44,85 @@ namespace SHADE
    setAllDirtyFlags();
  }

+  SHBatch::SHBatch(SHBatch&& rhs)
+  : device                   { rhs.device                              }
+  , pipeline                 { rhs.pipeline                            }
+  , referencedMatInstances   { std::move(rhs.referencedMatInstances)   }
+  , matBufferDirty           { std::move(rhs.matBufferDirty)           }
+  , subBatches               { std::move(rhs.subBatches)               }
+  , drawData                 { std::move(drawData)                     }
+  , transformData            { std::move(rhs.transformData)            }
+  , instancedIntegerData     { std::move(rhs.instancedIntegerData)     }
+  , matPropsData             { std::move(rhs.matPropsData)             }
+  , matPropsDataSize         { rhs.matPropsDataSize                    }
+  , singleMatPropAlignedSize { rhs.singleMatPropAlignedSize            }
+  , singleMatPropSize        { rhs.singleMatPropSize                   }
+  , isCPUBuffersDirty        { rhs.isCPUBuffersDirty                   }
+  , drawDataBuffer           { rhs.drawDataBuffer                      }
+  , transformDataBuffer      { rhs.transformDataBuffer                 }
+  , instancedIntegerBuffer   { rhs.instancedIntegerBuffer              }
+  , matPropsBuffer           { rhs.matPropsBuffer                      }
+  , matPropsDescSet          { rhs.matPropsDescSet                     }
+  {
+    rhs.drawDataBuffer         = {};
+    rhs.transformDataBuffer    = {};
+    rhs.instancedIntegerBuffer = {};
+    rhs.matPropsBuffer         = {};
+    rhs.matPropsDescSet        = {};
+  }
+
+  SHBatch& SHBatch::operator=(SHBatch&& rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    device                   = rhs.device                           ;
+    pipeline                 = rhs.pipeline                         ;
+    referencedMatInstances   = std::move(rhs.referencedMatInstances);
+    matBufferDirty           = std::move(rhs.matBufferDirty)        ;
+    subBatches               = std::move(rhs.subBatches)            ;
+    drawData                 = std::move(drawData)                  ;
+    transformData            = std::move(rhs.transformData)         ;
+    instancedIntegerData     = std::move(rhs.instancedIntegerData)  ;
+    matPropsData             = std::move(rhs.matPropsData)          ;
+    matPropsDataSize         = rhs.matPropsDataSize                 ;
+    singleMatPropAlignedSize = rhs.singleMatPropAlignedSize         ;
+    singleMatPropSize        = rhs.singleMatPropSize                ;
+    isCPUBuffersDirty        = rhs.isCPUBuffersDirty                ;
+    drawDataBuffer           = rhs.drawDataBuffer                   ;
+    transformDataBuffer      = rhs.transformDataBuffer              ;
+    instancedIntegerBuffer   = rhs.instancedIntegerBuffer           ;
+    matPropsBuffer           = rhs.matPropsBuffer                   ;
+    matPropsDescSet          = rhs.matPropsDescSet                  ;
+
+    // Unset values
+    rhs.drawDataBuffer         = {};
+    rhs.transformDataBuffer    = {};
+    rhs.instancedIntegerBuffer = {};
+    rhs.matPropsBuffer         = {};
+    rhs.matPropsDescSet        = {};
+
+    return *this;
+  }
+
+  SHBatch::~SHBatch()
+  {
+    // Free GPU buffers
+    for (int i = 0; i < SHGraphicsConstants::NUM_FRAME_BUFFERS; ++i)
+    {
+      if (drawDataBuffer[i])
+        drawDataBuffer[i].Free();
+      if (transformDataBuffer[i])
+        transformDataBuffer[i].Free();
+      if (instancedIntegerBuffer[i])
+        instancedIntegerBuffer[i].Free();
+      if (matPropsBuffer[i])
+        matPropsBuffer[i].Free();
+      if (matPropsDescSet[i])
+        matPropsDescSet[i].Free();
+    }
+  }
+
  void SHBatch::Add(const SHRenderable* renderable)
  {
    // Ignore if null
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.h
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.h
@ -71,6 +71,11 @@ namespace SHADE
        /* Constructor/Destructors                                                     */
        /*-----------------------------------------------------------------------------*/
        SHBatch(Handle<SHVkPipeline> pipeline);
+        SHBatch(const SHBatch&) = delete;
+        SHBatch(SHBatch&& rhs);
+        SHBatch& operator=(const SHBatch&) = delete;
+        SHBatch& operator=(SHBatch&& rhs);
+        ~SHBatch();

        /*-----------------------------------------------------------------------------*/
        /* Usage Functions                                                             */
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatcher.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatcher.cpp
@ -22,7 +22,7 @@ of DigiPen Institute of Technology is prohibited.
 #include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h"
 #include "Graphics/Pipeline/SHVkPipeline.h"
 #include "ECS_Base/Managers/SHComponentManager.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"

 namespace SHADE
 {
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHSuperBatch.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHSuperBatch.cpp
@ -69,9 +69,9 @@ namespace SHADE

    batch->Remove(renderable);

-    // If batch is empty, remove batch
-    if (batch->IsEmpty())
-      batches.erase(batch);
+    // TODO: If the pipeline is unloaded, we remove the batch
+    /*if (batch->IsEmpty() && !batch->GetPipeline())
+      batches.erase(batch);*/
  }

  void SHSuperBatch::Clear() noexcept
--- a/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.cpp
@ -5,7 +5,7 @@
 #include "Graphics/Pipeline/SHVkPipelineLayout.h"
 #include "Graphics/Descriptors/SHVkDescriptorSetLayout.h"
 #include "Graphics/MiddleEnd/Lights/SHLightData.h"
-#include "Tools/SHUtilities.h"
+#include "Tools/Utilities/SHUtilities.h"

 namespace SHADE
 {
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp
@ -570,13 +570,6 @@ namespace SHADE
      return;
    }

-    // Finalise all batches
-    for (auto vp : viewports)
-    for (auto renderer : vp->GetRenderers())
-    {
-      renderer->GetRenderGraph()->FinaliseBatch(renderContext.GetCurrentFrame(), descPool);
-    }
-
    // Resize
    auto windowDims = window->GetWindowSize();
    if (renderContext.GetResizeAndReset())
@ -591,6 +584,13 @@ namespace SHADE
    // #BackEndTest: For for the fence initialized by queue submit
    renderContext.WaitForFence();

+    // Finalise all batches
+    for (auto vp : viewports)
+    for (auto renderer : vp->GetRenderers())
+    {
+      renderer->GetRenderGraph()->FinaliseBatch(renderContext.GetCurrentFrame(), descPool);
+    }
+
    // #BackEndTest: Acquire the next image in the swapchain available
    renderContext.AcquireNextIamge();
    const uint32_t CURR_FRAME_IDX_2 = renderContext.GetCurrentFrame();
@ -602,8 +602,6 @@ namespace SHADE
    if (currFrameData.cmdPoolHdls.empty())
      throw std::runtime_error("No command pools available!");
    currFrameData.cmdPoolHdls[0]->Reset();
-
-
  }

  /***************************************************************************/
@ -710,6 +708,11 @@ namespace SHADE
    return resourceManager.Create<SHMaterialInstance>(materialInst->GetBaseMaterial());
  }

+  std::pair<typename SHResourceHub::dense_iterator<SHMaterialInstance>, typename SHResourceHub::dense_iterator<SHMaterialInstance>> SHGraphicsSystem::GetAllMaterialInstances()
+  {
+    return resourceManager.GetDenseAccess<SHMaterialInstance>();
+  }
+
  void SHGraphicsSystem::RemoveMaterialInstance(Handle<SHMaterialInstance> materialInstance)
  {
    resourceManager.Free(materialInstance);
@ -807,7 +810,7 @@ namespace SHADE

  void SHGraphicsSystem::BeginRoutine::Execute(double) noexcept
  {
-    SHResourceManager::FinaliseChanges();
+    // Begin rendering
    reinterpret_cast<SHGraphicsSystem*>(system)->BeginRender();
  }
  
@ -833,6 +836,36 @@ namespace SHADE
  void SHGraphicsSystem::EndRoutine::Execute(double) noexcept
  {
    reinterpret_cast<SHGraphicsSystem*>(system)->EndRender();
+
+    // Reset all material isDirty
+    auto gfxSystem = reinterpret_cast<SHGraphicsSystem*>(system);
+    auto [matBegin, matEnd] = gfxSystem->resourceManager.GetDenseAccess<SHMaterial>();
+    for (auto iter = matBegin; iter != matEnd; ++iter)
+    {
+      iter->ClearChangeFlag();
+    }
+  }
+
+  SHGraphicsSystem::PrepareRenderRoutine::PrepareRenderRoutine()
+    : SHSystemRoutine("Graphics System Pre-Render", true)
+  {}
+
+  void SHGraphicsSystem::PrepareRenderRoutine::Execute(double) noexcept
+  {
+    // Finish up, loading, unloading any resources
+    SHResourceManager::FinaliseChanges();
+
+    // Clean up and update all materials
+    auto gfxSystem = reinterpret_cast<SHGraphicsSystem*>(system);
+    auto [matInstBegin, matInstEnd] = gfxSystem->resourceManager.GetDenseAccess<SHMaterialInstance>();
+    for (auto iter = matInstBegin; iter != matInstEnd; ++iter)
+    {
+      auto baseMat = iter->GetBaseMaterial();
+      if (baseMat && baseMat->HasPipelineChanged())
+      {
+        iter->ResetProperties();
+      }
+    }
  }

  /*-----------------------------------------------------------------------------------*/
@ -847,6 +880,9 @@ namespace SHADE
    auto& renderables = SHComponentManager::GetDense<SHRenderable>();
    for (auto& renderable : renderables)
    {
+      // Check if the material instance is now unused
+      renderable.CleanUpMaterials();
+
      if (!renderable.HasChanged())
        continue; 

@ -858,7 +894,6 @@ namespace SHADE
        oldSuperBatch->Remove(&renderable);
      }

-      // Add to new SuperBatch if there is a material
      // Add to new SuperBatch if there is a material and a mesh to render
      Handle<SHMaterialInstance> newMatInstance = renderable.GetMaterial();
      if (newMatInstance && renderable.GetMesh())
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h
@ -110,6 +110,12 @@ namespace SHADE
      EndRoutine();
      virtual void Execute(double dt) noexcept override final;
    };
+    class SH_API PrepareRenderRoutine final : public SHSystemRoutine
+    {
+      public:
+      PrepareRenderRoutine();
+      virtual void Execute(double dt) noexcept override final;
+    };
    class SH_API BatcherDispatcherRoutine final : public SHSystemRoutine
    {
      public:
@ -156,6 +162,7 @@ namespace SHADE
    Handle<SHMaterialInstance> AddOrGetBaseMaterialInstance();
    Handle<SHMaterialInstance> AddOrGetBaseMaterialInstance(Handle<SHMaterial> material);
    Handle<SHMaterialInstance> AddMaterialInstanceCopy(Handle<SHMaterialInstance> materialInst);
+    std::pair<typename SHResourceHub::dense_iterator<SHMaterialInstance>, typename SHResourceHub::dense_iterator<SHMaterialInstance>> GetAllMaterialInstances();
    void RemoveMaterialInstance(Handle<SHMaterialInstance> materialInstance);
    Handle<SHMaterial> GetDefaultMaterial() { return defaultMaterial; }
    Handle<SHMaterialInstance> GetDefaultMaterialInstance() { return AddOrGetBaseMaterialInstance(defaultMaterial); }
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterial.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterial.cpp
@ -6,24 +6,26 @@
 #include "Graphics/Shaders/BlockInterface/SHShaderBlockInterface.h"
 #include "Math/Vector/SHVec3.h"
 #include "Math/Vector/SHVec4.h"
+#include "ECS_Base/Managers/SHSystemManager.h"
+#include "SHGraphicsSystem.h"
+#include "SHMaterialInstance.h"

 namespace SHADE
 {
-	/*---------------------------------------------------------------------------------*/
+  /*-----------------------------------------------------------------------------------*/
  /* Pipeline Functions                                                                */
-	/*---------------------------------------------------------------------------------*/
+  /*-----------------------------------------------------------------------------------*/
  void SHMaterial::SetPipeline(Handle<SHVkPipeline> _pipeline)
  {
+    // Reassignment, we ignore
+    if (_pipeline == pipeline)
+      return;
+
    pipeline = _pipeline;

    // Set up properties based on the pipeline
-		if (!pipeline)
+    if (pipeline)
    {
-			// Clear memory and all that
-			propMemory.reset();
-			return;
-		}
-
      // Allocate memory for properties
      const Handle<SHShaderBlockInterface> SHADER_INFO = GetShaderBlockInterface();
      propMemorySize = SHADER_INFO ? SHADER_INFO->GetBytesRequired() : 0;
@ -35,7 +37,13 @@ namespace SHADE
      {
        propMemory.reset(new char[propMemorySize]);
      }
+    }
+    
+    // Reset since pipeline changed
    ResetProperties();
+
+    // Mark changed so that we know to update dependent material instances
+    propertiesChanged = true;
  }

  Handle<SHVkPipeline> SHMaterial::GetPipeline() const
@ -43,9 +51,9 @@ namespace SHADE
    return pipeline;
  }

-	/*---------------------------------------------------------------------------------*/
+  /*-----------------------------------------------------------------------------------*/
  /* Property Functions                                                                */
-	/*---------------------------------------------------------------------------------*/
+  /*-----------------------------------------------------------------------------------*/
  void SHMaterial::ResetProperties()
  {
    // Reset all the properties to default values
@ -67,6 +75,8 @@ namespace SHADE
        break;
      }
    }
+
+    propertiesChanged = true;
  }

  void SHMaterial::ExportProperties(void* dest) const noexcept
@ -81,9 +91,9 @@ namespace SHADE
    return SHADER_INFO ? SHADER_INFO->GetBytesRequired() : 0;
  }

-	/*---------------------------------------------------------------------------------*/
+  /*-----------------------------------------------------------------------------------*/
  /* Helper Functions                                                                  */
-	/*---------------------------------------------------------------------------------*/
+  /*-----------------------------------------------------------------------------------*/
  Handle<SHShaderBlockInterface> SHMaterial::GetShaderBlockInterface() const noexcept
  {
    return pipeline->GetPipelineLayout()->GetShaderBlockInterface
@ -93,4 +103,12 @@ namespace SHADE
      vk::ShaderStageFlagBits::eFragment
    );
  }
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Query Functions                                                                   */
+  /*-----------------------------------------------------------------------------------*/
+  void SHMaterial::ClearChangeFlag() noexcept
+  {
+    propertiesChanged = false;
+  }
 }
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterial.h
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterial.h
@ -17,6 +17,7 @@ of DigiPen Institute of Technology is prohibited.
 // Project Includes
 #include "Resource/SHHandle.h"
 #include "SHCommonTypes.h"
+#include "SH_API.h"

 namespace SHADE
 {
@ -35,7 +36,7 @@ namespace SHADE
 		Describes a Pipeline along with it's associated properties for this instance.
 	*/
 	/***********************************************************************************/
-	class SHMaterial
+	class SH_API SHMaterial : public ISelfHandle<SHMaterial>
 	{
 	  public:
 		/*-----------------------------------------------------------------------------*/
@ -67,6 +68,10 @@ namespace SHADE
        /* Query Functions                                                             */
        /*-----------------------------------------------------------------------------*/
 		Handle<SHShaderBlockInterface> GetShaderBlockInterface() const noexcept;
+        bool HasPipelineChanged() const noexcept { return pipelineChanged; }
+        bool HasPropertiesChanged() const noexcept { return propertiesChanged; }
+        bool HasChanged() const noexcept { return pipelineChanged || propertiesChanged; }
+        void ClearChangeFlag() noexcept;

 	  private:
 		/*-----------------------------------------------------------------------------*/
@ -75,6 +80,8 @@ namespace SHADE
 		Handle<SHVkPipeline>  pipeline;
 		std::unique_ptr<char> propMemory;
 		Byte                  propMemorySize = 0;
+        bool                  propertiesChanged = true;
+        bool                  pipelineChanged = true;

        /*-----------------------------------------------------------------------------*/
        /* Helper Functions                                                            */
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterial.hpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterial.hpp
@ -33,8 +33,7 @@ namespace SHADE
 		}

 		// Get offset and modify the memory directly
-		T* dataPtr = reinterpret_cast<T*>(propMemory.get() + PROP_INFO->offset);
-		*dataPtr = value;
+        setPropertyUnsafe(PROP_INFO->offset, value);
 	}

    template<typename T>
@ -85,6 +84,12 @@ namespace SHADE
    template<typename T>
    void SHMaterial::setPropertyUnsafe(uint32_t memOffset, const T& value)
    {
+        // Size check
+        if (memOffset + sizeof(T) > propMemorySize)
+        {
+          throw std::runtime_error("Attempted to write to out of bounds MaterialInstance properties memory");
+        }
        (*reinterpret_cast<T*>(propMemory.get() + memOffset)) = value;
+        propertiesChanged = true;
    }
 }
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.cpp
@ -15,7 +15,7 @@ of DigiPen Institute of Technology is prohibited.
 #include "SHGraphicsConstants.h"
 #include "SHMaterial.h"
 #include "Graphics/Pipeline/SHVkPipeline.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"

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

  void SHMaterialInstance::ExportProperties(void* dest)
@ -65,9 +65,17 @@ namespace SHADE
    dataWasChanged = false;
  }

-  /*---------------------------------------------------------------------------------*/
+  /*-----------------------------------------------------------------------------------*/
+  /* Query Functions                                                                   */
+  /*-----------------------------------------------------------------------------------*/
+  bool SHMaterialInstance::HasChanged() const noexcept
+  {
+    return dataWasChanged || (baseMaterial && baseMaterial->HasChanged());
+  }
+
+  /*-----------------------------------------------------------------------------------*/
  /* Helper Functions                                                                  */
-  /*---------------------------------------------------------------------------------*/
+  /*-----------------------------------------------------------------------------------*/
  Handle<SHShaderBlockInterface> SHMaterialInstance::getShaderBlockInterface() const noexcept
  {
      return baseMaterial->GetPipeline()->GetPipelineLayout()->GetShaderBlockInterface
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.h
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.h
@ -43,9 +43,9 @@ namespace SHADE
    /*-----------------------------------------------------------------------------*/
    struct OverrideData
    {
-      size_t Index;
-      size_t DataSize;
-      size_t StoredDataOffset;
+      uint32_t Index;
+      uint32_t DataSize;
+      uint32_t StoredDataOffset;
    };

    /*-----------------------------------------------------------------------------*/
@ -69,7 +69,8 @@ namespace SHADE
    /* Getter Functions                                                            */
    /*-----------------------------------------------------------------------------*/
    Handle<SHMaterial> GetBaseMaterial() const noexcept { return baseMaterial; } 
-    bool               HasChanged() const noexcept { return dataWasChanged; }
+    bool               HasChanged() const noexcept;
+    bool               IsBlank() const noexcept { return overrideData.empty(); } // No overrides

    private:
    /*-----------------------------------------------------------------------------*/
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.hpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.hpp
@ -11,6 +11,7 @@ of DigiPen Institute of Technology is prohibited.
 *//*************************************************************************************/
 #pragma once
 #include "SHMaterialInstance.h"
+#include "SHMaterial.h"

 namespace SHADE
 {
@ -34,9 +35,20 @@ namespace SHADE
      dataStore.reset(new char[dataStoreSize]);
    }

+    // Check if this was stored before
+    const uint32_t VAR_IDX = SHADER_INFO->GetVariableIndex(key);
+    auto existingOverride = std::find_if(overrideData.begin(), overrideData.end(), [&](const OverrideData& od)
+    {
+        return od.Index == VAR_IDX;
+    });
+    
+    // Otherwise, create it
+    if (existingOverride == overrideData.end())
+    {
      OverrideData od;
-    od.Index = SHADER_INFO->GetVariableIndex(key);
+      od.Index = VAR_IDX;
      od.DataSize = sizeof(T);
+
      if (overrideData.empty())
      {
        od.StoredDataOffset = 0;
@ -47,12 +59,20 @@ namespace SHADE
        od.StoredDataOffset = lastInsertedData.StoredDataOffset + lastInsertedData.DataSize;
      }

-    // Get offset and modify the memory directly
-    T* dataPtr = reinterpret_cast<T*>(dataStore.get() + od.StoredDataOffset);
-    *dataPtr = value;
+      // Size check
+      if (od.StoredDataOffset + sizeof(T) > dataStoreSize)
+      {
+        throw std::runtime_error("Attempted to write to out of bounds MaterialInstance properties memory");
+      }

      // Save the override data information
      overrideData.emplace_back(std::move(od));
+      existingOverride = overrideData.end() - 1;
+    }
+
+    // Get offset and modify the memory directly
+    T* dataPtr = reinterpret_cast<T*>(dataStore.get() + existingOverride->StoredDataOffset);
+    *dataPtr = value;
    
    // Flag
 	dataWasChanged = true;
@ -73,8 +93,19 @@ namespace SHADE
    {
      return PROP_IDX == data.Index;
    });
+
+    // No overrides, we get from the base material instead
    if (prop == overrideData.end())
+    {
+      if (baseMaterial)
+      {
+        return baseMaterial->GetProperty<T>(key);
+      }
+      else
+      {
        throw std::invalid_argument("Attempted to get an property that was not set previously!");
+      }
+    }

    // Get offset and return the memory directly
    T* dataPtr = reinterpret_cast<T*>(dataStore.get() + prop->StoredDataOffset);
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderable.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderable.cpp
@ -34,8 +34,11 @@ namespace SHADE
  void SHRenderable::OnDestroy()
  {
    // Remove from SuperBatch
+    if (sharedMaterial)
+    {
      Handle<SHSuperBatch> superBatch = sharedMaterial->GetBaseMaterial()->GetPipeline()->GetPipelineState().GetSubpass()->GetSuperBatch();
      superBatch->Remove(this);
+    }

    // Free resources
    if (material)
@ -88,11 +91,20 @@ namespace SHADE
    {
      SHGraphicsSystem* gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
      material = gfxSystem->AddMaterialInstanceCopy(sharedMaterial);
+      matChanged = true;
    }

    return material;
  }
  
+  void SHRenderable::CleanUpMaterials() noexcept
+  {
+    if (material && material->IsBlank())
+    {
+      SetMaterial(sharedMaterial);
+    }
+  }
+
  /*-----------------------------------------------------------------------------------*/
  /* Mesh Functions                                                                    */
  /*-----------------------------------------------------------------------------------*/
@ -111,6 +123,20 @@ namespace SHADE
    return lightLayer;
  }
  
+  bool SHRenderable::HasChanged() const noexcept
+  {
+    if (matChanged || meshChanged)
+      return true;
+
+    // If the underlying material has changed
+    auto mat = GetMaterial();
+    if (mat)
+    {
+      return mat->HasChanged();
+    }
+    return false;
+  }
+
  /*-----------------------------------------------------------------------------------*/
  /* Batcher Dispatcher Functions                                                      */
  /*-----------------------------------------------------------------------------------*/
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderable.h
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderable.h
@ -53,6 +53,10 @@ namespace SHADE
      Handle<SHMaterialInstance> GetModifiableMaterial();
      Handle<SHMaterialInstance> GetPrevMaterial() const noexcept { return oldMaterial; }
      bool HasMaterialChanged() const noexcept { return matChanged; }
+      /// <summary>
+      /// Clears the modifiable material if it is unused.
+      /// </summary>
+      void CleanUpMaterials() noexcept;

      /*-------------------------------------------------------------------------------*/
      /* Mesh Functions                                                                */
@ -70,7 +74,7 @@ namespace SHADE
      /*-------------------------------------------------------------------------------*/
      /* Batcher Dispatcher Functions                                                  */
      /*-------------------------------------------------------------------------------*/
-      bool HasChanged() const noexcept { return matChanged || meshChanged; } // Whether or not the mesh or material has changed
+      bool HasChanged() const noexcept; // Whether or not the mesh or material has changed
      void ResetChangedFlag(); // TODO: Lock it so that only SHBatcherDispatcher can access this

      private:
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHViewport.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHViewport.cpp
@ -15,7 +15,7 @@ of DigiPen Institute of Technology is prohibited.

 #include "Graphics/Commands/SHVkCommandBuffer.h"
 #include "Graphics/Instance/SHVkInstance.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "SHRenderer.h"
 #include "Resource/SHResourceLibrary.h"
 #include "Graphics/RenderGraph/SHRenderGraph.h"
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.cpp
@ -1,7 +1,7 @@
 #include "SHpch.h"
 #include "SHLightingSubSystem.h"
 #include "Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.h"
-#include "Tools/SHUtilities.h"
+#include "Tools/Utilities/SHUtilities.h"
 #include "Graphics/Devices/SHVkLogicalDevice.h"
 #include "Graphics/Buffers/SHVkBuffer.h"
 #include "Graphics/Descriptors/SHVkDescriptorSetGroup.h"
--- a/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHRenderContext.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHRenderContext.cpp
@ -1,6 +1,6 @@
 #include "SHPch.h"
 #include "SHRenderContext.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "Graphics/Devices/SHVkLogicalDevice.h"
 #include "Graphics/Swapchain/SHVkSwapchain.h"

--- a/SHADE_Engine/src/Graphics/MiddleEnd/Pipeline/SHPipelineLibrary.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Pipeline/SHPipelineLibrary.cpp
@ -34,7 +34,7 @@ namespace SHADE
    {
    	colorBlendState.attachments.push_back(vk::PipelineColorBlendAttachmentState
        {
-          .blendEnable = SHVkUtil::IsBlendCompatible (subpass->GetFormatFromAttachmentReference(att.attachment)) ? true : false,
+          .blendEnable = SHVkUtil::IsBlendCompatible(subpass->GetFormatFromAttachmentReference(att.attachment)),
          .srcColorBlendFactor = vk::BlendFactor::eSrcAlpha,
          .dstColorBlendFactor = vk::BlendFactor::eOneMinusSrcAlpha,
          .colorBlendOp = vk::BlendOp::eAdd,
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp
@ -19,7 +19,7 @@ of DigiPen Institute of Technology is prohibited.
 #include "Graphics/Buffers/SHVkBuffer.h"
 #include "Graphics/Commands/SHVkCommandBuffer.h"
 #include "Graphics/SHVkUtil.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "Graphics/MiddleEnd/Interface/SHGraphicsConstants.h"
 #include "Graphics/Descriptors/SHVkDescriptorSetGroup.h"
 #include "Graphics/Images/SHVkImage.h"
--- a/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.cpp
+++ b/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.cpp
@ -2,7 +2,7 @@
 #include "SHVkPipelineLayout.h"
 #include "Graphics/Devices/SHVkLogicalDevice.h"
 #include "Graphics/Shaders/SHVkShaderModule.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "Graphics/Instance/SHVkInstance.h"

 namespace SHADE
--- a/SHADE_Engine/src/Graphics/Queues/SHVkQueue.cpp
+++ b/SHADE_Engine/src/Graphics/Queues/SHVkQueue.cpp
@ -1,6 +1,6 @@
 #include "SHPch.h"
 #include "SHVkQueue.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "Graphics/Devices/SHVkLogicalDevice.h"
 #include "Graphics/Synchronization/SHVkSemaphore.h"
 #include "Graphics/Synchronization/SHVkFence.h"
--- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp
+++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp
@ -7,7 +7,7 @@
 #include "Graphics/Images/SHVkImageView.h"
 #include "Graphics/Framebuffer/SHVkFramebuffer.h"
 #include "Graphics/Buffers/SHVkBuffer.h"
-#include "Tools/SHLogger.h"
+#include "Tools/Logger/SHLogger.h"
 #include "SHAttachmentDescInitParams.h"
 #include "SHRenderGraphStorage.h"
 #include "Graphics/RenderGraph/SHRenderGraphNodeCompute.h"
@ -129,11 +129,11 @@ namespace SHADE
        for (auto& predResource : prereq->attResources)
        {
          // if a predecessor's resource is used by this node, we want to copy the final layout from the pred to the initial of this node
-          if (uint64_t resourceID = predResource.GetId().Raw; node->resourceAttachmentMapping.contains(resourceID))
+          if (uint64_t resourceID = predResource.GetId().Raw; node->resourceAttachmentMapping->contains(resourceID))
          {
            // Get the resource's attachment index in BOTH the predecessor and the current node
-            uint32_t prereqResourceAttIndex = prereq->resourceAttachmentMapping[resourceID];
-            uint32_t resourceAttIndex = node->resourceAttachmentMapping[resourceID];
+            uint32_t prereqResourceAttIndex = prereq->resourceAttachmentMapping->at(resourceID);
+            uint32_t resourceAttIndex = node->resourceAttachmentMapping->at(resourceID);

            // Use the resource attachment index to get the attachment description in the renderpass
            auto& attDesc = node->attachmentDescriptions[resourceAttIndex];
--- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.cpp
+++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.cpp
@ -124,7 +124,7 @@ namespace SHADE
    , framebuffers{}
    , prereqNodes{ std::move(predecessors) }
    , attachmentDescriptions{}
-    , resourceAttachmentMapping{}
+    , resourceAttachmentMapping { new std::unordered_map<uint64_t, uint32_t> }
    , attResources{ }
    , subpasses{}
    , executed{ false }
@ -163,7 +163,7 @@ namespace SHADE
      if (attResources[i]->resourceTypeFlags & static_cast<uint32_t>(SH_ATT_DESC_TYPE_FLAGS::COLOR_PRESENT))
        containsSwapchainImage = true;

-      resourceAttachmentMapping.try_emplace(attResources[i].GetId().Raw, i);
+      resourceAttachmentMapping->try_emplace(attResources[i].GetId().Raw, i);
    }

    if (!containsSwapchainImage)
@ -254,7 +254,7 @@ namespace SHADE
      (
        subpassName, 
        graphStorage, GetHandle(), static_cast<uint32_t>(subpasses.size()),
-        &resourceAttachmentMapping
+        resourceAttachmentMapping.get()
      )
    );
    subpassIndexing.try_emplace(subpassName, static_cast<uint32_t>(subpasses.size()) - 1u);
--- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.h
+++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.h
@ -60,7 +60,7 @@ namespace SHADE
    std::vector<vk::SubpassDependency>  spDeps;

    //! For indexing resources fast
-    std::unordered_map<uint64_t, uint32_t> resourceAttachmentMapping;
+    std::unique_ptr<std::unordered_map<uint64_t, uint32_t>> resourceAttachmentMapping;

    //! For indexing subpasses
    std::map<std::string, uint32_t> subpassIndexing;
--- a/Show More
+++ b/Show More