Merge branch 'main' into SP3-6-c-scripting

Assets/Editor/Layouts/UserLayout.ini

@@ -0,0 +1,48 @@
+[Window][MainStatusBar]
+Pos=0,1389
+Size=2547,20
+Collapsed=0
+
+[Window][SHEditorMenuBar]
+Pos=0,48
+Size=2547,1341
+Collapsed=0
+
+[Window][Hierarchy Panel]
+Pos=0,172
+Size=571,1217
+Collapsed=0
+DockId=0x00000004,0
+
+[Window][Debug##Default]
+Pos=60,60
+Size=400,400
+Collapsed=0
+
+[Window][Inspector]
+Pos=2276,48
+Size=271,1341
+Collapsed=0
+DockId=0x00000006,0
+
+[Window][Profiler]
+Pos=0,48
+Size=571,122
+Collapsed=0
+DockId=0x00000003,0
+
+[Window][Viewport]
+Pos=573,48
+Size=1701,1341
+Collapsed=0
+DockId=0x00000002,0
+
+[Docking][Data]
+DockSpace       ID=0xC5C9B8AB Window=0xBE4044E9 Pos=8,79 Size=2547,1341 Split=X
+  DockNode      ID=0x00000005 Parent=0xC5C9B8AB SizeRef=1992,1036 Split=X
+    DockNode    ID=0x00000001 Parent=0x00000005 SizeRef=571,1036 Split=Y Selected=0x1E6EB881
+      DockNode  ID=0x00000003 Parent=0x00000001 SizeRef=225,94 Selected=0x1E6EB881
+      DockNode  ID=0x00000004 Parent=0x00000001 SizeRef=225,940 Selected=0xE096E5AE
+    DockNode    ID=0x00000002 Parent=0x00000005 SizeRef=1074,1036 CentralNode=1 Selected=0x13926F0B
+  DockNode      ID=0x00000006 Parent=0xC5C9B8AB SizeRef=271,1036 Selected=0xE7039252
+

SHADE_Application/src/Application/SBApplication.cpp

@@ -30,6 +30,7 @@
 #include "Input/SHInputManager.h"
 #include "FRC/SHFramerateController.h"
 #include "AudioSystem/SHAudioSystem.h"
+#include "Camera/SHCameraSystem.h"
 
 // Components
 #include "Graphics/MiddleEnd/Interface/SHRenderable.h"
@@ -67,6 +68,7 @@ namespace Sandbox
     SHSystemManager::CreateSystem<SHTransformSystem>();
     SHGraphicsSystem* graphicsSystem = static_cast<SHGraphicsSystem*>(SHSystemManager::GetSystem<SHGraphicsSystem>());
     SHSystemManager::CreateSystem<SHAudioSystem>();
+    SHSystemManager::CreateSystem<SHCameraSystem>();
     
 #ifdef SHEDITOR
     SDL_Init(SDL_INIT_VIDEO);
@@ -89,6 +91,8 @@ namespace Sandbox
 
     SHSystemManager::RegisterRoutine<SHGraphicsSystem, SHGraphicsSystem::BatcherDispatcherRoutine>();
     SHSystemManager::RegisterRoutine<SHGraphicsSystem, SHGraphicsSystem::BeginRoutine>();
+
+    SHSystemManager::RegisterRoutine<SHCameraSystem, SHCameraSystem::EditorCameraUpdate>();
     
 #ifdef SHEDITOR
     SHSystemManager::RegisterRoutine<SHEditor, SHEditor::EditorRoutine>();
@@ -101,6 +105,7 @@ namespace Sandbox
     SHComponentManager::CreateComponentSparseSet<SHColliderComponent>();
     SHComponentManager::CreateComponentSparseSet<SHTransformComponent>();
     SHComponentManager::CreateComponentSparseSet<SHRenderable>();
+    SHComponentManager::CreateComponentSparseSet<SHCameraComponent>();
 
     //TODO: REMOVE AFTER PRESENTATION
     //SHAssetManager::LoadDataTemp("../../Assets/racoon.gltf");

SHADE_Engine/src/Camera/SHCameraComponent.cpp

@@ -0,0 +1,131 @@
+#include "SHpch.h"
+#include "SHCameraComponent.h"
+#include "ECS_Base/Managers/SHComponentManager.h"
+
+
+namespace SHADE
+{
+	SHCameraComponent::SHCameraComponent()
+		:yaw(0.0f), pitch(0.0f), roll(0.0f)
+		, width(1920.0f), height(1080.0f), zNear(0.01f), zFar(10000.0f), fov(90.0f), movementSpeed(1.0f), turnSpeed(1.0f)
+		, perspProj(true), dirtyView(true), dirtyProj(true)
+		, viewMatrix(), projMatrix()
+		, position()
+	{
+		ComponentFamily::GetID<SHCameraComponent>();
+	}
+
+	SHCameraComponent::~SHCameraComponent()
+	{
+	}
+
+	void SHCameraComponent::SetYaw(float yaw) noexcept
+	{
+		this->yaw = yaw;
+		dirtyView = true;
+	}
+
+	void SHCameraComponent::SetPitch(float pitch) noexcept
+	{
+		this->pitch = pitch;
+		dirtyView = true;
+	}
+
+	void SHCameraComponent::SetRoll(float roll) noexcept
+	{
+		this->roll = roll;
+		dirtyView = true;
+	}
+	void SHCameraComponent::SetPositionX(float x) noexcept
+	{
+		position.x = x;
+		dirtyView = true;
+	}
+	void SHCameraComponent::SetPositionY(float y) noexcept
+	{
+		position.y = y;
+		dirtyView = true;
+	}
+	void SHCameraComponent::SetPositionZ(float z) noexcept
+	{
+		position.z = z;
+		dirtyView = true;
+	}
+	void SHCameraComponent::SetPosition(float x,float y, float z) noexcept
+	{
+		position.x = x;
+		position.y = y;
+		position.z = z;
+		dirtyView = true;
+	}
+	void SHCameraComponent::SetPosition(SHVec3& pos) noexcept
+	{
+		this->position = pos;
+		dirtyView = true;
+	}
+
+	void SHCameraComponent::SetWidth(float width) noexcept
+	{
+		this->width = width;
+		dirtyProj = true;
+	}
+
+
+	void SHCameraComponent::SetHeight(float height) noexcept
+	{
+		this->height = height;
+		dirtyProj = true;
+	}
+
+	void SHCameraComponent::SetNear(float znear) noexcept
+	{
+		this->zNear = znear;
+		dirtyProj = true;
+	}
+
+	void SHCameraComponent::SetFar(float zFar) noexcept
+	{
+		this->zFar = zFar;
+		dirtyProj = true;
+	}
+
+	void SHCameraComponent::SetFOV(float fov) noexcept
+	{
+		this->fov = fov;
+		dirtyProj = true;
+	}
+
+	float SHCameraComponent::GetYaw() const noexcept
+	{
+		return yaw;
+	}
+
+	float SHCameraComponent::GetPitch() const noexcept
+	{
+		return pitch;
+	}
+	float SHCameraComponent::GetRoll() const noexcept
+	{
+		return roll;
+	}	
+	float SHCameraComponent::GetAspectRatio() const noexcept
+	{
+		return width/height;
+	}
+
+	float SHCameraComponent::GetFOV() const noexcept
+	{
+		return fov;
+	}
+
+	const SHMatrix& SHCameraComponent::GetViewMatrix() const noexcept
+	{
+		return viewMatrix;
+	}
+
+	const SHMatrix& SHCameraComponent::GetProjMatrix() const noexcept
+	{
+		return projMatrix;
+	}
+
+}

SHADE_Engine/src/Camera/SHCameraComponent.h

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

SHADE_Engine/src/Camera/SHCameraSystem.cpp

@@ -0,0 +1,179 @@
+#include "SHpch.h"
+#include "SHCameraSystem.h"
+#include "Math/SHMathHelpers.h"
+#include "Input/SHInputManager.h"
+
+
+
+namespace SHADE
+{
+
+	void SHCameraSystem::EditorCameraUpdate::Execute(double dt) noexcept 
+	{
+    SHCameraSystem* system = static_cast<SHCameraSystem*>(GetSystem());
+    auto& camera = system->editorCamera;
+    SHVec3 target{ 0.0f,0.0f,-1.0f };
+    SHVec3 up = { 0.0f,1.0f,0.0f };
+
+
+    SHVec3::RotateY(target, SHMath::DegreesToRadians(camera.yaw));
+    SHVec3::RotateX(target, SHMath::DegreesToRadians(camera.pitch));
+    target += camera.position;
+    ////SHVec3::RotateZ(target, SHMath::DegreesToRadians(camera.roll));
+
+    //target = SHVec3::Normalise(target);
+
+    SHVec3::RotateZ(up, camera.roll);
+    up = SHVec3::Normalise(up);
+
+
+    SHVec3 view = target - camera.position; view = SHVec3::Normalise(view);
+    SHVec3 right = SHVec3::Cross(view, up); right = SHVec3::Normalise(right);
+    const SHVec3 UP = SHVec3::Cross(view, right);
+
+
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::A))
+    {
+      system->editorCamera.position -= right * dt * camera.movementSpeed;
+      system->editorCamera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::D))
+    {
+      system->editorCamera.position += right * dt * camera.movementSpeed;
+      system->editorCamera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::W))
+    {
+      system->editorCamera.position += view * dt * camera.movementSpeed;
+      system->editorCamera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::S))
+    {
+      system->editorCamera.position -= view * dt * camera.movementSpeed;
+      system->editorCamera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::Q))
+    {
+      system->editorCamera.position += UP * dt * camera.movementSpeed;
+      system->editorCamera.dirtyView = true;
+    }
+    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::E))
+    {
+      system->editorCamera.position -= UP * dt * camera.movementSpeed;
+      system->editorCamera.dirtyView = true;
+    }
+    system->UpdateCameraComponent(system->editorCamera);
+	}
+
+  void SHCameraSystem::Init(void) 
+  {
+    editorCamera.SetPosition(0.0f, 0.0f, 0.0f);
+    editorCamera.SetPitch(0.0f);
+    editorCamera.SetYaw(0.0f);
+    editorCamera.SetRoll(0.0f);
+    editorCamera.movementSpeed = 2.0f;
+    
+  }
+
+  void SHCameraSystem::Exit(void) 
+  {
+
+  }
+
+  SHCameraComponent* SHCameraSystem::GetEditorCamera(void) noexcept
+  {
+    return &editorCamera;
+  }
+
+  void SHCameraSystem::UpdateCameraComponent(SHCameraComponent& camera) noexcept
+	{
+		if (camera.dirtyView)
+		{
+      SHVec3 target{ 0.0f,0.0f,-1.0f };
+      SHVec3 up = { 0.0f,1.0f,0.0f };
+
+
+      SHVec3::RotateY(target, SHMath::DegreesToRadians(camera.yaw));
+      SHVec3::RotateX(target, SHMath::DegreesToRadians(camera.pitch));
+      target += camera.position;
+      ////SHVec3::RotateZ(target, SHMath::DegreesToRadians(camera.roll));
+
+      //target = SHVec3::Normalise(target);
+
+      SHVec3::RotateZ(up, camera.roll);
+      up = SHVec3::Normalise(up);
+
+
+      SHVec3 view = target - camera.position; view = SHVec3::Normalise(view);
+      SHVec3 right = SHVec3::Cross(view, up); right = SHVec3::Normalise(right);
+      const SHVec3 UP = SHVec3::Cross(view, right);
+
+      camera.viewMatrix = SHMatrix::Identity;
+      camera.viewMatrix(0, 0) = right[0];
+      camera.viewMatrix(0, 1) = right[1];
+      camera.viewMatrix(0, 2) = right[2];
+
+      camera.viewMatrix(1, 0) = UP[0];
+      camera.viewMatrix(1, 1) = UP[1];
+      camera.viewMatrix(1, 2) = UP[2];
+
+      camera.viewMatrix(2, 0) = view[0];
+      camera.viewMatrix(2, 1) = view[1];
+      camera.viewMatrix(2, 2) = view[2];
+
+      camera.viewMatrix(0, 3) = -right.Dot(camera.position);
+      camera.viewMatrix(1, 3) = -UP.Dot(camera.position);
+      camera.viewMatrix(2, 3) = -view.Dot(camera.position);
+
+      camera.dirtyView = false;
+		}
+    if (camera.dirtyProj == true)
+    {
+      if (camera.perspProj == true)
+      {
+        const float ASPECT_RATIO = (camera.GetAspectRatio());
+        const float TAN_HALF_FOV = tan(SHMath::DegreesToRadians(camera.fov) * 0.5f);
+        camera.projMatrix = SHMatrix::Identity;
+        camera.projMatrix(0, 0) = 1.0f / (ASPECT_RATIO * TAN_HALF_FOV);
+        camera.projMatrix(1, 1) = 1.0f / TAN_HALF_FOV;
+        camera.projMatrix(2, 2) = camera.zFar / (camera.zFar - camera.zNear);
+        camera.projMatrix(3, 3) = 0.0f;
+
+        camera.projMatrix(3, 2) = 1.0f;
+        camera.projMatrix(2, 3) = -(camera.zFar * camera.zNear) / (camera.zFar - camera.zNear);
+        
+        //const float fov_rad = SHMath::DegreesToRadians(camera.fov);
+        //const float focal_length = 1.0f / tan(fov_rad * 0.5f);
+
+        //camera.projMatrix(0,0) = focal_length / camera.GetAspectRatio();
+        //camera.projMatrix(1,1) = -focal_length;
+        //camera.projMatrix(2,2) = camera.zNear / (camera.zFar - camera.zNear);
+        //camera.projMatrix(2,3) = camera.zFar * (camera.zNear / (camera.zFar - camera.zNear));
+        //camera.projMatrix(3,2) = -1.0f;
+        //camera.projMatrix(3,3) = 0.0f;
+       
+        //camera.projMatrix = SHMatrix::Inverse(camera.projMatrix);
+
+        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;
+      }
+    }
+	}
+
+}

