2 files changed, 40 insertions, 41 deletions

diff --git a/src/Rendering/Renderer.cpp b/src/Rendering/Renderer.cpp
index 7b75a18..3f50a7c 100644
--- a/src/Rendering/Renderer.cpp
+++ b/src/Rendering/Renderer.cpp
@@ -3,10 +3,12 @@
 #include <memory>
 #include <glm/gtc/matrix_transform.hpp>
 
-namespace Donut {
-
-    Scope<RendererAPI> RendererAPI::Create() {
-        switch (s_API) {
+namespace Donut 
+{
+    Scope<RendererAPI> RendererAPI::Create()
+     {
+        switch (s_API)
+        {
             case API::OpenGL:
                 return std::make_unique<OpenGLRendererAPI>();
             default:
@@ -16,34 +18,28 @@ namespace Donut {
 
     RendererAPI::API RendererAPI::s_API = RendererAPI::API::OpenGL;
 
-    Renderer::SceneData* Renderer::s_SceneData = new Renderer::SceneData;
-
-    void Renderer::Init() {
+    void Renderer::Init()
+    {
         RenderCommand::Init();
+        RenderCommand::EnableDepthTest();
     }
 
-    void Renderer::Shutdown() {
-        delete s_SceneData;
+    void Renderer::Shutdown()
+    {
     }
 
-    void Renderer::OnWindowResize(uint32_t width, uint32_t height) {
+    void Renderer::OnWindowResize(uint32_t width, uint32_t height)
+    {
         RenderCommand::SetViewport(0, 0, width, height);
     }
 
-    void Renderer::BeginScene() {
-        // Set up scene data
-        s_SceneData->ViewProjectionMatrix = glm::ortho(-1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f);
-    }
-
-    void Renderer::EndScene() {
-        // Clean up scene data
-    }
-
     void Renderer::Submit(const std::shared_ptr<Shader>& shader, 
                          const std::shared_ptr<VertexArray>& vertexArray,
-                         const glm::mat4& transform) {
+                         const glm::mat4& transform,
+                         const glm::mat4& viewProjection) 
+    {
         shader->Bind();
-        shader->SetMat4("u_ViewProjection", s_SceneData->ViewProjectionMatrix);
+        shader->SetMat4("u_ViewProjection", viewProjection);
         shader->SetMat4("u_Transform", transform);
 
         vertexArray->Bind();
@@ -52,12 +48,13 @@ namespace Donut {
 
     Scope<RendererAPI> RenderCommand::s_RendererAPI = RendererAPI::Create();
 
-    void Renderer::SetClearColor(const glm::vec4& color) {
+    void Renderer::SetClearColor(const glm::vec4& color)
+    {
         RenderCommand::SetClearColor(color);
     }
 
-    void Renderer::Clear() {
+    void Renderer::Clear()
+    {
         RenderCommand::Clear();
     }
-
-}
+};
diff --git a/src/Rendering/Renderer.h b/src/Rendering/Renderer.h
index 29f66a5..d08d015 100644
--- a/src/Rendering/Renderer.h
+++ b/src/Rendering/Renderer.h
@@ -33,6 +33,7 @@ namespace Donut
         virtual void SetViewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height) = 0;
         virtual void SetClearColor(const glm::vec4& color) = 0;
         virtual void Clear() = 0;
+        virtual void EnableDepthTest() = 0;
 
         virtual void DrawIndexed(const std::shared_ptr<VertexArray>& vertexArray, uint32_t indexCount = 0) = 0;
 
@@ -46,23 +47,33 @@ namespace Donut
     class RenderCommand 
     {
     public:
-        inline static void Init() {
+        inline static void Init() 
+        {
             s_RendererAPI->Init();
         }
 
-        inline static void SetViewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height) {
+        inline static void SetViewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height)
+        {
             s_RendererAPI->SetViewport(x, y, width, height);
         }
 
-        inline static void SetClearColor(const glm::vec4& color) {
+        inline static void SetClearColor(const glm::vec4& color)
+        {
             s_RendererAPI->SetClearColor(color);
         }
 
-        inline static void Clear() {
+        inline static void Clear()
+        {
             s_RendererAPI->Clear();
         }
 
-        inline static void DrawIndexed(const std::shared_ptr<VertexArray>& vertexArray, uint32_t indexCount = 0) {
+        inline static void EnableDepthTest()
+        {
+            s_RendererAPI->EnableDepthTest();
+        }
+
+        inline static void DrawIndexed(const std::shared_ptr<VertexArray>& vertexArray, uint32_t indexCount = 0)
+        {
             s_RendererAPI->DrawIndexed(vertexArray, indexCount);
         }
 
@@ -78,23 +89,14 @@ namespace Donut
 
         static void OnWindowResize(uint32_t width, uint32_t height);
 
-        static void BeginScene();
-        static void EndScene();
-
         static void Submit(const std::shared_ptr<Shader>& shader, 
                            const std::shared_ptr<VertexArray>& vertexArray,
-                           const glm::mat4& transform = glm::mat4(1.0f));
+                           const glm::mat4& transform,
+                           const glm::mat4& viewProjection);
 
         static void SetClearColor(const glm::vec4& color);
         static void Clear();
 
         inline static RendererAPI::API GetAPI() { return RendererAPI::GetAPI(); }
-    private:
-        struct SceneData 
-        {
-            glm::mat4 ViewProjectionMatrix;
-        };
-
-        static SceneData* s_SceneData;
     };
 };