[help]: I am going to throw my computer out a window

12 files changed, 95 insertions, 33 deletions

diff --git a/src/Rendering/IndexBuffer.cpp b/src/Rendering/IndexBuffer.cpp
index 185684b..dc900ed 100644
--- a/src/Rendering/IndexBuffer.cpp
+++ b/src/Rendering/IndexBuffer.cpp
@@ -6,14 +6,14 @@
 
 namespace Donut 
 {
-    IndexBuffer* IndexBuffer::Create(const uint32_t* indices, uint32_t count) 
+    Ref<IndexBuffer> IndexBuffer::Create(const uint32_t* indices, uint32_t count) 
     {
         switch (Renderer::GetAPI()) 
         {
             case RendererAPI::API::OpenGL:
-                return new OpenGLIndexBuffer(indices, count);
+                return CreateRef<OpenGLIndexBuffer>(indices, count);
             case RendererAPI::API::Vulkan:
-                return new VulkanIndexBuffer((uint32_t*)indices, count);
+                return CreateRef<VulkanIndexBuffer>((uint32_t*)indices, count);
             default:
                 return nullptr;
         }
diff --git a/src/Rendering/IndexBuffer.h b/src/Rendering/IndexBuffer.h
index a58cc6c..bb1b3a1 100644
--- a/src/Rendering/IndexBuffer.h
+++ b/src/Rendering/IndexBuffer.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "Core/Memory.h"
 #include <cstdint>
 
 namespace Donut
@@ -13,6 +14,6 @@ namespace Donut
         virtual void     Unbind()   const = 0;
         virtual uint32_t GetCount() const = 0;
 
-        static IndexBuffer* Create(const uint32_t* indices, uint32_t count);
+        static Ref<IndexBuffer> Create(const uint32_t* indices, uint32_t count);
     };
 };
diff --git a/src/Rendering/Renderer.cpp b/src/Rendering/Renderer.cpp
index c0684cb..c1001d8 100644
--- a/src/Rendering/Renderer.cpp
+++ b/src/Rendering/Renderer.cpp
@@ -7,14 +7,14 @@
 
 namespace Donut 
 {
-    Scope<RendererAPI> RendererAPI::Create()
+    Ref<RendererAPI> RendererAPI::Create()
      {
         switch (s_API)
         {
             case API::OpenGL:
-                return CreateScope<OpenGLRendererAPI>();
+                return CreateRef<OpenGLRendererAPI>();
             case API::Vulkan:
-                return CreateScope<VulkanRendererAPI>();
+                return CreateRef<VulkanRendererAPI>();
             default:
                 return nullptr;
         }
@@ -50,7 +50,7 @@ namespace Donut
         RenderCommand::DrawIndexed(vertexArray);
     }
 
-    Scope<RendererAPI> RenderCommand::s_RendererAPI = RendererAPI::Create();
+    Ref<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 fa37fc8..b2a44a4 100644
--- a/src/Rendering/Renderer.h
+++ b/src/Rendering/Renderer.h
@@ -26,14 +26,17 @@ namespace Donut
         virtual void SetClearColor(const glm::vec4& color)        = 0;
         virtual void Clear()                                      = 0;
         virtual void EnableDepthTest()                            = 0;
+        virtual void DisableDepthTest()                           = 0;
         virtual void SetFaceCulling(bool enabled)                 = 0;
+        virtual void EnableBlending()                             = 0;
+        virtual void DisableBlending()                            = 0;
 
         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 Scope<RendererAPI> Create();
+        static Ref<RendererAPI> Create();
     private:
         static API s_API;
     };
@@ -66,18 +69,33 @@ namespace Donut
             s_RendererAPI->EnableDepthTest();
         }
 
+        inline static void DisableDepthTest()
+        {
+            s_RendererAPI->DisableDepthTest();
+        }
+
         inline static void SetFaceCulling(bool enabled)
         {
             s_RendererAPI->SetFaceCulling(enabled);
         }
 
+        inline static void EnableBlending()
+        {
+            s_RendererAPI->EnableBlending();
+        }
+
+        inline static void DisableBlending()
+        {
+            s_RendererAPI->DisableBlending();
+        }
+
         inline static void DrawIndexed(const Ref<VertexArray>& vertexArray, uint32_t indexCount = 0)
         {
             s_RendererAPI->DrawIndexed(vertexArray, indexCount);
         }
 
     private:
