Add graphics::Renderer (WIP) (#8)

Author: karnkaul

app/src/main.cpp

@@ -65,16 +65,29 @@ namespace
 		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;
+
 		while (engine.IsRunning())
 		{
-			const auto commandBuffer = engine.NextFrame();
+			engine.NextFrame();
+
+			if (ImGui::Begin("Misc"))
+			{
+				ImGui::Checkbox("wireframe", &wireframe);
+				ImGui::DragFloat("line width", &lineWidth, 1.0f, 1.0f, 100.0f);
+			}
+			ImGui::End();
 
-			ImGui::ShowDemoWindow();
+			if (auto renderer = engine.BeginRender())
+			{
+				renderer.BindShader(shader);
+				renderer.SetLineWidth(lineWidth);
+				renderer.SetWireframe(wireframe);
+				renderer.Draw(3);
+			}
 
-			engine.BeginRender();
-			engine.RenderPass().bind_pipeline(*pipeline);
-			commandBuffer.draw(3, 1, 0, 0);
-			engine.EndRender();
+			engine.Present();
 		}
 
 		renderDevice.get_device().waitIdle();

ext/src.zip

@@ -5,7 +5,8 @@
 #include <kvf/render_device.hpp>
 #include <kvf/render_pass.hpp>
 #include <kvf/window.hpp>
-#include "assetLoader.hpp"
+#include <tkge/assetLoader.hpp>
+#include <tkge/graphics/renderer.hpp>
 
 namespace tkge
 {
@@ -24,17 +25,15 @@ namespace tkge
 		explicit Engine(const WindowSurface& surface = {}, vk::SampleCountFlagBits aa = AntiAliasing);
 
 		[[nodiscard]] const kvf::RenderDevice& RenderDevice() const { return _renderDevice; }
-		[[nodiscard]] const kvf::RenderPass& RenderPass() const { return _renderPass; }
 
 		[[nodiscard]] glm::ivec2 FramebufferSize() const;
 		[[nodiscard]] auto FramebufferFormat() const -> vk::Format { return _renderPass.get_color_format(); }
 		[[nodiscard]] auto FramebufferSamples() const -> vk::SampleCountFlagBits { return _renderPass.get_samples(); }
 
 		[[nodiscard]] bool IsRunning() const;
 		vk::CommandBuffer NextFrame();
-		// TODO: return Renderer
-		void BeginRender(kvf::Color clear = kvf::black_v);
-		void EndRender();
+		[[nodiscard]] graphics::Renderer BeginRender(kvf::Color clear = kvf::black_v);
+		void Present();
 
 		[[nodiscard]] AssetLoader& GetAssetLoader() noexcept { return this->_assetLoader; }
 		[[nodiscard]] const AssetLoader& GetAssetLoader() const noexcept { return this->_assetLoader; }
@@ -46,6 +45,8 @@ namespace tkge
 		kvf::RenderDevice _renderDevice;
 		kvf::RenderPass _renderPass;
 
+		graphics::ResourcePool _resourcePool;
+
 		vk::CommandBuffer _cmd{};
 		AssetLoader _assetLoader;
 	};

lib/include/tkge/engine.hpp

@@ -0,0 +1,41 @@
+#pragma once
+#include <kvf/render_pass.hpp>
+#include <tkge/graphics/resource_pool.hpp>
+
+namespace tkge::graphics
+{
+	class Renderer
+	{
+	  public:
+		Renderer(Renderer&&) = delete;
+		Renderer(const Renderer&) = delete;
+		Renderer& operator=(const Renderer&) = delete;
+		Renderer& operator=(Renderer&&) = delete;
+
+		Renderer() = default;
+
+		explicit Renderer(kvf::RenderPass* renderPass, ResourcePool* resourcePool, vk::CommandBuffer commandBuffer, glm::ivec2 framebufferSize);
+		~Renderer() { EndRender(); }
+
+		[[nodiscard]] bool IsRendering() const { return _renderPass != nullptr; }
+		void EndRender();
+
+		bool BindShader(const Shader& shader);
+		void SetLineWidth(float width);
+		void SetWireframe(bool wireframe);
+
+		// temporary, until we have vertices, primitives, etc
+		void Draw(std::uint32_t vertices);
+
+		explicit operator bool() const { return IsRendering(); }
+
+	  private:
+		kvf::RenderPass* _renderPass{};
+		ResourcePool* _resourcePool{};
+
+		const Shader* _shader{};
+		vk::Pipeline _pipeline{};
+		vk::PolygonMode _polygonMode{vk::PolygonMode::eFill};
+		float _lineWidth{1.0f};
+	};
+} // namespace tkge::graphics

lib/include/tkge/graphics/renderer.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include <kvf/render_device.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; }
+
+		[[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
+	{
+	  public:
+		explicit ResourcePool(gsl::not_null<const kvf::RenderDevice*> renderDevice, vk::SampleCountFlagBits framebufferSamples)
+			: pipelinePool(renderDevice, framebufferSamples)
+		{
+		}
+
+		PipelinePool pipelinePool;
+	};
+} // namespace tkge::graphics

lib/include/tkge/graphics/resource_pool.hpp

@@ -1,18 +1,15 @@
 #include <klib/assert.hpp>
+#include <kvf/is_positive.hpp>
 #include <kvf/util.hpp>
-#include <tkge/Assets/TextAsset.hpp>
 #include <tkge/engine.hpp>
 #include <print>
 
 namespace tkge
 {
 	Engine::Engine(const WindowSurface& surface, const vk::SampleCountFlagBits aa)
-		: _window(CreateWindow(surface)), _renderDevice(_window.get()), _renderPass(&_renderDevice, aa)
+		: _window(CreateWindow(surface)), _renderDevice(_window.get()), _renderPass(&_renderDevice, aa), _resourcePool(&_renderDevice, aa)
 	{
 		_renderPass.set_color_target();
-		// TEST
-		const auto myTextDocument = this->GetAssetLoader().LoadAsset<tkge::Assets::TextAsset>("hello.txt");
-		std::println("Document content = '{}'", myTextDocument->ReadAllText());
 	}
 
 	glm::ivec2 Engine::FramebufferSize() const { return kvf::util::to_glm_vec<int>(_renderDevice.get_framebuffer_extent()); }
@@ -35,15 +32,20 @@ namespace tkge
 		return ret;
 	}
 
-	void Engine::BeginRender(const kvf::Color clear)
+	graphics::Renderer Engine::BeginRender(const kvf::Color clear)
 	{
+		if (!_cmd) { return {}; }
+
+		const auto framebufferSize = FramebufferSize();
+		if (!kvf::is_positive(framebufferSize)) { return {}; }
+
 		_renderPass.clear_color = clear.to_linear();
-		_renderPass.begin_render(_cmd, _renderDevice.get_framebuffer_extent());
+		return graphics::Renderer{&_renderPass, &_resourcePool, _cmd, framebufferSize};
 	}
 
-	void Engine::EndRender()
+	void Engine::Present()
 	{
-		_renderPass.end_render();
+		if (_renderPass.get_command_buffer()) { _renderPass.end_render(); }
 		_renderDevice.render(_renderPass.render_target());
 	}
 } // namespace tkge