SHADE_Engine/src/Camera/SHCameraSystem.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "ECS_Base/System/SHSystem.h"
+#include "SHCameraComponent.h"
+#include "ECS_Base/System/SHSystemRoutine.h"
+#include "SH_API.h"
+
+
+namespace SHADE
+{
+	class SH_API SHCameraSystem final : public SHSystem
+	{
+	private:
+		//A camera component that represents editor camera.
+		//This is not tied to any entity. Hence this EID should not be used.
+		SHCameraComponent editorCamera;
+
+		
+
+	public:
+    SHCameraSystem(void) = default;
+    virtual ~SHCameraSystem(void) = default;
+
+		void Init (void);
+		void Exit (void);
+
+		class SH_API EditorCameraUpdate final : public SHSystemRoutine
+		{
+		public:
+
+			EditorCameraUpdate() : SHSystemRoutine("Editor Camera Update", true) {  };
+			virtual void Execute(double dt) noexcept override final;
+
+		};
+		friend class EditorCameraUpdate;
+
+		SHCameraComponent* GetEditorCamera (void) noexcept;
+
+	protected:
+
+		void UpdateCameraComponent(SHCameraComponent& camera) noexcept;
+
+	};
+
+
+
+}

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

@@ -97,14 +97,16 @@ namespace SHADE
 	/*---------------------------------------------------------------------------------*/
     /* Getter Functions                                                                */
     /*---------------------------------------------------------------------------------*/
