feat: complete first geodesic 3D raytracing

12 files changed, 124 insertions, 46 deletions

diff --git a/src/rendering/index_buffer.cpp b/src/rendering/index_buffer.cpp
index 3271a5a..1095e3b 100644
--- a/src/rendering/index_buffer.cpp
+++ b/src/rendering/index_buffer.cpp
@@ -6,14 +6,14 @@
 
 namespace Donut 
 {
-    Ref<IndexBuffer> IndexBuffer::create(const uint32_t* indices, uint32_t count) 
+    IndexBuffer* IndexBuffer::create(const uint32_t* indices, uint32_t count) 
     {
         switch (Renderer::get_api()) 
         {
             case RendererAPI::API::OpenGL:
-                return create_ref<OpenGLIndexBuffer>(indices, count);
+                return new OpenGLIndexBuffer(indices, count);
             case RendererAPI::API::Vulkan:
-                return create_ref<VulkanIndexBuffer>((uint32_t*)indices, count);
+                return new VulkanIndexBuffer((uint32_t*)indices, count);
             default:
                 return nullptr;
         }
diff --git a/src/rendering/index_buffer.h b/src/rendering/index_buffer.h
index 9859c20..856559a 100644
--- a/src/rendering/index_buffer.h
+++ b/src/rendering/index_buffer.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "core/memory.h"
 #include <cstdint>
 
 namespace Donut
@@ -14,6 +13,6 @@ namespace Donut
         virtual void     unbind()   const = 0;
         virtual uint32_t get_count() const = 0;
 
-        static Ref<IndexBuffer> create(const uint32_t* indices, uint32_t count);
+        static IndexBuffer* create(const uint32_t* indices, uint32_t count);
     };
 };
diff --git a/src/rendering/renderer.cpp b/src/rendering/renderer.cpp
index f34e2b0..5e4682c 100644
--- a/src/rendering/renderer.cpp
+++ b/src/rendering/renderer.cpp
@@ -7,14 +7,14 @@
 
 namespace Donut 
 {
-    Ref<RendererAPI> RendererAPI::create()
+    Scope<RendererAPI> RendererAPI::create()
      {
         switch (s_api)
         {
             case API::OpenGL:
-                return create_ref<OpenGLRendererAPI>();
+                return create_scope<OpenGLRendererAPI>();
             case API::Vulkan:
-                return create_ref<VulkanRendererAPI>();
+                return create_scope<VulkanRendererAPI>();
             default:
                 return nullptr;
         }
@@ -50,7 +50,7 @@ namespace Donut
         RenderCommand::draw_indexed(vertex_array);
     }
 
-    Ref<RendererAPI> RenderCommand::s_renderer_api = RendererAPI::create();
+    Scope<RendererAPI> RenderCommand::s_renderer_api = RendererAPI::create();
 
     void Renderer::set_clear_color(const glm::vec4& color)
     {
diff --git a/src/rendering/renderer.h b/src/rendering/renderer.h
index 4a028e5..67ad998 100644
--- a/src/rendering/renderer.h
+++ b/src/rendering/renderer.h
@@ -20,23 +20,31 @@ namespace Donut
     public:
         virtual ~RendererAPI() = default;
 
-        virtual void init()                                       = 0;
+        virtual void init()                                               = 0;
         virtual void set_viewport(uint32_t x, uint32_t y, 
-                                 uint32_t width, uint32_t height) = 0;
-        virtual void set_clear_color(const glm::vec4& color)        = 0;
-        virtual void clear()                                      = 0;
-        virtual void enable_depth_test()                            = 0;
-        virtual void disable_depth_test()                           = 0;
-        virtual void set_face_culling(bool enabled)                 = 0;
-        virtual void enable_blending()                             = 0;
-        virtual void disable_blending()                            = 0;
+                                 uint32_t width, uint32_t height)         = 0;
+        virtual void set_clear_color(const glm::vec4& color)                = 0;
+        virtual void clear()                                              = 0;
+        virtual void enable_depth_test()                                    = 0;
+        virtual void disable_depth_test()                                   = 0;
+        virtual void set_face_culling(bool enabled)                         = 0;
+        virtual void enable_blending()                                     = 0;
+        virtual void disable_blending()                                    = 0;
 
         virtual void draw_indexed(const Ref<VertexArray>& vertex_array, 
-                                 uint32_t index_count = 0)         = 0;
+                                 uint32_t index_count = 0)                 = 0;
+        
+        virtual void draw_arrays(uint32_t vertex_count, uint32_t first = 0) = 0;
+        virtual void draw_lines(const Ref<VertexArray>& vertex_array, 
+                               uint32_t index_count = 0)                   = 0;
+        virtual void bind_texture(uint32_t texture_id, uint32_t slot = 0)   = 0;
+        virtual void bind_image_texture(uint32_t texture_id, 
+                                      uint32_t slot = 0, 
+                                      bool read_only = false)              = 0;
 
         inline static API get_api()         { return s_api; }
         inline static void set_api(API api) { s_api = api;  }