lib/src/engine.cpp

@@ -0,0 +1,57 @@
+#include <kvf/util.hpp>
+#include <tkge/graphics/renderer.hpp>
+#include <algorithm>
+
+namespace tkge::graphics
+{
+	Renderer::Renderer(kvf::RenderPass* renderPass, ResourcePool* resourcePool, const vk::CommandBuffer commandBuffer, const glm::ivec2 framebufferSize)
+		: _renderPass(renderPass), _resourcePool(resourcePool)
+	{
+		_renderPass->begin_render(commandBuffer, kvf::util::to_vk_extent(framebufferSize));
+	}
+
+	void Renderer::EndRender()
+	{
+		if (_renderPass == nullptr) { return; }
+		_renderPass->end_render();
+		_renderPass = nullptr;
+	}
+
+	bool Renderer::BindShader(const Shader& shader)
+	{
+		if (!IsRendering() || !shader.IsLoaded()) { return false; }
+		_shader = &shader;
+		return true;
+	}
+
+	void Renderer::SetWireframe(const bool wireframe) { _polygonMode = wireframe ? vk::PolygonMode::eLine : vk::PolygonMode::eFill; }
+
+	void Renderer::SetLineWidth(const float width)
+	{
+		if (_renderPass == nullptr) { return; }
+		const auto limits = _renderPass->get_render_device().get_gpu().properties.limits.lineWidthRange;
+		_lineWidth = std::clamp(width, limits[0], limits[1]);
+	}
+
+	void Renderer::Draw(const std::uint32_t vertices)
+	{
+		if (!IsRendering() || _shader == nullptr) { return; }
+
+		const auto pipelineParams = PipelinePool::Params{
+			.colourFormat = _renderPass->get_color_format(),
+			.polygonMode = _polygonMode,
+		};
+		const auto pipeline = _resourcePool->pipelinePool.GetPipeline(*_shader, pipelineParams);
+		if (!pipeline) { return; }
+
+		if (_pipeline != pipeline)
+		{
+			_pipeline = pipeline;
+			_renderPass->bind_pipeline(_pipeline);
+		}
+
+		const auto commandBuffer = _renderPass->get_command_buffer();
+		commandBuffer.setLineWidth(_lineWidth);
+		commandBuffer.draw(vertices, 1, 0, 0);
+	}
+} // namespace tkge::graphics

lib/src/graphics/renderer.cpp

@@ -0,0 +1,39 @@
+#include <klib/hash_combine.hpp>
+#include <tkge/graphics/resource_pool.hpp>
+#include <vulkan/vulkan_hash.hpp>
+
+namespace tkge::graphics
+{
+	PipelinePool::PipelinePool(gsl::not_null<const kvf::RenderDevice*> renderDevice, const vk::SampleCountFlagBits framebufferSamples)
+		: _renderDevice(renderDevice), _framebufferSamples(framebufferSamples)
+	{
+		// TODO: descriptor set layouts
+		_pipelineLayout = renderDevice->get_device().createPipelineLayoutUnique({});
+	}
+
+	vk::Pipeline PipelinePool::GetPipeline(const Shader& shader, const Params& params)
+	{
+		const auto key = klib::make_combined_hash(shader.GetHash(), params.colourFormat, params.polygonMode, params.topology);
+		auto it = _pipelines.find(key);
+		if (it != _pipelines.end()) { return *it->second; }
+
+		const auto pipelineState = kvf::PipelineState{
+			.vertex_bindings = {},
+			.vertex_attributes = {},
+			.vertex_shader = shader.VertexModule(),
+			.fragment_shader = shader.FragmentModule(),
+			.topology = params.topology,
+			.polygon_mode = params.polygonMode,
+		};
+		const auto pipelineFormat = kvf::PipelineFormat{
+			.samples = _framebufferSamples,
+			.color = params.colourFormat,
+		};
+		auto ret = _renderDevice->create_pipeline(*_pipelineLayout, pipelineState, pipelineFormat);
+		if (!ret) { return {}; }
+
+		it = _pipelines.insert({key, std::move(ret)}).first;
+		return *it->second;
+	}
+
+} // namespace tkge::graphics