[setup]: Prepare for Vulkan

19 files changed, 491 insertions, 2 deletions

diff --git a/src/Platform/Vulkan/.gitkeep b/src/Platform/Vulkan/.gitkeep
deleted file mode 100644
index cb7e3af..0000000
--- a/src/Platform/Vulkan/.gitkeep
+++ /dev/null
@@ -1 +0,0 @@
-Kill me
\ No newline at end of file
diff --git a/src/Platform/Vulkan/VulkanIndexBuffer.cpp b/src/Platform/Vulkan/VulkanIndexBuffer.cpp
new file mode 100644
index 0000000..930401e
--- /dev/null
+++ b/src/Platform/Vulkan/VulkanIndexBuffer.cpp
@@ -0,0 +1,25 @@
+#include "VulkanIndexBuffer.h"
+
+namespace Donut
+{
+	VulkanIndexBuffer::VulkanIndexBuffer(uint32_t* indices, uint32_t count)
+		: m_Count(count)
+	{
+		// TODO(Hachem): Implement Vulkan index buffer creation
+	}
+
+	VulkanIndexBuffer::~VulkanIndexBuffer()
+	{
+		// TODO(Hachem): Implement Vulkan index buffer cleanup
+	}
+
+	void VulkanIndexBuffer::Bind() const
+	{
+		// TODO(Hachem): Implement Vulkan index buffer binding
+	}
+
+	void VulkanIndexBuffer::Unbind() const
+	{
+		// TODO(Hachem): Implement Vulkan index buffer unbinding
+	}
+};
diff --git a/src/Platform/Vulkan/VulkanIndexBuffer.h b/src/Platform/Vulkan/VulkanIndexBuffer.h
new file mode 100644
index 0000000..74e69cf
--- /dev/null
+++ b/src/Platform/Vulkan/VulkanIndexBuffer.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "Rendering/IndexBuffer.h"
+
+namespace Donut 
+{
+	class VulkanIndexBuffer 
+		: public IndexBuffer
+	{
+	public:
+		VulkanIndexBuffer(uint32_t* indices, uint32_t count);
+		virtual ~VulkanIndexBuffer();
+
+		virtual void Bind()   const override;
+		virtual void Unbind() const override;
+
+		virtual uint32_t GetCount() const override { return m_Count; }
+	private:
+		uint32_t m_RendererID;
+		uint32_t m_Count;
+	};
+};
diff --git a/src/Platform/Vulkan/VulkanRendererAPI.cpp b/src/Platform/Vulkan/VulkanRendererAPI.cpp
new file mode 100644
index 0000000..377f100
--- /dev/null
+++ b/src/Platform/Vulkan/VulkanRendererAPI.cpp
@@ -0,0 +1,39 @@
+#include "VulkanRendererAPI.h"
+
+namespace Donut
+{
+	void VulkanRendererAPI::Init()
+	{
+		// TODO(Hachem): Implement Vulkan renderer API initialization
+	}
+
+	void VulkanRendererAPI::SetViewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height)
+	{
+		// TODO(Hachem): Implement Vulkan viewport setting
+	}
+
+	void VulkanRendererAPI::SetClearColor(const glm::vec4& color)
+	{
+		// TODO(Hachem): Implement Vulkan clear color setting
+	}
+
+	void VulkanRendererAPI::Clear()
+	{
+		// TODO(Hachem): Implement Vulkan clear
+	}
+
+	void VulkanRendererAPI::EnableDepthTest()
+	{
+		// TODO(Hachem): Implement Vulkan depth test enabling
+	}
+
+	void VulkanRendererAPI::SetFaceCulling(bool enabled)
+	{
+		// TODO(Hachem): Implement Vulkan face culling setting
+	}
+
+	void VulkanRendererAPI::DrawIndexed(const std::shared_ptr<VertexArray>& vertexArray, uint32_t indexCount)
+	{
+		// TODO(Hachem): Implement Vulkan indexed drawing
+	}
+};
diff --git a/src/Platform/Vulkan/VulkanRendererAPI.h b/src/Platform/Vulkan/VulkanRendererAPI.h
new file mode 100644
index 0000000..94d62e2
--- /dev/null
+++ b/src/Platform/Vulkan/VulkanRendererAPI.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "Rendering/RendererAPI.h"
+
+namespace Donut
+{
+	class VulkanRendererAPI 
+		: public RendererAPI
+	{
+	public:
+		virtual void Init()                                       override;
+		virtual void SetViewport(uint32_t x, uint32_t y,
+								 uint32_t width, uint32_t height) override;
+		virtual void SetClearColor(const glm::vec4& color)        override;
+		virtual void Clear()                                      override;
+		virtual void EnableDepthTest()                            override;
+		virtual void SetFaceCulling(bool enabled)                 override;
+
+		virtual void DrawIndexed(const std::shared_ptr<VertexArray>& vertexArray, 
+								 uint32_t indexCount = 0) override;
+	};
+};
diff --git a/src/Platform/Vulkan/VulkanShader.cpp b/src/Platform/Vulkan/VulkanShader.cpp
new file mode 100644
index 0000000..cbc0f54
--- /dev/null
+++ b/src/Platform/Vulkan/VulkanShader.cpp
@@ -0,0 +1,125 @@
+#include "VulkanShader.h"
+
+#include <fstream>
+#include <glm/gtc/type_ptr.hpp>
+
+namespace Donut
+{
+	VulkanShader::VulkanShader(const std::string& filepath)
+	{
+		// TODO(Hachem): Implement Vulkan shader creation from filepath
+	}
+
+	VulkanShader::VulkanShader(const std::string& name, const std::string& vertexSrc, const std::string& fragmentSrc)
+		: m_Name(name)
+	{
+		// TODO(Hachem): Implement Vulkan shader creation from source
+	}
+
+	VulkanShader::~VulkanShader()
+	{
+		// TODO(Hachem): Implement Vulkan shader cleanup
+	}
+
+	void VulkanShader::Bind() const
+	{
+		// TODO(Hachem): Implement Vulkan shader binding
+	}
+
+	void VulkanShader::Unbind() const
+	{
+		// TODO(Hachem): Implement Vulkan shader unbinding
+	}
+
+	void VulkanShader::SetInt(const std::string& name, int value)
+	{
+		// TODO(Hachem): Implement Vulkan shader int uniform setting
+	}
+
+	void VulkanShader::SetIntArray(const std::string& name, int* values, uint32_t count)
+	{
+		// TODO(Hachem): Implement Vulkan shader int array uniform setting
+	}
+
+	void VulkanShader::SetFloat(const std::string& name, float value)
+	{
+		// TODO(Hachem): Implement Vulkan shader float uniform setting
+	}
+
+	void VulkanShader::SetFloat2(const std::string& name, const glm::vec2& value)
+	{
+		// TODO(Hachem): Implement Vulkan shader float2 uniform setting
+	}
+
+	void VulkanShader::SetFloat3(const std::string& name, const glm::vec3& value)
+	{
+		// TODO(Hachem): Implement Vulkan shader float3 uniform setting
+	}
+
+	void VulkanShader::SetFloat4(const std::string& name, const glm::vec4& value)
+	{
+		// TODO(Hachem): Implement Vulkan shader float4 uniform setting
+	}
+
+	void VulkanShader::SetMat4(const std::string& name, const glm::mat4& value)
+	{
+		// TODO(Hachem): Implement Vulkan shader mat4 uniform setting
+	}
+
+	void VulkanShader::UploadUniformInt(const std::string& name, int value)
+	{
+		// TODO(Hachem): Implement Vulkan uniform int upload
+	}
+
+	void VulkanShader::UploadUniformIntArray(const std::string& name, int* values, uint32_t count)
+	{
+		// TODO(Hachem): Implement Vulkan uniform int array upload
+	}
+
+	void VulkanShader::UploadUniformFloat(const std::string& name, float value)
+	{
+		// TODO(Hachem): Implement Vulkan uniform float upload
+	}
+
+	void VulkanShader::UploadUniformFloat2(const std::string& name, const glm::vec2& value)
+	{
+		// TODO(Hachem): Implement Vulkan uniform float2 upload
+	}
+
+	void VulkanShader::UploadUniformFloat3(const std::string& name, const glm::vec3& value)
+	{
+		// TODO(Hachem): Implement Vulkan uniform float3 upload
+	}
+
+	void VulkanShader::UploadUniformFloat4(const std::string& name, const glm::vec4& value)
+	{
+		// TODO(Hachem): Implement Vulkan uniform float4 upload
+	}
+
+	void VulkanShader::UploadUniformMat3(const std::string& name, const glm::mat3& matrix)
+	{
+		// TODO(Hachem): Implement Vulkan uniform mat3 upload
+	}
+
+	void VulkanShader::UploadUniformMat4(const std::string& name, const glm::mat4& matrix)
+	{
+		// TODO(Hachem): Implement Vulkan uniform mat4 upload
+	}
+
+	std::string VulkanShader::ReadFile(const std::string& filepath)
+	{
+		// TODO(Hachem): Implement file reading for Vulkan shader
+		return "";
+	}
+
+	std::unordered_map<uint32_t, std::string> VulkanShader::PreProcess(const std::string& source)
+	{
+		// TODO(Hachem): Implement shader preprocessing for Vulkan
+		return {};
+	}
+
+	void VulkanShader::Compile(const std::unordered_map<uint32_t, std::string>& shaderSources)
+	{
+		// TODO(Hachem): Implement Vulkan shader compilation
+	}
+};
diff --git a/src/Platform/Vulkan/VulkanShader.h b/src/Platform/Vulkan/VulkanShader.h
new file mode 100644
index 0000000..fd99907
--- /dev/null
+++ b/src/Platform/Vulkan/VulkanShader.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "Rendering/Shader.h"
+
+#include <string>
+#include <unordered_map>
+
+namespace Donut 
+{
+	class VulkanShader 
+		: public Shader
+	{
+	public:
+		VulkanShader(const std::string& filepath);
+		VulkanShader(const std::string& name, const std::string& vertexSrc, const std::string& fragmentSrc);
+		virtual ~VulkanShader();
+
+		virtual void Bind()   const override;
+		virtual void Unbind() const override;
+
+		virtual void SetInt(const std::string& name, int value)                        override;
+		virtual void SetIntArray(const std::string& name, int* values, uint32_t count) override;
+		virtual void SetFloat(const std::string& name, float value)                    override;
+		virtual void SetFloat2(const std::string& name, const glm::vec2& value)        override;
+		virtual void SetFloat3(const std::string& name, const glm::vec3& value)        override;
+		virtual void SetFloat4(const std::string& name, const glm::vec4& value)        override;
+		virtual void SetMat4(const std::string& name, const glm::mat4& value)          override;
+
+		virtual const std::string& GetName() const override { return m_Name; }
+
+		void UploadUniformInt(const std::string& name, int value);
+		void UploadUniformIntArray(const std::string& name, int* values, uint32_t count);
+		void UploadUniformFloat(const std::string& name, float value);
+		void UploadUniformFloat2(const std::string& name, const glm::vec2& value);
+		void UploadUniformFloat3(const std::string& name, const glm::vec3& value);
+		void UploadUniformFloat4(const std::string& name, const glm::vec4& value);
+		void UploadUniformMat3(const std::string& name, const glm::mat3& matrix);
+		void UploadUniformMat4(const std::string& name, const glm::mat4& matrix);
+	private:
+		std::string ReadFile(const std::string& filepath);
+		std::unordered_map<uint32_t, std::string> PreProcess(const std::string& source);
+		void Compile(const std::unordered_map<uint32_t, std::string>& shaderSources);
+		uint32_t    m_RendererID;
+		std::string m_Name;
+	};
+};
diff --git a/src/Platform/Vulkan/VulkanTexture.cpp b/src/Platform/Vulkan/VulkanTexture.cpp
new file mode 100644
index 0000000..971972c
--- /dev/null
+++ b/src/Platform/Vulkan/VulkanTexture.cpp
@@ -0,0 +1,31 @@
+#include "VulkanTexture.h"
+
+namespace Donut
+{
+	VulkanTexture2D::VulkanTexture2D(uint32_t width, uint32_t height)
+		: m_Width(width), m_Height(height)
+	{
+		// TODO(Hachem): Implement Vulkan texture creation with dimensions
+	}
+
+	VulkanTexture2D::VulkanTexture2D(const std::string& path)
+		: m_Path(path)
+	{
+		// TODO(Hachem): Implement Vulkan texture creation from file
+	}
+
+	VulkanTexture2D::~VulkanTexture2D()
+	{
+		// TODO(Hachem): Implement Vulkan texture cleanup
+	}
+
+	void VulkanTexture2D::SetData(void* data, uint32_t size)
+	{
+		// TODO(Hachem): Implement Vulkan texture data setting
+	}
+
+	void VulkanTexture2D::Bind(uint32_t slot) const
+	{
+		// TODO(Hachem): Implement Vulkan texture binding
+	}
+};
diff --git a/src/Platform/Vulkan/VulkanTexture.h b/src/Platform/Vulkan/VulkanTexture.h
new file mode 100644
index 0000000..2dcc3cf
--- /dev/null
+++ b/src/Platform/Vulkan/VulkanTexture.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Rendering/Texture.h"
+
+namespace Donut
+{
+	class VulkanTexture2D
+		: public Texture2D
+	{
+	public:
+		VulkanTexture2D(uint32_t width, uint32_t height);
+		VulkanTexture2D(const std::string& path);
+		virtual ~VulkanTexture2D();
+
+		virtual uint32_t GetWidth()  const override { return m_Width; }
+		virtual uint32_t GetHeight() const override { return m_Height; }
+
+		virtual void SetData(void* data, uint32_t size) override;
+		virtual void Bind(uint32_t slot = 0)      const override;
+
+		virtual bool operator==(const Texture& other) const override
+		{
+			return m_RendererID == ((VulkanTexture2D&)other).m_RendererID;
+		}
+
+	private:
+		std::string m_Path;
+		uint32_t    m_Width, m_Height;
+		uint32_t    m_RendererID;
+		uint32_t    m_InternalFormat, m_DataFormat;
+	};
+};
diff --git a/src/Platform/Vulkan/VulkanVertexArray.cpp b/src/Platform/Vulkan/VulkanVertexArray.cpp
new file mode 100644
index 0000000..9fda0a3
--- /dev/null
+++ b/src/Platform/Vulkan/VulkanVertexArray.cpp
@@ -0,0 +1,36 @@
+#include "VulkanVertexArray.h"
+
+namespace Donut
+{
+	VulkanVertexArray::VulkanVertexArray()
+	{
+		// TODO(Hachem): Implement Vulkan vertex array creation
+	}
+
+	VulkanVertexArray::~VulkanVertexArray()
+	{
+		// TODO(Hachem): Implement Vulkan vertex array cleanup
+	}
+
+	void VulkanVertexArray::Bind() const
+	{
+		// TODO(Hachem): Implement Vulkan vertex array binding
+	}
+
+	void VulkanVertexArray::Unbind() const
+	{
+		// TODO(Hachem): Implement Vulkan vertex array unbinding
+	}
+
+	void VulkanVertexArray::AddVertexBuffer(const std::shared_ptr<VertexBuffer>& vertexBuffer)
+	{
+		// TODO(Hachem): Implement Vulkan vertex buffer addition
+		m_VertexBuffers.push_back(vertexBuffer);
+	}
+
+	void VulkanVertexArray::SetIndexBuffer(const std::shared_ptr<IndexBuffer>& indexBuffer)
+	{
+		// TODO(Hachem): Implement Vulkan index buffer setting
+		m_IndexBuffer = indexBuffer;
+	}
+};
diff --git a/src/Platform/Vulkan/VulkanVertexArray.h b/src/Platform/Vulkan/VulkanVertexArray.h
new file mode 100644
index 0000000..a6eef6a
--- /dev/null
+++ b/src/Platform/Vulkan/VulkanVertexArray.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "Rendering/VertexArray.h"
+
+namespace Donut
+{
+	class VulkanVertexArray 
+		: public VertexArray
+	{
+	public:
+		VulkanVertexArray();
+		virtual ~VulkanVertexArray();
+
+		virtual void Bind()   const override;
+		virtual void Unbind() const override;
+
+		virtual void AddVertexBuffer(const std::shared_ptr<VertexBuffer>& vertexBuffer) override;
+		virtual void SetIndexBuffer(const std::shared_ptr<IndexBuffer>& indexBuffer)   override;
+
+		virtual const std::vector<std::shared_ptr<VertexBuffer>>& GetVertexBuffers() const { return m_VertexBuffers; }
+		virtual const std::shared_ptr<IndexBuffer>& GetIndexBuffer()                 const { return m_IndexBuffer;   }
+	private:
+		uint32_t                                   m_RendererID;
+		std::vector<std::shared_ptr<VertexBuffer>> m_VertexBuffers;
+		std::shared_ptr<IndexBuffer>               m_IndexBuffer;
+	};
+};
diff --git a/src/Platform/Vulkan/VulkanVertexBuffer.cpp b/src/Platform/Vulkan/VulkanVertexBuffer.cpp
new file mode 100644
index 0000000..f77cbe4
--- /dev/null
+++ b/src/Platform/Vulkan/VulkanVertexBuffer.cpp
@@ -0,0 +1,34 @@
+#include "VulkanVertexBuffer.h"
+
+namespace Donut
+{
+	VulkanVertexBuffer::VulkanVertexBuffer(uint32_t size)
+	{
+		// TODO(Hachem): Implement Vulkan vertex buffer creation with size
+	}
+
+	VulkanVertexBuffer::VulkanVertexBuffer(float* vertices, uint32_t size)
+	{
+		// TODO(Hachem): Implement Vulkan vertex buffer creation with data
+	}
+
+	VulkanVertexBuffer::~VulkanVertexBuffer()
+	{
+		// TODO(Hachem): Implement Vulkan vertex buffer cleanup
+	}
+
+	void VulkanVertexBuffer::Bind() const
+	{
+		// TODO(Hachem): Implement Vulkan vertex buffer binding
+	}
+
+	void VulkanVertexBuffer::Unbind() const
+	{
+		// TODO(Hachem): Implement Vulkan vertex buffer unbinding
+	}
+
+	void VulkanVertexBuffer::SetData(const void* data, uint32_t size)
+	{
+		// TODO(Hachem): Implement Vulkan vertex buffer data setting
+	}
+};
\ No newline at end of file
diff --git a/src/Platform/Vulkan/VulkanVertexBuffer.h b/src/Platform/Vulkan/VulkanVertexBuffer.h
new file mode 100644
index 0000000..2208fd8
--- /dev/null
+++ b/src/Platform/Vulkan/VulkanVertexBuffer.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "Rendering/VertexBuffer.h"
+
+namespace Donut
+{
+	class VulkanVertexBuffer
+        : public VertexBuffer
+	{
+	public:
+		VulkanVertexBuffer(uint32_t size);
+		VulkanVertexBuffer(float* vertices, uint32_t size);
+		virtual ~VulkanVertexBuffer();
+
+		virtual void Bind()   const override;
+		virtual void Unbind() const override;
+
+		virtual void SetData(const void* data, uint32_t size) override;
+
+		virtual const BufferLayout& GetLayout()      const override { return m_Layout;  }
+		virtual void SetLayout(const BufferLayout& layout) override { m_Layout = layout; }
+
+	private:
+		uint32_t     m_RendererID;
+		BufferLayout m_Layout;
+	};
+};
diff --git a/src/Rendering/IndexBuffer.cpp b/src/Rendering/IndexBuffer.cpp
index de9cb87..185684b 100644
--- a/src/Rendering/IndexBuffer.cpp
+++ b/src/Rendering/IndexBuffer.cpp
@@ -2,6 +2,7 @@
 #include "Renderer.h"
 
 #include "Platform/OpenGL/OpenGLIndexBuffer.h"