-        static Ref<RendererAPI> create();
+        static Scope<RendererAPI> create();
     private:
         static API s_api;
     };
@@ -94,8 +102,28 @@ namespace Donut
             s_renderer_api->draw_indexed(vertex_array, index_count);
         }
 
+        inline static void draw_arrays(uint32_t vertex_count, uint32_t first = 0)
+        {
+            s_renderer_api->draw_arrays(vertex_count, first);
+        }
+
+        inline static void draw_lines(const Ref<VertexArray>& vertex_array, uint32_t index_count = 0)
+        {
+            s_renderer_api->draw_lines(vertex_array, index_count);
+        }
+
+        inline static void bind_texture(uint32_t texture_id, uint32_t slot = 0)
+        {
+            s_renderer_api->bind_texture(texture_id, slot);
+        }
+
+        inline static void bind_image_texture(uint32_t texture_id, uint32_t slot = 0, bool read_only = false)
+        {
+            s_renderer_api->bind_image_texture(texture_id, slot, read_only);
+        }
+
     private:
-        static Ref<RendererAPI> s_renderer_api;
+        static Scope<RendererAPI> s_renderer_api;
     };
 
     class Renderer 
diff --git a/src/rendering/shader.cpp b/src/rendering/shader.cpp
index 833b719..1bbd0fc 100644
--- a/src/rendering/shader.cpp
+++ b/src/rendering/shader.cpp
@@ -6,40 +6,40 @@
 
 namespace Donut
 {
-    Ref<Shader> Shader::create(const std::string& filepath) 
+    Shader* Shader::create(const std::string& filepath) 
     {
         switch (Renderer::get_api())
         {
             case RendererAPI::API::OpenGL:
-                return create_ref<OpenGLShader>(filepath);
+                return new OpenGLShader(filepath);
             case RendererAPI::API::Vulkan:
-                return create_ref<VulkanShader>(filepath);
+                return new VulkanShader(filepath);
             default:
                 return nullptr;
         }
     }
 
-    Ref<Shader> Shader::create(const std::string& name, const std::string& vertex_src, const std::string& fragment_src)
+    Shader* Shader::create(const std::string& name, const std::string& vertex_src, const std::string& fragment_src)
     {
         switch (Renderer::get_api()) 
         {
             case RendererAPI::API::OpenGL:
-                return create_ref<OpenGLShader>(name, vertex_src, fragment_src);
+                return new OpenGLShader(name, vertex_src, fragment_src);
             case RendererAPI::API::Vulkan:
-                return create_ref<VulkanShader>(name, vertex_src, fragment_src);
+                return new VulkanShader(name, vertex_src, fragment_src);
             default:
                 return nullptr;
         }
     }
 
-    Ref<Shader> Shader::create_compute(const std::string& name, const std::string& compute_src)
+    Shader* Shader::create_compute(const std::string& name, const std::string& compute_src)
     {
         switch (Renderer::get_api()) 
         {
             case RendererAPI::API::OpenGL:
-                return create_ref<OpenGLShader>(name, compute_src);
+                return new OpenGLShader(name, compute_src);
             case RendererAPI::API::Vulkan:
-                return create_ref<VulkanShader>(name, compute_src);
+                return new VulkanShader(name, compute_src);
             default:
                 return nullptr;
         }
@@ -58,14 +58,14 @@ namespace Donut
 
     Ref<Shader> ShaderLibrary::load(const std::string& filepath)
     {
-        auto shader = Shader::create(filepath);
+        auto shader = Ref<Shader>(Shader::create(filepath));
         add(shader);
         return shader;
     }
 
     Ref<Shader> ShaderLibrary::load(const std::string& name, const std::string& filepath)
     {
-        auto shader = Shader::create(filepath);
+        auto shader = Ref<Shader>(Shader::create(filepath));
         add(name, shader);
         return shader;
     }
diff --git a/src/rendering/shader.h b/src/rendering/shader.h
index 7f024bd..814f0cf 100644
--- a/src/rendering/shader.h
+++ b/src/rendering/shader.h
@@ -35,9 +35,9 @@ namespace Donut
 
         virtual const std::string& get_name() const = 0;
 
-        static Ref<Shader> create(const std::string& filepath);
-        static Ref<Shader> create(const std::string& name, const std::string& vertex_src, const std::string& fragment_src);
-        static Ref<Shader> create_compute(const std::string& name, const std::string& compute_src);
+        static Shader* create(const std::string& filepath);
+        static Shader* create(const std::string& name, const std::string& vertex_src, const std::string& fragment_src);
+        static Shader* create_compute(const std::string& name, const std::string& compute_src);
     };
 
     class ShaderLibrary
diff --git a/src/rendering/texture_manager.cpp b/src/rendering/texture_manager.cpp
new file mode 100644
index 0000000..fff5dda
--- /dev/null
+++ b/src/rendering/texture_manager.cpp
@@ -0,0 +1,34 @@
+#include "texture_manager.h"
+#include "platform/opengl/opengl_texture.h"
+#include "platform/opengl/opengl_renderer_api.h"
+#include <glad/glad.h>
+
+namespace Donut
+{
+    Ref<Texture2D> TextureManager::create_texture(uint32_t width, uint32_t height)
+    {
+        return create_ref<OpenGLTexture2D>(width, height);
+    }
+
+    void TextureManager::bind_texture(uint32_t texture_id, uint32_t slot)
+    {
+        RenderCommand::bind_texture(texture_id, slot);
+    }
+
+    void TextureManager::bind_image_texture(uint32_t texture_id, uint32_t slot, bool read_only)
+    {
+        RenderCommand::bind_image_texture(texture_id, slot, read_only);
+    }
+
+    void TextureManager::set_texture_data(uint32_t texture_id, void* data, uint32_t width, uint32_t height)
+    {
+        glBindTexture(GL_TEXTURE_2D, texture_id);
+        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
+    }
+
+    void TextureManager::resize_texture(uint32_t texture_id, uint32_t width, uint32_t height)
+    {
+        glBindTexture(GL_TEXTURE_2D, texture_id);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    }
+};
diff --git a/src/rendering/texture_manager.h b/src/rendering/texture_manager.h
new file mode 100644
index 0000000..902a27d
--- /dev/null
+++ b/src/rendering/texture_manager.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "core/memory.h"
+#include "rendering/texture.h"
+#include <cstdint>
+
+namespace Donut
+{
+    class TextureManager
+    {
+    public:
+        static Ref<Texture2D> create_texture(uint32_t width, uint32_t height);
+        
+        static void bind_texture(uint32_t texture_id, uint32_t slot = 0);
+        static void bind_image_texture(uint32_t texture_id, uint32_t slot = 0, bool read_only = false);
+        static void set_texture_data(uint32_t texture_id, void* data, uint32_t width, uint32_t height);
+        static void resize_texture(uint32_t texture_id, uint32_t width, uint32_t height);
+    };
+};
diff --git a/src/rendering/vertex_array.cpp b/src/rendering/vertex_array.cpp
index d0cd4b0..bb92ff3 100644
--- a/src/rendering/vertex_array.cpp
+++ b/src/rendering/vertex_array.cpp
@@ -17,14 +17,14 @@ namespace Donut
         }
     }
 
