Merge branch 'main' into tymii/17-inconsistent-file-naming

Author: karnkaul

App/Src/Main.cpp

@@ -50,20 +50,21 @@ namespace
 		const auto& renderDevice = engine.RenderDevice();
 		if (!shader.Load(renderDevice.get_device(), vertexSpirV, fragmentSpirV)) { throw std::runtime_error{"Failed to load shaders"}; }
 
-		const auto pipelineLayout = renderDevice.get_device().createPipelineLayoutUnique({});
+		constexpr auto vertices = std::array{
+			Tkge::Graphics::Vertex{.position = {-0.5f, -0.5f}, .colour = kvf::red_v.to_vec4()},
+			Tkge::Graphics::Vertex{.position = {0.5f, -0.5f}, .colour = kvf::green_v.to_vec4()},
+			Tkge::Graphics::Vertex{.position = {0.5f, 0.5f}, .colour = kvf::blue_v.to_vec4()},
+			Tkge::Graphics::Vertex{.position = {-0.5f, 0.5f}, .colour = kvf::yellow_v.to_vec4()},
+		};
 
-		const auto pipelineState = kvf::PipelineState{
-			.vertex_bindings = {},
-			.vertex_attributes = {},
-			.vertex_shader = shader.VertexModule(),
-			.fragment_shader = shader.FragmentModule(),
+		constexpr auto indices = std::array{
+			0u, 1u, 2u, 2u, 3u, 0u,
 		};
-		const auto pipelineFormat = kvf::PipelineFormat{
-			.samples = engine.FramebufferSamples(),
-			.color = engine.FramebufferFormat(),
+
+		const auto primitive = Tkge::Graphics::Primitive{
+			.vertices = vertices,
+			.indices = indices,
 		};
-		const auto pipeline = renderDevice.create_pipeline(*pipelineLayout, pipelineState, pipelineFormat);
-		if (!pipeline) { throw std::runtime_error{"Failed to create graphics pipeline"}; }
 
 		auto wireframe = false;
 		auto lineWidth = 3.0f;
@@ -84,7 +85,7 @@ namespace
 				renderer.BindShader(shader);
 				renderer.SetLineWidth(lineWidth);
 				renderer.SetWireframe(wireframe);
-				renderer.Draw(3);
+				renderer.Draw(primitive);
 			}
 
 			engine.Present();

Assets/shaders/default.frag

@@ -45,7 +45,7 @@ namespace Tkge
 		kvf::RenderDevice _renderDevice;
 		kvf::RenderPass _renderPass;
 
-		Graphics::ResourcePool _resourcePool;
+		std::unique_ptr<Graphics::IResourcePool> _resourcePool{};
 
 		vk::CommandBuffer _cmd{};
 		AssetLoader _assetLoader;

Assets/shaders/default.vert

@@ -0,0 +1,15 @@
+#pragma once
+#include <vulkan/vulkan.hpp>
+
+namespace Tkge::Graphics
+{
+	/// \brief Description of a unique Pipeline's fixed state.
+	struct PipelineFixedState
+	{
+		/// \brief Colour image format of target Render Pass.
+		vk::Format colourFormat{};
+
+		vk::PrimitiveTopology topology{vk::PrimitiveTopology::eTriangleList};
+		vk::PolygonMode polygonMode{vk::PolygonMode::eFill};
+	};
+} // namespace Tkge::Graphics

Assets/shaders/triangle.vert

@@ -0,0 +1,14 @@
+#pragma once
+#include <Tkge/Graphics/Vertex.hpp>
+#include <span>
+
+namespace Tkge::Graphics
+{
+	struct Primitive
+	{
+		std::span<const Vertex> vertices{};
+		std::span<const std::uint32_t> indices{};
+
+		vk::PrimitiveTopology topology{vk::PrimitiveTopology::eTriangleList};
+	};
+} // namespace Tkge::Graphics

Lib/Include/Tkge/Engine.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <Tkge/Graphics/Primitive.hpp>
 #include <Tkge/Graphics/ResourcePool.hpp>
 #include <kvf/render_pass.hpp>
 
@@ -14,7 +15,7 @@ namespace Tkge::Graphics
 
 		Renderer() = default;
 
-		explicit Renderer(kvf::RenderPass* renderPass, ResourcePool* resourcePool, vk::CommandBuffer commandBuffer, glm::ivec2 framebufferSize);
+		explicit Renderer(kvf::RenderPass* renderPass, IResourcePool* resourcePool, vk::CommandBuffer commandBuffer, glm::ivec2 framebufferSize);
 		~Renderer() { EndRender(); }
 
 		[[nodiscard]] bool IsRendering() const { return _renderPass != nullptr; }
@@ -24,14 +25,15 @@ namespace Tkge::Graphics
 		void SetLineWidth(float width);
 		void SetWireframe(bool wireframe);
 
-		// temporary, until we have vertices, primitives, etc
-		void Draw(std::uint32_t vertices);
+		void Draw(const Primitive& primitive);
 
 		explicit operator bool() const { return IsRendering(); }
 
 	  private:
+		void BindVboAndDraw(const Primitive& primitive) const;
+
 		kvf::RenderPass* _renderPass{};
-		ResourcePool* _resourcePool{};
+		IResourcePool* _resourcePool{};
 
 		const Shader* _shader{};
 		vk::Pipeline _pipeline{};

Lib/Include/Tkge/Graphics/PipelineFixedState.hpp

@@ -1,43 +1,24 @@
 #pragma once
+#include <Tkge/Graphics/PipelineFixedState.hpp>
 #include <Tkge/Graphics/Shader.hpp>
-#include <kvf/render_device.hpp>
-#include <unordered_map>
+#include <kvf/vma.hpp>
 
 namespace Tkge::Graphics
 {
-	class PipelinePool
-	{
-	  public:
-		struct Params
-		{
-			vk::Format colourFormat{};
-
-			vk::PrimitiveTopology topology{vk::PrimitiveTopology::eTriangleList};
-			vk::PolygonMode polygonMode{vk::PolygonMode::eFill};
-		};
-
-		explicit PipelinePool(gsl::not_null<const kvf::RenderDevice*> renderDevice, vk::SampleCountFlagBits framebufferSamples);
-
-		[[nodiscard]] vk::PipelineLayout PipelineLayout() const { return *_pipelineLayout; }
+	using Buffer = kvf::vma::Buffer;
 
-		[[nodiscard]] vk::Pipeline GetPipeline(const Shader& shader, const Params& params);
-
-	  private:
-		gsl::not_null<const kvf::RenderDevice*> _renderDevice;
-		vk::SampleCountFlagBits _framebufferSamples;
-
-		vk::UniquePipelineLayout _pipelineLayout{};
-		std::unordered_map<std::size_t, vk::UniquePipeline> _pipelines{};
-	};
-
-	class ResourcePool
+	class IResourcePool : public klib::Polymorphic
 	{
 	  public:
-		explicit ResourcePool(gsl::not_null<const kvf::RenderDevice*> renderDevice, vk::SampleCountFlagBits framebufferSamples)
-			: pipelinePool(renderDevice, framebufferSamples)
-		{
-		}
+		[[nodiscard]] virtual vk::PipelineLayout PipelineLayout() const = 0;
+
+		/// \brief Get the Pipeline identified by the input parameters.
+		/// \param shader Shader that will be used in draw calls (dynamic Pipeline state).
+		/// \param state Fixed Pipeline state.
+		/// \returns Existing Pipeline if already cached, otherwise a newly created one (unless creation fails).
+		[[nodiscard]] virtual vk::Pipeline GetPipeline(const Shader& shader, const PipelineFixedState& state) = 0;
 
-		PipelinePool pipelinePool;
+		/// \brief Allocate a Buffer for given usage and of given size.
+		[[nodiscard]] virtual Buffer& AllocateBuffer(vk::BufferUsageFlags usage, vk::DeviceSize size) = 0;
 	};
 } // namespace Tkge::Graphics

Lib/Include/Tkge/Graphics/Primitive.hpp

@@ -0,0 +1,13 @@
+#pragma once
+#include <glm/vec2.hpp>
+#include <glm/vec4.hpp>
+
+namespace Tkge::Graphics
+{
+	struct Vertex
+	{
+		glm::vec2 position{};
+		glm::vec4 colour{1.0f};
+		glm::vec2 uv{};
+	};
+} // namespace Tkge::Graphics

Lib/Include/Tkge/Graphics/Renderer.hpp

@@ -0,0 +1,18 @@
+#pragma once
+#include <Tkge/Graphics/Vertex.hpp>
+#include <cstdint>
+#include <span>
+#include <vector>
+
+namespace Tkge::Graphics
+{
+	struct VertexArray
+	{
+		std::vector<Vertex> vertices{};
+		std::vector<std::uint32_t> indices{};
+
+		void Reserve(std::size_t vertexCount, std::size_t indexCount);
+		void Clear();
+		auto Append(std::span<const Vertex> vertices, std::span<const std::uint32_t> indices) -> VertexArray&;
+	};
+} // namespace Tkge::Graphics

Lib/Include/Tkge/Graphics/ResourcePool.hpp

@@ -0,0 +1,57 @@
+#pragma once
+#include <kvf/render_device.hpp>
+#include <kvf/vma.hpp>
+#include <vulkan/vulkan_hash.hpp>
+
+namespace Tkge::Detail
+{
+	/// \brief Cached storage for Vulkan Host Buffers.
+	class BufferPool
+	{
+	  public:
+		explicit BufferPool(gsl::not_null<kvf::RenderDevice*> renderDevice) : _renderDevice(renderDevice) {}
+
+		// Allocate a Buffer for given usage and of given size.
+		[[nodiscard]] kvf::vma::Buffer& Allocate(vk::BufferUsageFlags usage, vk::DeviceSize size)
+		{
+			const auto frameIndex = _renderDevice->get_frame_index();
+			auto& poolMap = _poolMaps.at(std::size_t(frameIndex));
+			auto& pool = poolMap[std::hash<vk::BufferUsageFlags>{}(usage)];
+			if (pool.next < pool.buffers.size())
+			{
+				auto& ret = pool.buffers.at(pool.next++);
+				ret.resize(size);
+				return ret;
+			}
+			const auto createInfo = kvf::vma::BufferCreateInfo{
+				.usage = usage,
+				.type = kvf::vma::BufferType::Host,
+			};
+			pool.next = pool.buffers.size() + 1;
+			return pool.buffers.emplace_back(_renderDevice, createInfo, size);
+		}
+
+		// Make all buffers for the current frame available for use.
+		void NextFrame()
+		{
+			// GPU has finished rendering the current frame, these resources can now be reused.
+			// (Other frames may still be being rendered, hence the multiple buffering.)
+			const auto frameIndex = _renderDevice->get_frame_index();
+			auto& poolMap = _poolMaps.at(std::size_t(frameIndex));
+			for (auto& [_, pool] : poolMap) { pool.next = 0; }
+		}
+
+	  private:
+		struct Pool
+		{
+			std::vector<kvf::vma::Buffer> buffers{}; // buffer pool for a specific usage
+			std::size_t next{};						 // index of next available buffer
+		};
+
+		using PoolMap = std::unordered_map<std::size_t, Pool>; // map of hash(usage) => Pool
+
+		gsl::not_null<kvf::RenderDevice*> _renderDevice;
+
+		kvf::Buffered<PoolMap> _poolMaps{}; // double/triple/etc buffered pools
+	};
+} // namespace Tkge::Detail

Lib/Include/Tkge/Graphics/Vertex.hpp

@@ -0,0 +1,78 @@
+#pragma once
+#include <Tkge/Graphics/PipelineFixedState.hpp>
+#include <Tkge/Graphics/Shader.hpp>
+#include <Tkge/Graphics/Vertex.hpp>
+#include <klib/hash_combine.hpp>
+#include <kvf/render_device.hpp>
+#include <unordered_map>
+
+namespace Tkge::Detail
+{
+	/// \brief Cached storage for Vulkan Graphics Pipelines.
+	class PipelinePool
+	{
+	  public:
+		using FixedState = Graphics::PipelineFixedState;
+
+		/// \param renderDevice Pointer to valid RenderDevice.
+		/// \param framebufferSamples Sample count of target Render Pass' colour attachment.
+		explicit PipelinePool(gsl::not_null<const kvf::RenderDevice*> renderDevice, vk::SampleCountFlagBits framebufferSamples)
+			: _renderDevice(renderDevice), _framebufferSamples(framebufferSamples)
+		{
+			// TODO: descriptor set layouts
+			_pipelineLayout = renderDevice->get_device().createPipelineLayoutUnique({});
+		}
+
+		[[nodiscard]] vk::PipelineLayout PipelineLayout() const { return *_pipelineLayout; }
+
+		/// \brief Get the Pipeline identified by the input parameters.
+		/// \param shader Shader that will be used in draw calls (dynamic Pipeline state).
+		/// \param state Fixed Pipeline state.
+		/// \returns Existing Pipeline if already cached, otherwise a newly created one (unless creation fails).
+		[[nodiscard]] vk::Pipeline GetPipeline(const Graphics::Shader& shader, const FixedState& state)
+		{
+			using Graphics::Vertex;
+
+			// A single Vertex Buffer is bound during draw (index 0), containing vertices.
+			static constexpr auto VertexBindings = std::array{
+				vk::VertexInputBindingDescription{0, sizeof(Vertex)},
+			};
+
+			// Attributes for Vertex Buffer at index 0: list of interleaved vertices (span<Vertex>).
+			static constexpr auto VertexAttributes = std::array{
+				vk::VertexInputAttributeDescription{0, 0, vk::Format::eR32G32Sfloat, offsetof(Vertex, position)},
+				vk::VertexInputAttributeDescription{1, 0, vk::Format::eR32G32B32A32Sfloat, offsetof(Vertex, colour)},
+				vk::VertexInputAttributeDescription{2, 0, vk::Format::eR32G32Sfloat, offsetof(Vertex, uv)},
+			};
+
+			const auto key = klib::make_combined_hash(shader.GetHash(), state.colourFormat, state.polygonMode, state.topology);
+			auto it = _pipelines.find(key);
+			if (it != _pipelines.end()) { return *it->second; }
+
+			const auto pipelineState = kvf::PipelineState{
+				.vertex_bindings = VertexBindings,
+				.vertex_attributes = VertexAttributes,
+				.vertex_shader = shader.VertexModule(),
+				.fragment_shader = shader.FragmentModule(),
+				.topology = state.topology,
+				.polygon_mode = state.polygonMode,
+			};
+			const auto pipelineFormat = kvf::PipelineFormat{
+				.samples = _framebufferSamples,
+				.color = state.colourFormat,
+			};
+			auto ret = _renderDevice->create_pipeline(*_pipelineLayout, pipelineState, pipelineFormat);
+			if (!ret) { return {}; }
+
+			it = _pipelines.insert({key, std::move(ret)}).first;
+			return *it->second;
+		}
+
+	  private:
+		gsl::not_null<const kvf::RenderDevice*> _renderDevice;
+		vk::SampleCountFlagBits _framebufferSamples;
+
+		vk::UniquePipelineLayout _pipelineLayout{};
+		std::unordered_map<std::size_t, vk::UniquePipeline> _pipelines{};
+	};
+} // namespace Tkge::Detail