-        static Scope<RendererAPI> s_RendererAPI;
+        static Ref<RendererAPI> s_RendererAPI;
     };
 
     class Renderer 
diff --git a/src/Rendering/Shader.cpp b/src/Rendering/Shader.cpp
index 8266e00..2198663 100644
--- a/src/Rendering/Shader.cpp
+++ b/src/Rendering/Shader.cpp
@@ -6,40 +6,40 @@
 
 namespace Donut
 {
-    Shader* Shader::Create(const std::string& filepath) 
+    Ref<Shader> Shader::Create(const std::string& filepath) 
     {
         switch (Renderer::GetAPI())
         {
             case RendererAPI::API::OpenGL:
-                return new OpenGLShader(filepath);
+                return CreateRef<OpenGLShader>(filepath);
             case RendererAPI::API::Vulkan:
-                return new VulkanShader(filepath);
+                return CreateRef<VulkanShader>(filepath);
             default:
                 return nullptr;
         }
     }
 
-    Shader* Shader::Create(const std::string& name, const std::string& vertexSrc, const std::string& fragmentSrc)
+    Ref<Shader> Shader::Create(const std::string& name, const std::string& vertexSrc, const std::string& fragmentSrc)
     {
         switch (Renderer::GetAPI()) 
         {
             case RendererAPI::API::OpenGL:
-                return new OpenGLShader(name, vertexSrc, fragmentSrc);
+                return CreateRef<OpenGLShader>(name, vertexSrc, fragmentSrc);
             case RendererAPI::API::Vulkan:
-                return new VulkanShader(name, vertexSrc, fragmentSrc);
+                return CreateRef<VulkanShader>(name, vertexSrc, fragmentSrc);
             default:
                 return nullptr;
         }
     }
 
-    Shader* Shader::CreateCompute(const std::string& name, const std::string& computeSrc)
+    Ref<Shader> Shader::CreateCompute(const std::string& name, const std::string& computeSrc)
     {
         switch (Renderer::GetAPI()) 
         {
             case RendererAPI::API::OpenGL:
-                return new OpenGLShader(name, computeSrc);
+                return CreateRef<OpenGLShader>(name, computeSrc);
             case RendererAPI::API::Vulkan:
-                return new VulkanShader(name, computeSrc);
+                return CreateRef<VulkanShader>(name, computeSrc);
             default:
                 return nullptr;
         }
@@ -58,14 +58,14 @@ namespace Donut
 
     Ref<Shader> ShaderLibrary::Load(const std::string& filepath)
     {
-        auto shader = Ref<Shader>(Shader::Create(filepath));
+        auto shader = Shader::Create(filepath);
         Add(shader);
         return shader;
     }
 
     Ref<Shader> ShaderLibrary::Load(const std::string& name, const std::string& filepath)
     {
-        auto shader = Ref<Shader>(Shader::Create(filepath));
+        auto shader = Shader::Create(filepath);
         Add(name, shader);
         return shader;
     }
diff --git a/src/Rendering/Shader.h b/src/Rendering/Shader.h
index e2d8d2a..9cfecd9 100644
--- a/src/Rendering/Shader.h
+++ b/src/Rendering/Shader.h
@@ -35,9 +35,9 @@ namespace Donut
 
         virtual const std::string& GetName() const = 0;
 
-        static Shader* Create(const std::string& filepath);
-        static Shader* Create(const std::string& name, const std::string& vertexSrc, const std::string& fragmentSrc);
-        static Shader* CreateCompute(const std::string& name, const std::string& computeSrc);
+        static Ref<Shader> Create(const std::string& filepath);
+        static Ref<Shader> Create(const std::string& name, const std::string& vertexSrc, const std::string& fragmentSrc);
+        static Ref<Shader> CreateCompute(const std::string& name, const std::string& computeSrc);
     };
 
     class ShaderLibrary
diff --git a/src/Rendering/UniformBuffer.cpp b/src/Rendering/UniformBuffer.cpp
new file mode 100644
index 0000000..16cf04c
--- /dev/null
+++ b/src/Rendering/UniformBuffer.cpp
@@ -0,0 +1,23 @@
+#include "UniformBuffer.h"
+#include "Renderer.h"
+
+#include "Platform/OpenGL/OpenGLUniformBuffer.h"
+#include "Platform/Vulkan/VulkanUniformBuffer.h"
+
+namespace Donut
+{
+    Ref<UniformBuffer> UniformBuffer::Create(uint32_t size, uint32_t binding)
+    {
+        switch (Renderer::GetAPI())
+        {
+        case RendererAPI::API::OpenGL:
+            return CreateRef<OpenGLUniformBuffer>(size, binding);
+        case RendererAPI::API::Vulkan:
+            return CreateRef<VulkanUniformBuffer>(size, binding);
+        case RendererAPI::API::None:
+            return nullptr;
+        default:
+            return nullptr;
+        }
+    }
+};
diff --git a/src/Rendering/UniformBuffer.h b/src/Rendering/UniformBuffer.h
new file mode 100644
index 0000000..ce68908
--- /dev/null
+++ b/src/Rendering/UniformBuffer.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Core/Memory.h"
+#include <cstdint>
+
+namespace Donut
+{
+    class UniformBuffer
+    {
+    public:
+        virtual ~UniformBuffer() = default;
+
+        virtual void SetData(const void* data, uint32_t size, uint32_t offset = 0) = 0;
+        virtual void Bind(uint32_t binding) = 0;
+
+        static Ref<UniformBuffer> Create(uint32_t size, uint32_t binding);
+    };
+};
diff --git a/src/Rendering/VertexArray.cpp b/src/Rendering/VertexArray.cpp
index 366675f..bca1f4a 100644
--- a/src/Rendering/VertexArray.cpp
+++ b/src/Rendering/VertexArray.cpp
@@ -17,14 +17,14 @@ namespace Donut
         }
     }
 
