Add VertexBuffer class

openVulkanoCpp/Scene/VertexBuffer.hpp

@@ -0,0 +1,54 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include "Base/Render/RenderResource.hpp"
+#include "Scene/UpdateFrequency.hpp"
+
+namespace OpenVulkano::Scene
+{
+	class VertexBuffer final : public RenderResourceHolder<VertexBuffer>
+	{
+	public:
+		size_t size = 0;
+		const void* data = nullptr;
+		UpdateFrequency updateFrequency = UpdateFrequency::Never;
+		bool updated = true;
+		bool ownsMemory = true;
+
+		~VertexBuffer() { Close(); }
+
+		void Init(size_t size, const void* data)
+		{
+			this->size = size;
+			this->data = data;
+			this->ownsMemory = false;
+		}
+
+		void Init(size_t size)
+		{
+			this->size = size;
+			this->data = malloc(size);
+			this->ownsMemory = true;
+		}
+
+		template<typename T>
+		T* Init(size_t count)
+		{
+			Init(count * sizeof(T));
+			return static_cast<T*>(const_cast<void*>(data));
+		}
+
+		void Close()
+		{
+			if (ownsMemory && data) free(const_cast<void*>(data));
+			data = nullptr;
+		}
+
+		UpdateFrequency GetUpdateFrequency() const { return updateFrequency; }
+	};
+}

openVulkanoCpp/Vulkan/Resources/ResourceManager.cpp

@@ -5,6 +5,9 @@
  */
 
 #include "ResourceManager.hpp"
+
+#include <Scene/VertexBuffer.hpp>
+
 #include "ManagedBuffer.hpp"
 #include "MemoryAllocation.hpp"
 #include "Scene/Vertex.hpp"
@@ -21,6 +24,7 @@
 #include "Vulkan/Scene/VulkanTexture.hpp"
 #include "Vulkan/Scene/VulkanCamera.hpp"
 #include "Vulkan/Scene/VulkanUniformBuffer.hpp"
+#include "Vulkan/Scene/VulkanVertexBuffer.hpp"
 
 namespace OpenVulkano::Vulkan
 {
@@ -173,6 +177,21 @@ namespace OpenVulkano::Vulkan
 		return geometry->GetRenderResource();
 	}
 
+	VulkanVertexBuffer* ResourceManager::PrepareVertexBuffer(Scene::VertexBuffer* vbo)
+	{
+		const std::unique_lock lock(mutex);
+		if(!vbo->HasRenderResource())
+		{
+			ManagedBuffer::Ptr vertexBuffer =
+					CreateDeviceOnlyBufferWithData(vbo->size, vk::BufferUsageFlagBits::eVertexBuffer, vbo->data);
+			ManagedBuffer::Ptr indexBuffer;
+			VulkanVertexBuffer* vkVbo = new VulkanVertexBuffer(vbo, vertexBuffer);
+			vertexBuffers.emplace_back(vkVbo);
+			return vkVbo;
+		}
+		return vbo->GetRenderResource();
+	}
+
 	void ResourceManager::PrepareMaterial(Scene::Material* material)
 	{
 		if (material->texture && !material->texture->HasRenderResource())

openVulkanoCpp/Vulkan/Resources/ResourceManager.hpp

@@ -34,6 +34,7 @@ namespace OpenVulkano
 		class Shader;
 		class Camera;
 		class UniformBuffer;
+		class VertexBuffer;
 	}
 
 	namespace Vulkan
@@ -45,11 +46,12 @@ namespace OpenVulkano
 		class VulkanNode;
 		class VulkanShader;
 		class VulkanUniformBuffer;
+		class VulkanVertexBuffer;
 		class UniformBuffer;
 		class ManagedBuffer;
 		class MemoryAllocation;
 
-		class ResourceManager : public IShaderOwner, public IResourceManager
+		class ResourceManager final : public IShaderOwner, public IResourceManager
 		{
 			friend UniformBuffer;
 			friend VulkanTexture;
@@ -63,6 +65,7 @@ namespace OpenVulkano
 			MemoryPool memPool;
 			std::vector<Unique<VulkanShader>> shaders;
 			std::vector<Unique<VulkanGeometry>> geometries;
+			std::vector<Unique<VulkanVertexBuffer>> vertexBuffers;
 			std::vector<Unique<VulkanNode>> nodes;
 			std::vector<Unique<VulkanTexture>> textures;
 			std::vector<Unique<VulkanCamera>> cameras;
@@ -100,6 +103,8 @@ namespace OpenVulkano
 
 			VulkanUniformBuffer* PrepareUniformBuffer(Scene::UniformBuffer* buffer);
 
+			VulkanVertexBuffer* PrepareVertexBuffer(Scene::VertexBuffer* vbo);
+
 			VulkanNode* PrepareNode(Scene::Node* node);
 
 			VulkanTexture* PrepareTexture(Scene::Texture* texture);

openVulkanoCpp/Vulkan/Scene/VulkanVertexBuffer.hpp

@@ -0,0 +1,43 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include "IRecordable.hpp"
+#include "Scene/Scene.hpp"
+#include "Scene/VertexBuffer.hpp"
+#include "Vulkan/Resources/ManagedBuffer.hpp"
+
+namespace OpenVulkano::Vulkan
+{
+	class VulkanVertexBuffer final : public IRenderResource<Scene::VertexBuffer>
+	{
+		ManagedBuffer::Ptr m_vertexBuffer;
+
+	public:
+		VulkanVertexBuffer(Scene::VertexBuffer* vbo, ManagedBuffer::Ptr& vertexBuffer)
+				: IRenderResource<Scene::VertexBuffer>(vbo) , m_vertexBuffer(std::move(vertexBuffer))
+		{}
+
+		~VulkanVertexBuffer() override = default;
+
+		void RecordBind(vk::CommandBuffer& cmdBuffer)
+		{
+			const vk::DeviceSize m_offsets = 0;
+			cmdBuffer.bindVertexBuffers(0, 1, &m_vertexBuffer->buffer, &m_offsets);
+		}
+
+		void RecordDraw(vk::CommandBuffer& cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex = 0, uint32_t firstInstance = 0)
+		{
+			cmdBuffer.draw(vertexCount, instanceCount, firstVertex, firstInstance);
+		}
+
+		void Release() override
+		{
+			//TODO
+		}
+	};
+}