+#include "Platform/Vulkan/VulkanIndexBuffer.h"
 
 namespace Donut 
 {
@@ -11,6 +12,8 @@ namespace Donut
         {
             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/Renderer.cpp b/src/Rendering/Renderer.cpp
index 9aa3dd3..4f61619 100644
--- a/src/Rendering/Renderer.cpp
+++ b/src/Rendering/Renderer.cpp
@@ -1,5 +1,6 @@
 #include "Renderer.h"
 #include "Platform/OpenGL/OpenGLRendererAPI.h"
+#include "Platform/Vulkan/VulkanRendererAPI.h"
 #include <memory>
 #include <glm/gtc/matrix_transform.hpp>
 
@@ -11,6 +12,8 @@ namespace Donut
         {
             case API::OpenGL:
                 return std::make_unique<OpenGLRendererAPI>();
+            case API::Vulkan:
+                return std::make_unique<VulkanRendererAPI>();
             default:
                 return nullptr;
         }
diff --git a/src/Rendering/Shader.cpp b/src/Rendering/Shader.cpp
index a791c98..e38ce65 100644
--- a/src/Rendering/Shader.cpp
+++ b/src/Rendering/Shader.cpp
@@ -1,6 +1,7 @@
 #include "Shader.h"
 #include "Renderer.h"
 #include "Platform/OpenGL/OpenGLShader.h"
+#include "Platform/Vulkan/VulkanShader.h"
 #include <memory>
 
 namespace Donut
@@ -11,6 +12,8 @@ namespace Donut
         {
             case RendererAPI::API::OpenGL:
                 return new OpenGLShader(filepath);
+            case RendererAPI::API::Vulkan:
+                return new VulkanShader(filepath);
             default:
                 return nullptr;
         }
@@ -22,6 +25,8 @@ namespace Donut
         {
             case RendererAPI::API::OpenGL:
                 return new OpenGLShader(name, vertexSrc, fragmentSrc);
+            case RendererAPI::API::Vulkan:
+                return new VulkanShader(name, vertexSrc, fragmentSrc);
             default:
                 return nullptr;
         }
@@ -33,6 +38,8 @@ namespace Donut
         {
             case RendererAPI::API::OpenGL:
                 return new OpenGLShader(name, computeSrc);
+            case RendererAPI::API::Vulkan:
+                return new VulkanShader(name, computeSrc);
             default:
                 return nullptr;
         }
diff --git a/src/Rendering/Texture.cpp b/src/Rendering/Texture.cpp
index a52a469..3a86dba 100644
--- a/src/Rendering/Texture.cpp
+++ b/src/Rendering/Texture.cpp
@@ -1,6 +1,7 @@
 #include "Texture.h"
 #include "Renderer.h"
 #include "../Platform/OpenGL/OpenGLTexture.h"
+#include "../Platform/Vulkan/VulkanTexture.h"
 
 namespace Donut
 {
@@ -10,6 +11,8 @@ namespace Donut
         {
         case RendererAPI::API::OpenGL:
             return std::make_shared<OpenGLTexture2D>(width, height);
+        case RendererAPI::API::Vulkan:
+            return std::make_shared<VulkanTexture2D>(width, height);
         case RendererAPI::API::None:
             return nullptr;
         default:
@@ -23,6 +26,8 @@ namespace Donut
         {
         case RendererAPI::API::OpenGL:
             return std::make_shared<OpenGLTexture2D>(path);
+        case RendererAPI::API::Vulkan:
+            return std::make_shared<VulkanTexture2D>(path);
         case RendererAPI::API::None:
             return nullptr;
         default:
diff --git a/src/Rendering/VertexArray.cpp b/src/Rendering/VertexArray.cpp
index 87db8fb..2b2549c 100644
--- a/src/Rendering/VertexArray.cpp
+++ b/src/Rendering/VertexArray.cpp
@@ -1,6 +1,7 @@
 #include "VertexArray.h"
 #include "Renderer.h"
 #include "Platform/OpenGL/OpenGLVertexArray.h"
+#include "Platform/Vulkan/VulkanVertexArray.h"
 
 namespace Donut
 {
@@ -21,6 +22,8 @@ namespace Donut
         {
             case RendererAPI::API::OpenGL:
                 return new OpenGLVertexArray();
+            case RendererAPI::API::Vulkan:
+                return new VulkanVertexArray();
             default:
                 return nullptr;
         }
diff --git a/src/Rendering/VertexBuffer.cpp b/src/Rendering/VertexBuffer.cpp
index bd9c0f9..57b4d87 100644
--- a/src/Rendering/VertexBuffer.cpp
+++ b/src/Rendering/VertexBuffer.cpp
@@ -1,15 +1,18 @@
 #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) 
+    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;
         }