-    VertexArray* VertexArray::Create() 
+    Ref<VertexArray> VertexArray::Create() 
     {
         switch (Renderer::GetAPI()) 
         {
             case RendererAPI::API::OpenGL:
-                return new OpenGLVertexArray();
+                return CreateRef<OpenGLVertexArray>();
             case RendererAPI::API::Vulkan:
-                return new VulkanVertexArray();
+                return CreateRef<VulkanVertexArray>();
             default:
                 return nullptr;
         }
diff --git a/src/Rendering/VertexArray.h b/src/Rendering/VertexArray.h
index 10fff89..aa857e4 100644
--- a/src/Rendering/VertexArray.h
+++ b/src/Rendering/VertexArray.h
@@ -23,6 +23,6 @@ namespace Donut
         virtual const std::vector<Ref<VertexBuffer>>& GetVertexBuffers() const = 0;
         virtual const Ref<IndexBuffer>& GetIndexBuffer()                 const = 0;
 
-        static VertexArray* Create();
+        static Ref<VertexArray> Create();
     };
 };
diff --git a/src/Rendering/VertexBuffer.cpp b/src/Rendering/VertexBuffer.cpp
index a7e2504..dd59546 100644
--- a/src/Rendering/VertexBuffer.cpp
+++ b/src/Rendering/VertexBuffer.cpp
@@ -6,14 +6,14 @@
 
 namespace Donut
 {
-    VertexBuffer* VertexBuffer::Create(const void* data, uint32_t size)
+    Ref<VertexBuffer> VertexBuffer::Create(const void* data, uint32_t size)
     {
         switch (Renderer::GetAPI()) 
         {
             case RendererAPI::API::OpenGL:
-                return new OpenGLVertexBuffer(data, size);
+                return CreateRef<OpenGLVertexBuffer>(data, size);
             case RendererAPI::API::Vulkan:
-                return new VulkanVertexBuffer((float*)data, size);
+                return CreateRef<VulkanVertexBuffer>((float*)data, size);
             default:
                 return nullptr;
         }
diff --git a/src/Rendering/VertexBuffer.h b/src/Rendering/VertexBuffer.h
index 35b9a84..db85755 100644
--- a/src/Rendering/VertexBuffer.h
+++ b/src/Rendering/VertexBuffer.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "Core/Memory.h"
+
 #include <cstdint>
 #include <vector>
 
@@ -22,7 +24,7 @@ namespace Donut
         ~VertexBufferLayout() = default;
 
         template<typename T>
-        void Push(uint32_t count) 
+        void Push(uint32_t count)
         {
             static_assert(false);
         }
@@ -68,6 +70,6 @@ namespace Donut
         virtual const VertexBufferLayout& GetLayout()      const = 0;
         virtual void SetLayout(const VertexBufferLayout& layout) = 0;
 
-        static VertexBuffer* Create(const void* data, uint32_t size);
+        static Ref<VertexBuffer> Create(const void* data, uint32_t size);
     };
 };