[add]: Custom memory managers and fix includes

9 files changed, 51 insertions, 45 deletions

diff --git a/src/Rendering/Renderer.cpp b/src/Rendering/Renderer.cpp
index 577dcf4..c0684cb 100644
--- a/src/Rendering/Renderer.cpp
+++ b/src/Rendering/Renderer.cpp
@@ -3,19 +3,18 @@
 #include "Platform/OpenGL/OpenGLRendererAPI.h"
 #include "Platform/Vulkan/VulkanRendererAPI.h"
 
-#include <memory>
 #include <glm/gtc/matrix_transform.hpp>
 
 namespace Donut 
 {
-    std::unique_ptr<RendererAPI> RendererAPI::Create()
+    Scope<RendererAPI> RendererAPI::Create()
      {
         switch (s_API)
         {
             case API::OpenGL:
-                return std::make_unique<OpenGLRendererAPI>();
+                return CreateScope<OpenGLRendererAPI>();
             case API::Vulkan:
-                return std::make_unique<VulkanRendererAPI>();
+                return CreateScope<VulkanRendererAPI>();
             default:
                 return nullptr;
         }
@@ -38,8 +37,8 @@ namespace Donut
         RenderCommand::SetViewport(0, 0, width, height);
     }
 
-    void Renderer::Submit(const std::shared_ptr<Shader>& shader, 
-                          const std::shared_ptr<VertexArray>& vertexArray,
+    void Renderer::Submit(const Ref<Shader>& shader, 
+                          const Ref<VertexArray>& vertexArray,
                           const glm::mat4& transform,
                           const glm::mat4& viewProjection) 
     {
@@ -51,7 +50,7 @@ namespace Donut
         RenderCommand::DrawIndexed(vertexArray);
     }
 
-    std::unique_ptr<RendererAPI> RenderCommand::s_RendererAPI = RendererAPI::Create();
+    Scope<RendererAPI> RenderCommand::s_RendererAPI = RendererAPI::Create();
 
     void Renderer::SetClearColor(const glm::vec4& color)
     {
diff --git a/src/Rendering/Renderer.h b/src/Rendering/Renderer.h
index 61dae82..fa37fc8 100644
--- a/src/Rendering/Renderer.h
+++ b/src/Rendering/Renderer.h
@@ -1,10 +1,10 @@
 #pragma once
 
+#include "Core/Memory.h"
 #include "VertexArray.h"
 #include "Shader.h"
 
 #include <glm/glm.hpp>
-#include <memory>
 
 namespace Donut
 {
@@ -28,12 +28,12 @@ namespace Donut
         virtual void EnableDepthTest()                            = 0;
         virtual void SetFaceCulling(bool enabled)                 = 0;
 
-        virtual void DrawIndexed(const std::shared_ptr<VertexArray>& vertexArray, 
+        virtual void DrawIndexed(const Ref<VertexArray>& vertexArray, 
                                  uint32_t indexCount = 0)         = 0;
 
         inline static API GetAPI()         { return s_API; }
         inline static void SetAPI(API api) { s_API = api;  }
-        static std::unique_ptr<RendererAPI> Create();
+        static Scope<RendererAPI> Create();
     private:
         static API s_API;
     };
@@ -71,13 +71,13 @@ namespace Donut
             s_RendererAPI->SetFaceCulling(enabled);
         }
 
-        inline static void DrawIndexed(const std::shared_ptr<VertexArray>& vertexArray, uint32_t indexCount = 0)
+        inline static void DrawIndexed(const Ref<VertexArray>& vertexArray, uint32_t indexCount = 0)
         {
             s_RendererAPI->DrawIndexed(vertexArray, indexCount);
         }
 
     private:
-        static std::unique_ptr<RendererAPI> s_RendererAPI;
+        static Scope<RendererAPI> s_RendererAPI;
     };
 
     class Renderer 
@@ -88,8 +88,8 @@ namespace Donut
 
         static void OnWindowResize(uint32_t width, uint32_t height);
 
-        static void Submit(const std::shared_ptr<Shader>& shader, 
-                           const std::shared_ptr<VertexArray>& vertexArray,
+        static void Submit(const Ref<Shader>& shader, 
+                           const Ref<VertexArray>& vertexArray,
                            const glm::mat4& transform,
                            const glm::mat4& viewProjection);
 
diff --git a/src/Rendering/Shader.cpp b/src/Rendering/Shader.cpp
index e38ce65..8266e00 100644
--- a/src/Rendering/Shader.cpp
+++ b/src/Rendering/Shader.cpp
@@ -1,8 +1,8 @@
 #include "Shader.h"
 #include "Renderer.h"
+
 #include "Platform/OpenGL/OpenGLShader.h"
 #include "Platform/Vulkan/VulkanShader.h"
-#include <memory>
 
 namespace Donut
 {
@@ -45,32 +45,32 @@ namespace Donut
         }
     }
 
-    void ShaderLibrary::Add(const std::shared_ptr<Shader>& shader)
+    void ShaderLibrary::Add(const Ref<Shader>& shader)
     {
         auto& name = shader->GetName();
         Add(name, shader);
     }
 
-    void ShaderLibrary::Add(const std::string& name, const std::shared_ptr<Shader>& shader)
+    void ShaderLibrary::Add(const std::string& name, const Ref<Shader>& shader)
     {
         m_Shaders[name] = shader;
     }
 
-    std::shared_ptr<Shader> ShaderLibrary::Load(const std::string& filepath)
+    Ref<Shader> ShaderLibrary::Load(const std::string& filepath)
     {
-        auto shader = std::shared_ptr<Shader>(Shader::Create(filepath));
+        auto shader = Ref<Shader>(Shader::Create(filepath));
         Add(shader);
         return shader;
     }
 
-    std::shared_ptr<Shader> ShaderLibrary::Load(const std::string& name, const std::string& filepath)
+    Ref<Shader> ShaderLibrary::Load(const std::string& name, const std::string& filepath)
     {
-        auto shader = std::shared_ptr<Shader>(Shader::Create(filepath));
+        auto shader = Ref<Shader>(Shader::Create(filepath));
         Add(name, shader);
         return shader;
     }
 
-    std::shared_ptr<Shader> ShaderLibrary::Get(const std::string& name)
+    Ref<Shader> ShaderLibrary::Get(const std::string& name)
     {
         if (Exists(name))
             return m_Shaders[name];
diff --git a/src/Rendering/Shader.h b/src/Rendering/Shader.h
index ef0bdb1..e2d8d2a 100644
--- a/src/Rendering/Shader.h
+++ b/src/Rendering/Shader.h
@@ -1,8 +1,9 @@
 #pragma once
 
+#include "Core/Memory.h"
+
 #include <string>
 #include <unordered_map>
-#include <memory>
 #include <glm/glm.hpp>
 
 #define SHADER_STORAGE_BARRIER_BIT    0x00002000
@@ -42,15 +43,15 @@ namespace Donut
     class ShaderLibrary
     {
     public:
-        void Add(const std::shared_ptr<Shader>& shader);
-        void Add(const std::string& name, const std::shared_ptr<Shader>& shader);
-        std::shared_ptr<Shader> Load(const std::string& filepath);
-        std::shared_ptr<Shader> Load(const std::string& name, const std::string& filepath);
+        void Add(const Ref<Shader>& shader);
+        void Add(const std::string& name, const Ref<Shader>& shader);
+        Ref<Shader> Load(const std::string& filepath);
+        Ref<Shader> Load(const std::string& name, const std::string& filepath);
 
-        std::shared_ptr<Shader> Get(const std::string& name);
+        Ref<Shader> Get(const std::string& name);
 
         bool Exists(const std::string& name) const;
     private:
-        std::unordered_map<std::string, std::shared_ptr<Shader>> m_Shaders;
+        std::unordered_map<std::string, Ref<Shader>> m_Shaders;
     };
 };
diff --git a/src/Rendering/Texture.cpp b/src/Rendering/Texture.cpp
index 3a86dba..a96b816 100644
--- a/src/Rendering/Texture.cpp
+++ b/src/Rendering/Texture.cpp
@@ -1,18 +1,19 @@
 #include "Texture.h"
 #include "Renderer.h"
-#include "../Platform/OpenGL/OpenGLTexture.h"
-#include "../Platform/Vulkan/VulkanTexture.h"
+
+#include "Platform/OpenGL/OpenGLTexture.h"
+#include "Platform/Vulkan/VulkanTexture.h"
 
 namespace Donut
 {
-    std::shared_ptr<Texture2D> Texture2D::Create(uint32_t width, uint32_t height)
+    Ref<Texture2D> Texture2D::Create(uint32_t width, uint32_t height)
     {
         switch (Renderer::GetAPI())
         {
         case RendererAPI::API::OpenGL:
-            return std::make_shared<OpenGLTexture2D>(width, height);
+            return CreateRef<OpenGLTexture2D>(width, height);
         case RendererAPI::API::Vulkan:
-            return std::make_shared<VulkanTexture2D>(width, height);
+            return CreateRef<VulkanTexture2D>(width, height);
         case RendererAPI::API::None:
             return nullptr;
         default:
@@ -20,14 +21,14 @@ namespace Donut
         }
     }
 
-    std::shared_ptr<Texture2D> Texture2D::Create(const std::string& path)
+    Ref<Texture2D> Texture2D::Create(const std::string& path)
     {
         switch (Renderer::GetAPI())
         {
         case RendererAPI::API::OpenGL:
-            return std::make_shared<OpenGLTexture2D>(path);
+            return CreateRef<OpenGLTexture2D>(path);
         case RendererAPI::API::Vulkan:
-            return std::make_shared<VulkanTexture2D>(path);
+            return CreateRef<VulkanTexture2D>(path);
         case RendererAPI::API::None:
             return nullptr;
         default:
diff --git a/src/Rendering/Texture.h b/src/Rendering/Texture.h
index 4d150c0..21941ee 100644
--- a/src/Rendering/Texture.h
+++ b/src/Rendering/Texture.h
@@ -1,6 +1,7 @@
 #pragma once
 
-#include <memory>
+#include "Core/Memory.h"
+
 #include <string>
 #include <glm/glm.hpp>
 
@@ -27,7 +28,7 @@ namespace Donut
         : public Texture
     {
     public:
-        static std::shared_ptr<Texture2D> Create(uint32_t width, uint32_t height);
-        static std::shared_ptr<Texture2D> Create(const std::string& path);
+        static Ref<Texture2D> Create(uint32_t width, uint32_t height);
+        static Ref<Texture2D> Create(const std::string& path);
     };
 };
\ No newline at end of file
diff --git a/src/Rendering/VertexArray.cpp b/src/Rendering/VertexArray.cpp
index 2b2549c..366675f 100644
--- a/src/Rendering/VertexArray.cpp
+++ b/src/Rendering/VertexArray.cpp
@@ -1,5 +1,6 @@
 #include "VertexArray.h"
 #include "Renderer.h"
+
 #include "Platform/OpenGL/OpenGLVertexArray.h"
 #include "Platform/Vulkan/VulkanVertexArray.h"
 
diff --git a/src/Rendering/VertexArray.h b/src/Rendering/VertexArray.h
index 8ae61a7..10fff89 100644
--- a/src/Rendering/VertexArray.h
+++ b/src/Rendering/VertexArray.h
@@ -1,8 +1,10 @@
 #pragma once
 
+#include "Core/Memory.h"
+
 #include "VertexBuffer.h"
 #include "IndexBuffer.h"
-#include <memory>
+
 #include <vector>
 
 namespace Donut
@@ -15,11 +17,11 @@ namespace Donut
         virtual void Bind()   const = 0;
         virtual void Unbind() const = 0;
 
-        virtual void AddVertexBuffer(const std::shared_ptr<VertexBuffer>& vertexBuffer) = 0;
-        virtual void SetIndexBuffer(const std::shared_ptr<IndexBuffer>& indexBuffer)    = 0;
+        virtual void AddVertexBuffer(const Ref<VertexBuffer>& vertexBuffer) = 0;
+        virtual void SetIndexBuffer(const Ref<IndexBuffer>& indexBuffer)    = 0;
 
-        virtual const std::vector<std::shared_ptr<VertexBuffer>>& GetVertexBuffers() const = 0;
-        virtual const std::shared_ptr<IndexBuffer>& GetIndexBuffer()                 const = 0;
+        virtual const std::vector<Ref<VertexBuffer>>& GetVertexBuffers() const = 0;
+        virtual const Ref<IndexBuffer>& GetIndexBuffer()                 const = 0;
 
         static VertexArray* Create();
     };
diff --git a/src/Rendering/VertexBuffer.cpp b/src/Rendering/VertexBuffer.cpp
index 57b4d87..a7e2504 100644
--- a/src/Rendering/VertexBuffer.cpp
+++ b/src/Rendering/VertexBuffer.cpp
@@ -1,5 +1,6 @@
 #include "VertexBuffer.h"
 #include "Renderer.h"
+
 #include "Platform/OpenGL/OpenGLVertexBuffer.h"
 #include "Platform/Vulkan/VulkanVertexBuffer.h"