-    Ref<VertexArray> VertexArray::create() 
+    VertexArray* VertexArray::create() 
     {
         switch (Renderer::get_api()) 
         {
             case RendererAPI::API::OpenGL:
-                return create_ref<OpenGLVertexArray>();
+                return new OpenGLVertexArray();
             case RendererAPI::API::Vulkan:
-                return create_ref<VulkanVertexArray>();
+                return new VulkanVertexArray();
             default:
                 return nullptr;
         }
diff --git a/src/rendering/vertex_array.h b/src/rendering/vertex_array.h
index 3729167..a39849f 100644
--- a/src/rendering/vertex_array.h
+++ b/src/rendering/vertex_array.h
@@ -23,6 +23,6 @@ namespace Donut
         virtual const std::vector<Ref<VertexBuffer>>& get_vertex_buffers() const = 0;
         virtual const Ref<IndexBuffer>& get_index_buffer()                 const = 0;
 
-        static Ref<VertexArray> create();
+        static VertexArray* create();
     };
 };
diff --git a/src/rendering/vertex_buffer.cpp b/src/rendering/vertex_buffer.cpp
index ef2b288..4929711 100644
--- a/src/rendering/vertex_buffer.cpp
+++ b/src/rendering/vertex_buffer.cpp
@@ -6,14 +6,14 @@
 
 namespace Donut
 {
-    Ref<VertexBuffer> VertexBuffer::create(const void* data, uint32_t size)
+    VertexBuffer* VertexBuffer::create(const void* data, uint32_t size)
     {
         switch (Renderer::get_api()) 
         {
             case RendererAPI::API::OpenGL:
-                return create_ref<OpenGLVertexBuffer>(data, size);
+                return new OpenGLVertexBuffer(data, size);
             case RendererAPI::API::Vulkan:
-                return create_ref<VulkanVertexBuffer>((float*)data, size);
+                return new VulkanVertexBuffer((float*)data, size);
             default:
                 return nullptr;
         }
diff --git a/src/rendering/vertex_buffer.h b/src/rendering/vertex_buffer.h
index 39f43ba..77a76c9 100644
--- a/src/rendering/vertex_buffer.h
+++ b/src/rendering/vertex_buffer.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "core/memory.h"
-
 #include <cstdint>
 #include <vector>
 
@@ -24,7 +22,7 @@ namespace Donut
         ~VertexBufferLayout() = default;
 
         template<typename T>
-        void push(uint32_t count)
+        void push(uint32_t count) 
         {
             static_assert(false);
         }
@@ -70,6 +68,6 @@ namespace Donut
         virtual const VertexBufferLayout& get_layout()      const = 0;
         virtual void set_layout(const VertexBufferLayout& layout) = 0;
 
-        static Ref<VertexBuffer> create(const void* data, uint32_t size);
+        static VertexBuffer* create(const void* data, uint32_t size);
     };
 };