Add Vertex, Primitive; draw quad (#16)

* Add `Vertex`, `Primitive`; draw quad

* Use constexpr verts and indices (just for demonstration)

* Refactor `ResourcePool`

- Use `IResourcePool` abstract interface for public API
- Move individual pool classes to 'src', under `namespace detail`
- Concretize in 'engine.cpp'

This hides unecessary implementation details from users, and reduces includes in the public API.

---------

Co-authored-by: Tymianek <[email protected]>

Author: karnkaul

app/src/main.cpp

@@ -45,25 +45,26 @@ namespace
 		tkge::Engine engine{surface};
 
 		auto shader = tkge::graphics::Shader{};
-		const auto vertexSpirV = LoadSpirV((assets_path / "shaders/triangle.vert").string().c_str());
-		const auto fragmentSpirV = LoadSpirV((assets_path / "shaders/triangle.frag").string().c_str());
+		const auto vertexSpirV = LoadSpirV((assets_path / "shaders/default.vert").string().c_str());
+		const auto fragmentSpirV = LoadSpirV((assets_path / "shaders/default.frag").string().c_str());
 		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/triangle.frag renamed to 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,5 +1,6 @@
 #pragma once
 #include <kvf/render_pass.hpp>
+#include <tkge/graphics/primitive.hpp>
 #include <tkge/graphics/resource_pool.hpp>
 
 namespace tkge::graphics
@@ -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/pipeline_fixed_state.hpp

@@ -1,43 +1,24 @@
 #pragma once
-#include <kvf/render_device.hpp>
+#include <kvf/vma.hpp>
+#include <tkge/graphics/pipeline_fixed_state.hpp>
 #include <tkge/graphics/shader.hpp>
-#include <unordered_map>
 
 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