aboutsummaryrefslogtreecommitdiff
path: root/src/Rendering
diff options
context:
space:
mode:
Diffstat (limited to 'src/Rendering')
-rw-r--r--src/Rendering/Framebuffer.cpp12
-rw-r--r--src/Rendering/Framebuffer.h30
-rw-r--r--src/Rendering/IndexBuffer.cpp21
-rw-r--r--src/Rendering/IndexBuffer.h18
-rw-r--r--src/Rendering/Renderer.cpp54
-rw-r--r--src/Rendering/Renderer.h154
-rw-r--r--src/Rendering/Shader.cpp60
-rw-r--r--src/Rendering/Shader.h48
-rw-r--r--src/Rendering/Texture.cpp40
-rw-r--r--src/Rendering/Texture.h24
-rw-r--r--src/Rendering/TextureManager.cpp34
-rw-r--r--src/Rendering/TextureManager.h19
-rw-r--r--src/Rendering/UniformBuffer.cpp23
-rw-r--r--src/Rendering/UniformBuffer.h18
-rw-r--r--src/Rendering/VertexArray.cpp32
-rw-r--r--src/Rendering/VertexArray.h28
-rw-r--r--src/Rendering/VertexBuffer.cpp21
-rw-r--r--src/Rendering/VertexBuffer.h73
18 files changed, 212 insertions, 497 deletions
diff --git a/src/Rendering/Framebuffer.cpp b/src/Rendering/Framebuffer.cpp
index 1e95c6d..089c31e 100644
--- a/src/Rendering/Framebuffer.cpp
+++ b/src/Rendering/Framebuffer.cpp
@@ -1,15 +1,15 @@
-#include "Framebuffer.h"
-#include "Renderer.h"
+#include "framebuffer.h"
+#include "renderer.h"
-#include "Platform/OpenGL/OpenGLFramebuffer.h"
+#include "platform/opengl/opengl_framebuffer.h"
namespace Donut
{
- Ref<Framebuffer> Framebuffer::Create(const FramebufferSpecification& spec)
+ auto Framebuffer::create(const FramebufferSpecification& spec) -> Ref<Framebuffer>
{
- switch (Renderer::GetAPI())
+ switch (Renderer::get_api())
{
- case RendererAPI::API::OpenGL: return CreateRef<OpenGLFramebuffer>(spec);
+ case RendererAPI::API::OpenGL: return create_ref<OpenGLFramebuffer>(spec);
}
return nullptr;
diff --git a/src/Rendering/Framebuffer.h b/src/Rendering/Framebuffer.h
index e4c1481..a01a81b 100644
--- a/src/Rendering/Framebuffer.h
+++ b/src/Rendering/Framebuffer.h
@@ -1,7 +1,7 @@
#pragma once
-#include "Core/Memory.h"
-#include "Texture.h"
+#include "core/memory.h"
+#include "texture.h"
namespace Donut
{
@@ -21,24 +21,24 @@ namespace Donut
{
FramebufferTextureSpecification() = default;
FramebufferTextureSpecification(FramebufferTextureFormat format)
- : TextureFormat(format) {}
+ : texture_format(format) {}
- FramebufferTextureFormat TextureFormat = FramebufferTextureFormat::None;
+ FramebufferTextureFormat texture_format = FramebufferTextureFormat::None;
};
struct FramebufferAttachmentSpecification
{
FramebufferAttachmentSpecification() = default;
FramebufferAttachmentSpecification(std::initializer_list<FramebufferTextureSpecification> attachments)
- : Attachments(attachments) {}
+ : attachments(attachments) {}
- std::vector<FramebufferTextureSpecification> Attachments;
+ std::vector<FramebufferTextureSpecification> attachments;
};
struct FramebufferSpecification
{
uint32_t Width = 0, Height = 0;
- FramebufferAttachmentSpecification Attachments;
+ FramebufferAttachmentSpecification attachments;
uint32_t Samples = 1;
bool SwapChainTarget = false;
@@ -49,17 +49,17 @@ namespace Donut
public:
virtual ~Framebuffer() = default;
- virtual void Bind() = 0;
- virtual void Unbind() = 0;
+ virtual auto bind() -> void = 0;
+ virtual auto unbind() -> void = 0;
- virtual void Resize(uint32_t width, uint32_t height) = 0;
- virtual int ReadPixel(uint32_t attachmentIndex, int x, int y) = 0;
+ virtual auto resize(uint32_t width, uint32_t height) -> void = 0;
+ virtual auto read_pixel(uint32_t attachment_index, int x, int y) -> int = 0;
- virtual void ClearAttachment(uint32_t attachmentIndex, int value) = 0;
- virtual uint32_t GetColorAttachmentRendererID(uint32_t index = 0) const = 0;
+ virtual auto clear_attachment(uint32_t attachment_index, int value) -> void = 0;
+ virtual auto get_color_attachment_renderer_id(uint32_t index = 0) const -> uint32_t = 0;
- virtual const FramebufferSpecification& GetSpecification() const = 0;
+ virtual auto get_specification() const -> const FramebufferSpecification& = 0;
- static Ref<Framebuffer> Create(const FramebufferSpecification& spec);
+ static auto create(const FramebufferSpecification& spec) -> Ref<Framebuffer>;
};
};
diff --git a/src/Rendering/IndexBuffer.cpp b/src/Rendering/IndexBuffer.cpp
deleted file mode 100644
index 185684b..0000000
--- a/src/Rendering/IndexBuffer.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "IndexBuffer.h"
-#include "Renderer.h"
-
-#include "Platform/OpenGL/OpenGLIndexBuffer.h"
-#include "Platform/Vulkan/VulkanIndexBuffer.h"
-
-namespace Donut
-{
- IndexBuffer* IndexBuffer::Create(const uint32_t* indices, uint32_t count)
- {
- switch (Renderer::GetAPI())
- {
- case RendererAPI::API::OpenGL:
- return new OpenGLIndexBuffer(indices, count);
- case RendererAPI::API::Vulkan:
- return new VulkanIndexBuffer((uint32_t*)indices, count);
- default:
- return nullptr;
- }
- }
-};
diff --git a/src/Rendering/IndexBuffer.h b/src/Rendering/IndexBuffer.h
deleted file mode 100644
index a58cc6c..0000000
--- a/src/Rendering/IndexBuffer.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace Donut
-{
- class IndexBuffer
- {
- public:
- virtual ~IndexBuffer() = default;
-
- virtual void Bind() const = 0;
- virtual void Unbind() const = 0;
- virtual uint32_t GetCount() const = 0;
-
- static IndexBuffer* Create(const uint32_t* indices, uint32_t count);
- };
-};
diff --git a/src/Rendering/Renderer.cpp b/src/Rendering/Renderer.cpp
index c0684cb..28b7962 100644
--- a/src/Rendering/Renderer.cpp
+++ b/src/Rendering/Renderer.cpp
@@ -1,64 +1,64 @@
-#include "Renderer.h"
+#include "renderer.h"
-#include "Platform/OpenGL/OpenGLRendererAPI.h"
-#include "Platform/Vulkan/VulkanRendererAPI.h"
+#include "platform/opengl/opengl_renderer_api.h"
+#include "platform/vulkan/vulkan_renderer_api.h"
#include <glm/gtc/matrix_transform.hpp>
namespace Donut
{
- Scope<RendererAPI> RendererAPI::Create()
+ auto RendererAPI::create() -> Scope<RendererAPI>
{
- switch (s_API)
+ switch (s_api)
{
case API::OpenGL:
- return CreateScope<OpenGLRendererAPI>();
+ return create_scope<OpenGLRendererAPI>();
case API::Vulkan:
- return CreateScope<VulkanRendererAPI>();
+ return create_scope<VulkanRendererAPI>();
default:
return nullptr;
}
}
- RendererAPI::API RendererAPI::s_API = RendererAPI::API::OpenGL;
+ RendererAPI::API RendererAPI::s_api = RendererAPI::API::OpenGL;
- void Renderer::Init()
+ auto Renderer::init() -> void
{
- RenderCommand::Init();
- RenderCommand::EnableDepthTest();
+ RenderCommand::init();
+ RenderCommand::enable_depth_test();
}
- void Renderer::Shutdown()
+ auto Renderer::shutdown() -> void
{
}
- void Renderer::OnWindowResize(uint32_t width, uint32_t height)
+ auto Renderer::on_window_resize(uint32_t width, uint32_t height) -> void
{
- RenderCommand::SetViewport(0, 0, width, height);
+ RenderCommand::set_viewport(0, 0, width, height);
}
- void Renderer::Submit(const Ref<Shader>& shader,
- const Ref<VertexArray>& vertexArray,
+ auto Renderer::submit(const Ref<Shader>& shader,
+ const Ref<VertexArray>& vertex_array,
const glm::mat4& transform,
- const glm::mat4& viewProjection)
+ const glm::mat4& view_projection) -> void
{
- shader->Bind();
- shader->SetMat4("u_ViewProjection", viewProjection);
- shader->SetMat4("u_Transform", transform);
+ shader->bind();
+ shader->set_mat4("u_ViewProjection", view_projection);
+ shader->set_mat4("u_Transform", transform);
- vertexArray->Bind();
- RenderCommand::DrawIndexed(vertexArray);
+ vertex_array->bind();
+ RenderCommand::draw_indexed(vertex_array);
}
- Scope<RendererAPI> RenderCommand::s_RendererAPI = RendererAPI::Create();
+ Scope<RendererAPI> RenderCommand::s_renderer_api = RendererAPI::create();
- void Renderer::SetClearColor(const glm::vec4& color)
+ auto Renderer::set_clear_color(const glm::vec4& color) -> void
{
- RenderCommand::SetClearColor(color);
+ RenderCommand::set_clear_color(color);
}
- void Renderer::Clear()
+ auto Renderer::clear() -> void
{
- RenderCommand::Clear();
+ RenderCommand::clear();
}
};
diff --git a/src/Rendering/Renderer.h b/src/Rendering/Renderer.h
index 6e87411..189723d 100644
--- a/src/Rendering/Renderer.h
+++ b/src/Rendering/Renderer.h
@@ -1,156 +1,158 @@
#pragma once
-#include "Core/Memory.h"
-#include "VertexArray.h"
-#include "Shader.h"
-#include "Framebuffer.h"
+#include "core/memory.h"
+#include "vertex_array.h"
+#include "shader.h"
+#include "framebuffer.h"
#include <glm/glm.hpp>
namespace Donut
{
- class RendererAPI
+ class RendererAPI
{
public:
- enum class API
+ enum class API
{
- None = 0,
+ None = 0,
OpenGL = 1,
Vulkan = 2,
};
+
public:
virtual ~RendererAPI() = default;
- virtual void Init() = 0;
- 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 DisableDepthTest() = 0;
- virtual void SetFaceCulling(bool enabled) = 0;
- virtual void EnableBlending() = 0;
- virtual void DisableBlending() = 0;
+ virtual auto init() -> void = 0;
+ virtual auto set_viewport(uint32_t x, uint32_t y,
+ uint32_t width, uint32_t height) -> void = 0;
+ virtual auto set_clear_color(const glm::vec4& color) -> void = 0;
+ virtual auto clear() -> void = 0;
+ virtual auto enable_depth_test() -> void = 0;
+ virtual auto disable_depth_test() -> void = 0;
+ virtual auto set_face_culling(bool enabled) -> void = 0;
+ virtual auto enable_blending() -> void = 0;
+ virtual auto disable_blending() -> void = 0;
+
+ virtual auto draw_indexed(const Ref<VertexArray>& vertex_array,
+ uint32_t index_count = 0) -> void = 0;
+
+ virtual auto draw_arrays(uint32_t vertex_count, uint32_t first = 0) -> void = 0;
+ virtual auto draw_lines(const Ref<VertexArray>& vertex_array,
+ uint32_t index_count = 0) -> void = 0;
+ virtual auto bind_texture(uint32_t texture_id, uint32_t slot = 0) -> void = 0;
+ virtual auto bind_image_texture(uint32_t texture_id,
+ uint32_t slot = 0,
+ bool read_only = false) -> void = 0;
+ virtual auto read_pixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height,
+ uint32_t format, uint32_t type, void* pixels) -> void = 0;
- virtual void DrawIndexed(const Ref<VertexArray>& vertexArray,
- uint32_t indexCount = 0) = 0;
-
- virtual void DrawArrays(uint32_t vertexCount, uint32_t first = 0) = 0;
- virtual void DrawLines(const Ref<VertexArray>& vertexArray,
- uint32_t indexCount = 0) = 0;
- virtual void BindTexture(uint32_t textureID, uint32_t slot = 0) = 0;
- virtual void BindImageTexture(uint32_t textureID,
- uint32_t slot = 0,
- bool readOnly = false) = 0;
- virtual void ReadPixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height,
- uint32_t format, uint32_t type, void* pixels) = 0;
+ inline static auto get_api() -> API { return s_api; }
+ inline static auto set_api(API api) -> void { s_api = api; }
+ static auto create() -> Scope<RendererAPI>;
- inline static API GetAPI() { return s_API; }
- inline static void SetAPI(API api) { s_API = api; }
- static Scope<RendererAPI> Create();
private:
- static API s_API;
+ static API s_api;
};
- class RenderCommand
+ class RenderCommand
{
public:
- inline static void Init()
+ inline static auto init() -> void
{
- s_RendererAPI->Init();
+ s_renderer_api->init();
}
- inline static void SetViewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height)
+ inline static auto set_viewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height) -> void
{
- s_RendererAPI->SetViewport(x, y, width, height);
+ s_renderer_api->set_viewport(x, y, width, height);
}
- inline static void SetClearColor(const glm::vec4& color)
+ inline static auto set_clear_color(const glm::vec4& color) -> void
{
- s_RendererAPI->SetClearColor(color);
+ s_renderer_api->set_clear_color(color);
}
- inline static void Clear()
+ inline static auto clear() -> void
{
- s_RendererAPI->Clear();
+ s_renderer_api->clear();
}
- inline static void EnableDepthTest()
+ inline static auto enable_depth_test() -> void
{
- s_RendererAPI->EnableDepthTest();
+ s_renderer_api->enable_depth_test();
}
- inline static void DisableDepthTest()
+ inline static auto disable_depth_test() -> void
{
- s_RendererAPI->DisableDepthTest();
+ s_renderer_api->disable_depth_test();
}
- inline static void SetFaceCulling(bool enabled)
+ inline static auto set_face_culling(bool enabled) -> void
{
- s_RendererAPI->SetFaceCulling(enabled);
+ s_renderer_api->set_face_culling(enabled);
}
- inline static void EnableBlending()
+ inline static auto enable_blending() -> void
{
- s_RendererAPI->EnableBlending();
+ s_renderer_api->enable_blending();
}
- inline static void DisableBlending()
+ inline static auto disable_blending() -> void
{
- s_RendererAPI->DisableBlending();
+ s_renderer_api->disable_blending();
}
- inline static void DrawIndexed(const Ref<VertexArray>& vertexArray, uint32_t indexCount = 0)
+ inline static auto draw_indexed(const Ref<VertexArray>& vertex_array, uint32_t index_count = 0) -> void
{
- s_RendererAPI->DrawIndexed(vertexArray, indexCount);
+ s_renderer_api->draw_indexed(vertex_array, index_count);
}
- inline static void DrawArrays(uint32_t vertexCount, uint32_t first = 0)
+ inline static auto draw_arrays(uint32_t vertex_count, uint32_t first = 0) -> void
{
- s_RendererAPI->DrawArrays(vertexCount, first);
+ s_renderer_api->draw_arrays(vertex_count, first);
}
- inline static void DrawLines(const Ref<VertexArray>& vertexArray, uint32_t indexCount = 0)
+ inline static auto draw_lines(const Ref<VertexArray>& vertex_array, uint32_t index_count = 0) -> void
{
- s_RendererAPI->DrawLines(vertexArray, indexCount);
+ s_renderer_api->draw_lines(vertex_array, index_count);
}
- inline static void BindTexture(uint32_t textureID, uint32_t slot = 0)
+ inline static auto bind_texture(uint32_t texture_id, uint32_t slot = 0) -> void
{
- s_RendererAPI->BindTexture(textureID, slot);
+ s_renderer_api->bind_texture(texture_id, slot);
}
- inline static void BindImageTexture(uint32_t textureID, uint32_t slot = 0, bool readOnly = false)
+ inline static auto bind_image_texture(uint32_t texture_id, uint32_t slot = 0, bool read_only = false) -> void
{
- s_RendererAPI->BindImageTexture(textureID, slot, readOnly);
+ s_renderer_api->bind_image_texture(texture_id, slot, read_only);
}
- inline static void ReadPixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height,
- uint32_t format, uint32_t type, void* pixels)
+ inline static auto read_pixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height,
+ uint32_t format, uint32_t type, void* pixels) -> void
{
- s_RendererAPI->ReadPixels(x, y, width, height, format, type, pixels);
+ s_renderer_api->read_pixels(x, y, width, height, format, type, pixels);
}
private:
- static Scope<RendererAPI> s_RendererAPI;
+ static Scope<RendererAPI> s_renderer_api;
};
- class Renderer
+ class Renderer
{
public:
- static void Init();
- static void Shutdown();
+ static auto init() -> void;
+ static auto shutdown() -> void;
- static void OnWindowResize(uint32_t width, uint32_t height);
+ static auto on_window_resize(uint32_t width, uint32_t height) -> void;
- static void Submit(const Ref<Shader>& shader,
- const Ref<VertexArray>& vertexArray,
+ static auto submit(const Ref<Shader>& shader,
+ const Ref<VertexArray>& vertex_array,
const glm::mat4& transform,
- const glm::mat4& viewProjection);
+ const glm::mat4& view_projection) -> void;
- static void SetClearColor(const glm::vec4& color);
- static void Clear();
+ static auto set_clear_color(const glm::vec4& color) -> void;
+ static auto clear() -> void;
- inline static RendererAPI::API GetAPI() { return RendererAPI::GetAPI(); }
+ inline static auto get_api() -> RendererAPI::API { return RendererAPI::get_api(); }
};
};
diff --git a/src/Rendering/Shader.cpp b/src/Rendering/Shader.cpp
index 8266e00..167b855 100644
--- a/src/Rendering/Shader.cpp
+++ b/src/Rendering/Shader.cpp
@@ -1,14 +1,14 @@
-#include "Shader.h"
-#include "Renderer.h"
+#include "shader.h"
+#include "renderer.h"
-#include "Platform/OpenGL/OpenGLShader.h"
-#include "Platform/Vulkan/VulkanShader.h"
+#include "platform/opengl/opengl_shader.h"
+#include "platform/vulkan/vulkan_shader.h"
namespace Donut
{
- Shader* Shader::Create(const std::string& filepath)
+ auto Shader::create(const std::string& filepath) -> Shader*
{
- switch (Renderer::GetAPI())
+ switch (Renderer::get_api())
{
case RendererAPI::API::OpenGL:
return new OpenGLShader(filepath);
@@ -19,66 +19,66 @@ namespace Donut
}
}
- Shader* Shader::Create(const std::string& name, const std::string& vertexSrc, const std::string& fragmentSrc)
+ auto Shader::create(const std::string& name, const std::string& vertex_src, const std::string& fragment_src) -> Shader*
{
- switch (Renderer::GetAPI())
+ switch (Renderer::get_api())
{
case RendererAPI::API::OpenGL:
- return new OpenGLShader(name, vertexSrc, fragmentSrc);
+ return new OpenGLShader(name, vertex_src, fragment_src);
case RendererAPI::API::Vulkan:
- return new VulkanShader(name, vertexSrc, fragmentSrc);
+ return new VulkanShader(name, vertex_src, fragment_src);
default:
return nullptr;
}
}
- Shader* Shader::CreateCompute(const std::string& name, const std::string& computeSrc)
+ auto Shader::create_compute(const std::string& name, const std::string& compute_src) -> Shader*
{
- switch (Renderer::GetAPI())
+ switch (Renderer::get_api())
{
case RendererAPI::API::OpenGL:
- return new OpenGLShader(name, computeSrc);
+ return new OpenGLShader(name, compute_src);
case RendererAPI::API::Vulkan:
- return new VulkanShader(name, computeSrc);
+ return new VulkanShader(name, compute_src);
default:
return nullptr;
}
}
- void ShaderLibrary::Add(const Ref<Shader>& shader)
+ auto ShaderLibrary::add(const Ref<Shader>& shader) -> void
{
- auto& name = shader->GetName();
- Add(name, shader);
+ auto& name = shader->get_name();
+ add(name, shader);
}
- void ShaderLibrary::Add(const std::string& name, const Ref<Shader>& shader)
+ auto ShaderLibrary::add(const std::string& name, const Ref<Shader>& shader) -> void
{
- m_Shaders[name] = shader;
+ m_shaders[name] = shader;
}
- Ref<Shader> ShaderLibrary::Load(const std::string& filepath)
+ auto ShaderLibrary::load(const std::string& filepath) -> Ref<Shader>
{
- auto shader = Ref<Shader>(Shader::Create(filepath));
- Add(shader);
+ auto shader = Ref<Shader>(Shader::create(filepath));
+ add(shader);
return shader;
}
- Ref<Shader> ShaderLibrary::Load(const std::string& name, const std::string& filepath)
+ auto ShaderLibrary::load(const std::string& name, const std::string& filepath) -> Ref<Shader>
{
- auto shader = Ref<Shader>(Shader::Create(filepath));
- Add(name, shader);
+ auto shader = Ref<Shader>(Shader::create(filepath));
+ add(name, shader);
return shader;
}
- Ref<Shader> ShaderLibrary::Get(const std::string& name)
+ auto ShaderLibrary::Get(const std::string& name) -> Ref<Shader>
{
- if (Exists(name))
- return m_Shaders[name];
+ if (exists(name))
+ return m_shaders[name];
return nullptr;
}
- bool ShaderLibrary::Exists(const std::string& name) const
+ auto ShaderLibrary::exists(const std::string& name) const -> bool
{
- return m_Shaders.find(name) != m_Shaders.end();
+ return m_shaders.find(name) != m_shaders.end();
}
};
diff --git a/src/Rendering/Shader.h b/src/Rendering/Shader.h
index 483102d..bc3fd9a 100644
--- a/src/Rendering/Shader.h
+++ b/src/Rendering/Shader.h
@@ -1,6 +1,6 @@
#pragma once
-#include "Core/Memory.h"
+#include "core/memory.h"
#include <string>
#include <unordered_map>
@@ -18,41 +18,41 @@ namespace Donut
public:
virtual ~Shader() = default;
- virtual void Bind() const = 0;
- virtual void Unbind() const = 0;
+ virtual auto bind() const -> void = 0;
+ virtual auto unbind() const -> void = 0;
- virtual void SetInt( const std::string& name, int value) = 0;
- virtual void SetIntArray(const std::string& name, int* values, uint32_t count) = 0;
- virtual void SetFloat( const std::string& name, float value) = 0;
- virtual void SetFloat2( const std::string& name, const glm::vec2& value) = 0;
- virtual void SetFloat3( const std::string& name, const glm::vec3& value) = 0;
- virtual void SetFloat4( const std::string& name, const glm::vec4& value) = 0;
- virtual void SetMat4( const std::string& name, const glm::mat4& value) = 0;
+ virtual auto set_int( const std::string& name, int value) -> void = 0;
+ virtual auto set_int_array(const std::string& name, int* values, uint32_t count) -> void = 0;
+ virtual auto set_float( const std::string& name, float value) -> void = 0;
+ virtual auto set_float2( const std::string& name, const glm::vec2& value) -> void = 0;
+ virtual auto set_float3( const std::string& name, const glm::vec3& value) -> void = 0;
+ virtual auto set_float4( const std::string& name, const glm::vec4& value) -> void = 0;
+ virtual auto set_mat4( const std::string& name, const glm::mat4& value) -> void = 0;
- virtual void Dispatch(uint32_t x, uint32_t y = 1, uint32_t z = 1) = 0;
- virtual void DispatchIndirect(uint32_t offset = 0) = 0;
- virtual void MemoryBarrier(uint32_t barriers) = 0;
+ virtual auto dispatch(uint32_t x, uint32_t y = 1, uint32_t z = 1) -> void = 0;
+ virtual auto dispatch_indirect(uint32_t offset = 0) -> void = 0;
+ virtual auto memory_barrier(uint32_t barriers) -> void = 0;
- virtual const std::string& GetName() const = 0;
- virtual uint32_t GetRendererID() const = 0;
+ virtual auto get_name() const -> const std::string& = 0;
+ virtual auto get_renderer_id() const -> uint32_t = 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 auto create(const std::string& filepath) -> Shader*;
+ static auto create(const std::string& name, const std::string& vertex_src, const std::string& fragment_src) -> Shader*;
+ static auto create_compute(const std::string& name, const std::string& compute_src) -> Shader*;
};
class ShaderLibrary
{
public:
- 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);
+ auto add(const Ref<Shader>& shader) -> void;
+ auto add(const std::string& name, const Ref<Shader>& shader) -> void;
+ auto load(const std::string& filepath) -> Ref<Shader>;
+ auto load(const std::string& name, const std::string& filepath) -> Ref<Shader>;
Ref<Shader> Get(const std::string& name);
- bool Exists(const std::string& name) const;
+ auto exists(const std::string& name) const -> bool;
private:
- std::unordered_map<std::string, Ref<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 93b8a75..2470e46 100644
--- a/src/Rendering/Texture.cpp
+++ b/src/Rendering/Texture.cpp
@@ -1,19 +1,19 @@
-#include "Texture.h"
-#include "Renderer.h"
+#include "texture.h"
+#include "renderer.h"
-#include "Platform/OpenGL/OpenGLTexture.h"
-#include "Platform/Vulkan/VulkanTexture.h"
+#include "platform/opengl/opengl_texture.h"
+#include "platform/vulkan/vulkan_texture.h"
namespace Donut
{
- Ref<Texture2D> Texture2D::Create(uint32_t width, uint32_t height)
+ auto Texture2D::create(uint32_t width, uint32_t height) -> Ref<Texture2D>
{
- switch (Renderer::GetAPI())
+ switch (Renderer::get_api())
{
case RendererAPI::API::OpenGL:
- return CreateRef<OpenGLTexture2D>(width, height);
+ return create_ref<OpenGLTexture2D>(width, height);
case RendererAPI::API::Vulkan:
- return CreateRef<VulkanTexture2D>(width, height);
+ return create_ref<VulkanTexture2D>(width, height);
case RendererAPI::API::None:
return nullptr;
default:
@@ -21,14 +21,14 @@ namespace Donut
}
}
- Ref<Texture2D> Texture2D::Create(const std::string& path)
+ auto Texture2D::create(const std::string& path) -> Ref<Texture2D>
{
- switch (Renderer::GetAPI())
+ switch (Renderer::get_api())
{
case RendererAPI::API::OpenGL:
- return CreateRef<OpenGLTexture2D>(path);
+ return create_ref<OpenGLTexture2D>(path);
case RendererAPI::API::Vulkan:
- return CreateRef<VulkanTexture2D>(path);
+ return create_ref<VulkanTexture2D>(path);
case RendererAPI::API::None:
return nullptr;
default:
@@ -36,14 +36,14 @@ namespace Donut
}
}
- Ref<CubemapTexture> CubemapTexture::Create(uint32_t width, uint32_t height)
+ auto CubemapTexture::create(uint32_t width, uint32_t height) -> Ref<CubemapTexture>
{
- switch (Renderer::GetAPI())
+ switch (Renderer::get_api())
{
case RendererAPI::API::OpenGL:
- return CreateRef<OpenGLCubemapTexture>(width, height);
+ return create_ref<OpenGLCubemapTexture>(width, height);
case RendererAPI::API::Vulkan:
- return CreateRef<VulkanCubemapTexture>(width, height);
+ return create_ref<VulkanCubemapTexture>(width, height);
case RendererAPI::API::None:
return nullptr;
default:
@@ -51,14 +51,14 @@ namespace Donut
}
}
- Ref<CubemapTexture> CubemapTexture::CreateFromHDRI(const std::string& path)
+ auto CubemapTexture::create_from_hdri(const std::string& path) -> Ref<CubemapTexture>
{
- switch (Renderer::GetAPI())
+ switch (Renderer::get_api())
{
case RendererAPI::API::OpenGL:
- return CreateRef<OpenGLCubemapTexture>(path);
+ return create_ref<OpenGLCubemapTexture>(path);
case RendererAPI::API::Vulkan:
- return CreateRef<VulkanCubemapTexture>(path);
+ return create_ref<VulkanCubemapTexture>(path);
case RendererAPI::API::None:
return nullptr;
default:
diff --git a/src/Rendering/Texture.h b/src/Rendering/Texture.h
index 3e53b2d..e9b3e0a 100644
--- a/src/Rendering/Texture.h
+++ b/src/Rendering/Texture.h
@@ -1,6 +1,6 @@
#pragma once
-#include "Core/Memory.h"
+#include "core/memory.h"
#include <string>
#include <glm/glm.hpp>
@@ -12,14 +12,14 @@ namespace Donut
public:
virtual ~Texture() = default;
- virtual uint32_t GetWidth() const = 0;
- virtual uint32_t GetHeight() const = 0;
- virtual uint32_t GetRendererID() const = 0;
+ virtual auto get_width() const -> uint32_t = 0;
+ virtual auto get_height() const -> uint32_t = 0;
+ virtual auto get_renderer_id() const -> uint32_t = 0;
- virtual void SetData(void* data, uint32_t size) = 0;
- virtual void Bind(uint32_t slot = 0) const = 0;
- virtual void BindAsImage(uint32_t slot = 0,
- bool readOnly = false) const = 0;
+ virtual auto set_data(void* data, uint32_t size) -> void = 0;
+ virtual auto bind(uint32_t slot = 0) const -> void = 0;
+ virtual void bind_as_image(uint32_t slot = 0,
+ bool read_only = false) const = 0;
virtual bool operator==(const Texture& other) const = 0;
};
@@ -28,15 +28,15 @@ namespace Donut
: public Texture
{
public:
- static Ref<Texture2D> Create(uint32_t width, uint32_t height);
- static Ref<Texture2D> Create(const std::string& path);
+ static auto create(uint32_t width, uint32_t height) -> Ref<Texture2D>;
+ static auto create(const std::string& path) -> Ref<Texture2D>;
};
class CubemapTexture
: public Texture
{
public:
- static Ref<CubemapTexture> Create(uint32_t width, uint32_t height);
- static Ref<CubemapTexture> CreateFromHDRI(const std::string& path);
+ static auto create(uint32_t width, uint32_t height) -> Ref<CubemapTexture>;
+ static auto create_from_hdri(const std::string& path) -> Ref<CubemapTexture>;
};
}; \ No newline at end of file
diff --git a/src/Rendering/TextureManager.cpp b/src/Rendering/TextureManager.cpp
deleted file mode 100644
index 9110558..0000000
--- a/src/Rendering/TextureManager.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "TextureManager.h"
-#include "Platform/OpenGL/OpenGLTexture.h"
-#include "Platform/OpenGL/OpenGLRendererAPI.h"
-#include <glad/glad.h>
-
-namespace Donut
-{
- Ref<Texture2D> TextureManager::CreateTexture(uint32_t width, uint32_t height)
- {
- return CreateRef<OpenGLTexture2D>(width, height);
- }
-
- void TextureManager::BindTexture(uint32_t textureID, uint32_t slot)
- {
- RenderCommand::BindTexture(textureID, slot);
- }
-
- void TextureManager::BindImageTexture(uint32_t textureID, uint32_t slot, bool readOnly)
- {
- RenderCommand::BindImageTexture(textureID, slot, readOnly);
- }
-
- void TextureManager::SetTextureData(uint32_t textureID, void* data, uint32_t width, uint32_t height)
- {
- glBindTexture(GL_TEXTURE_2D, textureID);
- glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
- }
-
- void TextureManager::ResizeTexture(uint32_t textureID, uint32_t width, uint32_t height)
- {
- glBindTexture(GL_TEXTURE_2D, textureID);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
- }
-};
diff --git a/src/Rendering/TextureManager.h b/src/Rendering/TextureManager.h
deleted file mode 100644
index 0ab6c5f..0000000
--- a/src/Rendering/TextureManager.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include "Core/Memory.h"
-#include "Rendering/Texture.h"
-#include <cstdint>
-
-namespace Donut
-{
- class TextureManager
- {
- public:
- static Ref<Texture2D> CreateTexture(uint32_t width, uint32_t height);
-
- static void BindTexture(uint32_t textureID, uint32_t slot = 0);
- static void BindImageTexture(uint32_t textureID, uint32_t slot = 0, bool readOnly = false);
- static void SetTextureData(uint32_t textureID, void* data, uint32_t width, uint32_t height);
- static void ResizeTexture(uint32_t textureID, uint32_t width, uint32_t height);
- };
-};
diff --git a/src/Rendering/UniformBuffer.cpp b/src/Rendering/UniformBuffer.cpp
deleted file mode 100644
index 16cf04c..0000000
--- a/src/Rendering/UniformBuffer.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#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
deleted file mode 100644
index ce68908..0000000
--- a/src/Rendering/UniformBuffer.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#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
deleted file mode 100644
index 366675f..0000000
--- a/src/Rendering/VertexArray.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "VertexArray.h"
-#include "Renderer.h"
-
-#include "Platform/OpenGL/OpenGLVertexArray.h"
-#include "Platform/Vulkan/VulkanVertexArray.h"
-
-namespace Donut
-{
- uint32_t VertexBufferElement::GetSizeOfType(uint32_t type)
- {
- switch (type)
- {
- case 0x1406: return 4; // GL_FLOAT
- case 0x1405: return 4; // GL_UNSIGNED_INT
- case 0x1401: return 1; // GL_UNSIGNED_BYTE
- default: return 0;
- }
- }
-
- VertexArray* VertexArray::Create()
- {
- switch (Renderer::GetAPI())
- {
- case RendererAPI::API::OpenGL:
- return new OpenGLVertexArray();
- case RendererAPI::API::Vulkan:
- return new VulkanVertexArray();
- default:
- return nullptr;
- }
- }
-};
diff --git a/src/Rendering/VertexArray.h b/src/Rendering/VertexArray.h
deleted file mode 100644
index 10fff89..0000000
--- a/src/Rendering/VertexArray.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#pragma once
-
-#include "Core/Memory.h"
-
-#include "VertexBuffer.h"
-#include "IndexBuffer.h"
-
-#include <vector>
-
-namespace Donut
-{
- class VertexArray
- {
- public:
- virtual ~VertexArray() = default;
-
- virtual void Bind() const = 0;
- virtual void Unbind() const = 0;
-
- virtual void AddVertexBuffer(const Ref<VertexBuffer>& vertexBuffer) = 0;
- virtual void SetIndexBuffer(const Ref<IndexBuffer>& indexBuffer) = 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
deleted file mode 100644
index a7e2504..0000000
--- a/src/Rendering/VertexBuffer.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "VertexBuffer.h"
-#include "Renderer.h"
-
-#include "Platform/OpenGL/OpenGLVertexBuffer.h"
-#include "Platform/Vulkan/VulkanVertexBuffer.h"
-
-namespace Donut
-{
- VertexBuffer* VertexBuffer::Create(const void* data, uint32_t size)
- {
- switch (Renderer::GetAPI())
- {
- case RendererAPI::API::OpenGL:
- return new OpenGLVertexBuffer(data, size);
- case RendererAPI::API::Vulkan:
- return new VulkanVertexBuffer((float*)data, size);
- default:
- return nullptr;
- }
- }
-};
diff --git a/src/Rendering/VertexBuffer.h b/src/Rendering/VertexBuffer.h
deleted file mode 100644
index 35b9a84..0000000
--- a/src/Rendering/VertexBuffer.h
+++ /dev/null
@@ -1,73 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <vector>
-
-namespace Donut
-{
- struct VertexBufferElement
- {
- uint32_t type;
- uint32_t count;
- uint8_t normalized;
- uint32_t offset;
-
- static uint32_t GetSizeOfType(uint32_t type);
- };
-
- class VertexBufferLayout
- {
- public:
- VertexBufferLayout() = default;
- ~VertexBufferLayout() = default;
-
- template<typename T>
- void Push(uint32_t count)
- {
- static_assert(false);
- }
-
- template<>
- void Push<float>(uint32_t count)
- {
- m_Elements.push_back({ 0x1406, count, 0, m_Stride }); // GL_FLOAT
- m_Stride += count * VertexBufferElement::GetSizeOfType(0x1406);
- }
-
- template<>
- void Push<uint32_t>(uint32_t count)
- {
- m_Elements.push_back({ 0x1405, count, 0, m_Stride }); // GL_UNSIGNED_INT
- m_Stride += count * VertexBufferElement::GetSizeOfType(0x1405);
- }
-
- template<>
- void Push<uint8_t>(uint32_t count)
- {
- m_Elements.push_back({ 0x1401, count, 1, m_Stride }); // GL_UNSIGNED_BYTE
- m_Stride += count * VertexBufferElement::GetSizeOfType(0x1401);
- }
-
- inline const std::vector<VertexBufferElement>& GetElements() const { return m_Elements; }
- inline uint32_t GetStride() const { return m_Stride; }
-
- private:
- std::vector<VertexBufferElement> m_Elements;
- uint32_t m_Stride = 0;
- };
-
- class VertexBuffer
- {
- public:
- virtual ~VertexBuffer() = default;
-
- virtual void Bind() const = 0;
- virtual void Unbind() const = 0;
- virtual void SetData(const void* data, uint32_t size) = 0;
-
- virtual const VertexBufferLayout& GetLayout() const = 0;
- virtual void SetLayout(const VertexBufferLayout& layout) = 0;
-
- static VertexBuffer* Create(const void* data, uint32_t size);
- };
-};