-	SHMatrix SHCamera::GetViewMatrix() const
+	SHMatrix SHCamera::GetViewMatrix()
 	{
-		return viewMatrix;
+    updateMatrices();
+    return viewMatrix;
 	}
 
-	SHMatrix SHCamera::GetProjectionMatrix() const
+	SHMatrix SHCamera::GetProjectionMatrix()
 	{
-		return projMatrix;
+    updateMatrices();
+    return projMatrix;
 	}
 	SHMatrix SHCamera::GetViewProjectionMatrix()
 	{

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

@@ -3,11 +3,11 @@
 \author         Tng Kah Wei, kahwei.tng, 390009620
 \par            email: kahwei.tng\@digipen.edu
 \date           Aug 21, 2022
-\brief          
+\brief
+
 
-  
 Copyright (C) 2022 DigiPen Institute of Technology.
-Reproduction or disclosure of this file or its contents without the prior written consent 
+Reproduction or disclosure of this file or its contents without the prior written consent
 of DigiPen Institute of Technology is prohibited.
 *//*************************************************************************************/
 #pragma once
@@ -17,64 +17,66 @@ of DigiPen Institute of Technology is prohibited.
 
 namespace SHADE
 {
-    /***********************************************************************************/
+  /***********************************************************************************/
-    /*!
+  /*!
-      \brief
+    \brief
-        Object that manages the view and projection transformations for rendering
+      Object that manages the view and projection transformations for rendering
-        a 3D scene.	  
+      a 3D scene.
-    */
+  */
-    /***********************************************************************************/
+  /***********************************************************************************/
-    class SHCamera
+  class SHCamera
-    {
+  {
-      public:
+  public:
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        /* Constructor/Destructors                                                     */
+    /* Constructor/Destructors                                                     */
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        /* View Set Functions                                                          */
+    /* View Set Functions                                                          */
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        void SetLookAt(const SHVec3& pos, const SHVec3& target, const SHVec3& up);
+    void SetLookAt(const SHVec3& pos, const SHVec3& target, const SHVec3& up);
 
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        /* Projection Set Functions                                                    */
+    /* Projection Set Functions                                                    */
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        void SetPerspective(float fov, float width, float height, float zNear, float zFar);
+    void SetPerspective(float fov, float width, float height, float zNear, float zFar);
-        void SetOrthographic(float width, float height, float zNear, float zFar);
+    void SetOrthographic(float width, float height, float zNear, float zFar);
+    
+    //void SetPerspectiveMatrixExplicit (
 
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        /* Getter Functions                                                            */
+    /* Getter Functions                                                            */
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        SHMatrix GetViewMatrix() const;
+    SHMatrix GetViewMatrix();
-        SHMatrix GetProjectionMatrix() const;
+    SHMatrix GetProjectionMatrix();
-        SHMatrix GetViewProjectionMatrix();
+    SHMatrix GetViewProjectionMatrix();
-        SHMatrix GetInverseViewMatrix() const;
+    SHMatrix GetInverseViewMatrix() const;
-        SHMatrix GetInverseProjectionMatrix() const;
+    SHMatrix GetInverseProjectionMatrix() const;
-        SHMatrix GetInverseViewProjectionMatrix();
+    SHMatrix GetInverseViewProjectionMatrix();
 
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        /* Mapping Functions                                                           */
+    /* Mapping Functions                                                           */
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        SHVec3 ScreenToWorld(const SHVec3& vec) const;
+    SHVec3 ScreenToWorld(const SHVec3& vec) const;
-        SHVec3 WorldToScreen(const SHVec3& vec) const;
+    SHVec3 WorldToScreen(const SHVec3& vec) const;
-        SHVec3 CameraToWorld(const SHVec3& vec) const;
+    SHVec3 CameraToWorld(const SHVec3& vec) const;
-        SHVec3 WorldToCamera(const SHVec3& vec) const;
+    SHVec3 WorldToCamera(const SHVec3& vec) const;
 
-      private:
+  private:
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        /* Data Members                                                                */
+    /* Data Members                                                                */
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        SHMatrix viewMatrix;
+    SHMatrix viewMatrix;
-		SHMatrix projMatrix;
+    SHMatrix projMatrix;
-		SHMatrix vpMatrix;
+    SHMatrix vpMatrix;
-        SHMatrix inverseViewMatrix;
+    SHMatrix inverseViewMatrix;
-		SHMatrix inverseProjMatrix;
+    SHMatrix inverseProjMatrix;
-		SHMatrix inverseVpMatrix;
+    SHMatrix inverseVpMatrix;
-        bool isDirty                = true;
+    bool isDirty = true;
 
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        /* Helper Functions                                                            */
+    /* Helper Functions                                                            */
-        /*-----------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------*/
-        void updateMatrices();
+    void updateMatrices();
-        static SHVec3 multiplyHomogenous(const SHMatrix& mat, const SHVec3& vec);
+    static SHVec3 multiplyHomogenous(const SHMatrix& mat, const SHVec3& vec);
-    };
+  };
 }

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

@@ -16,6 +16,9 @@ of DigiPen Institute of Technology is prohibited.
 #include "Graphics/Instance/SHVkInstance.h"
 #include "Graphics/Windowing/Surface/SHVkSurface.h"
 #include "Graphics/Swapchain/SHVkSwapchain.h"
+#include "Camera/SHCameraSystem.h"
+#include "Editor/SHEditor.hpp"
+#include "ECS_Base/Managers/SHSystemManager.h"
 //#include "SHRenderer.h"
 #include "Graphics/Windowing/SHWindow.h"
 #include "Graphics/MiddleEnd/PerFrame/SHPerFrameData.h"
@@ -318,6 +321,23 @@ namespace SHADE
 
     // Bind textures
     
+    auto cameraSystem = SHSystemManager::GetSystem<SHCameraSystem>();
+    
+#ifdef SHEDITOR
+
+    auto editorSystem = SHSystemManager::GetSystem<SHEditor>();
+    if (editorSystem->editorState != SHEditor::State::PLAY)
+    {
+      worldRenderer->SetViewProjectionMatrix(SHMatrix::Transpose(cameraSystem->GetEditorCamera()->GetProjMatrix() * cameraSystem->GetEditorCamera()->GetViewMatrix()));
+    }
+    else
+    {
+      // main camera
+    }
+
+#else
+    // main camera
+#endif
 
     // For every viewport 
     for (int vpIndex = 0; vpIndex < static_cast<int>(viewports.size()); ++vpIndex)
@@ -704,6 +724,14 @@ namespace SHADE
 
     worldCamera->SetPerspective(90.0f, static_cast<float>(resizeWidth), static_cast<float>(resizeHeight), 0.0f, 100.0f);
 
+    auto cameraSystem = SHSystemManager::GetSystem<SHCameraSystem>();
+#ifdef SHEDITOR
+    cameraSystem->GetEditorCamera()->SetWidth(resizeWidth);
+    cameraSystem->GetEditorCamera()->SetHeight(resizeHeight);
+#else
+
+#endif
+
     for (auto& semaHandle : graphSemaphores)
       semaHandle = device->CreateSemaphore();
 

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

@@ -77,7 +77,7 @@ namespace SHADE
   {
     if (camera)
     {
-      cpuCameraData.viewProjectionMatrix = camera->GetViewProjectionMatrix();
+      //cpuCameraData.viewProjectionMatrix = camera->GetViewProjectionMatrix();
       cameraBuffer->WriteToMemory(&cpuCameraData, sizeof(SHShaderCameraData), 0, cameraDataAlignedSize * frameIndex);
 
         std::array<uint32_t, 1> dynamicOffsets{ frameIndex * cameraDataAlignedSize };
@@ -90,6 +90,12 @@ namespace SHADE
   {
   }
 
+  void SHRenderer::SetViewProjectionMatrix(SHMatrix const& vpMatrix) noexcept
+  {
+    //cpuCameraData.viewProjectionMatrix = camera->GetViewMatrix() * camera->GetProjectionMatrix();
+    cpuCameraData.viewProjectionMatrix = vpMatrix;
+  }
+
   Handle<SHRenderGraph> SHRenderer::GetRenderGraph(void) const noexcept
   {
     return renderGraph;

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

@@ -78,6 +78,7 @@ namespace SHADE
         void Draw(uint32_t frameIndex, Handle<SHVkDescriptorPool> descPool) noexcept;
         void UpdateDataAndBind (Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex) noexcept;
         void UpdateCameraDataToBuffer (void) noexcept;
+        void SetViewProjectionMatrix (SHMatrix const& vpMatrix) noexcept;
 
         /*-----------------------------------------------------------------------------*/
         /* Setters and Getters                                                         */