Add Transform, view and projection matrices (#20)

Author: karnkaul

App/Src/Main.cpp

@@ -50,20 +50,20 @@ namespace
 		const auto& renderDevice = engine.RenderDevice();
 		if (!shader.Load(renderDevice.get_device(), vertexSpirV, fragmentSpirV)) { throw std::runtime_error{"Failed to load shaders"}; }
 
-		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()},
+		static constexpr auto Vertices = std::array{
+			Tkge::Graphics::Vertex{.position = {-200.0f, -200.0f}, .colour = kvf::red_v.to_vec4()},
+			Tkge::Graphics::Vertex{.position = {200.0f, -200.0f}, .colour = kvf::green_v.to_vec4()},
+			Tkge::Graphics::Vertex{.position = {200.0f, 200.0f}, .colour = kvf::blue_v.to_vec4()},
+			Tkge::Graphics::Vertex{.position = {-200.0f, 200.0f}, .colour = kvf::yellow_v.to_vec4()},
 		};
 
-		constexpr auto indices = std::array{
+		static constexpr auto Indices = std::array{
 			0u, 1u, 2u, 2u, 3u, 0u,
 		};
 
-		const auto primitive = Tkge::Graphics::Primitive{
-			.vertices = vertices,
-			.indices = indices,
+		static constexpr auto Primitive = Tkge::Graphics::Primitive{
+			.vertices = Vertices,
+			.indices = Indices,
 		};
 
 		auto wireframe = false;
@@ -85,7 +85,7 @@ namespace
 				renderer.BindShader(shader);
 				renderer.SetLineWidth(lineWidth);
 				renderer.SetWireframe(wireframe);
-				renderer.Draw(primitive);
+				renderer.Draw(Primitive);
 			}
 
 			engine.Present();

Assets/Shaders/Default.vert

@@ -1,6 +1,7 @@
 #pragma once
 #include <Tkge/Graphics/Primitive.hpp>
 #include <Tkge/Graphics/ResourcePool.hpp>
+#include <Tkge/Transform.hpp>
 #include <kvf/render_pass.hpp>
 
 namespace Tkge::Graphics
@@ -29,12 +30,17 @@ namespace Tkge::Graphics
 
 		explicit operator bool() const { return IsRendering(); }
 
+		Transform view{};
+
 	  private:
+		[[nodiscard]] bool WriteSets() const;
 		void BindVboAndDraw(const Primitive& primitive) const;
 
 		kvf::RenderPass* _renderPass{};
 		IResourcePool* _resourcePool{};
 
+		vk::Viewport _viewport{};
+
 		const Shader* _shader{};
 		vk::Pipeline _pipeline{};
 		vk::PolygonMode _polygonMode{vk::PolygonMode::eFill};

Lib/Include/Tkge/Graphics/Renderer.hpp

@@ -11,6 +11,7 @@ namespace Tkge::Graphics
 	{
 	  public:
 		[[nodiscard]] virtual vk::PipelineLayout PipelineLayout() const = 0;
+		[[nodiscard]] virtual std::span<const vk::DescriptorSetLayout> SetLayouts() const = 0;
 
 		/// \brief Get the Pipeline identified by the input parameters.
 		/// \param shader Shader that will be used in draw calls (dynamic Pipeline state).

Lib/Include/Tkge/Graphics/ResourcePool.hpp

@@ -0,0 +1,27 @@
+#pragma once
+#include <glm/mat4x4.hpp>
+
+namespace Tkge
+{
+	struct Transform
+	{
+		static constexpr auto IdentityMat = glm::mat4{1.0f};
+
+		[[nodiscard]] auto ToModel() const -> glm::mat4;
+		[[nodiscard]] auto ToView() const -> glm::mat4;
+		[[nodiscard]] auto ToInverseView() const -> glm::mat4;
+
+		[[nodiscard]] static constexpr auto Accumulate(const Transform& a, const Transform& b) -> Transform
+		{
+			return Transform{
+				.position = a.position + b.position,
+				.orientation = a.orientation + b.orientation,
+				.scale = a.scale * b.scale,
+			};
+		}
+
+		glm::vec2 position{};
+		float orientation{};
+		glm::vec2 scale{1.0f};
+	};
+} // namespace Tkge

Lib/Include/Tkge/Transform.hpp

@@ -19,12 +19,14 @@ namespace Tkge::Detail
 		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({});
+			CreateSetLayouts();
+			CreatePipelineLayout();
 		}
 
 		[[nodiscard]] vk::PipelineLayout PipelineLayout() const { return *_pipelineLayout; }
 
+		[[nodiscard]] std::span<const vk::DescriptorSetLayout> SetLayouts() const { return _setLayouts; }
+
 		/// \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.
@@ -69,10 +71,38 @@ namespace Tkge::Detail
 		}
 
 	  private:
+		void CreateSetLayouts()
+		{
+			static constexpr auto StageFlags = vk::ShaderStageFlagBits::eAllGraphics;
+			// set 0: builtin
+			auto set0 = std::array<vk::DescriptorSetLayoutBinding, 1>{};
+			// set 0, binding 0: view
+			set0[0].setBinding(0).setDescriptorCount(1).setDescriptorType(vk::DescriptorType::eUniformBuffer).setStageFlags(StageFlags);
+			// TODO: instances, texture bindings
+
+			// TODO: set 1: user data
+
+			auto dslci = std::array<vk::DescriptorSetLayoutCreateInfo, 1>{};
+			dslci[0].setBindings(set0);
+
+			for (const auto& createInfo : dslci) { _setLayoutStorage.push_back(_renderDevice->get_device().createDescriptorSetLayoutUnique(createInfo)); }
+			for (const auto& setLayout : _setLayoutStorage) { _setLayouts.push_back(*setLayout); }
+		}
+
+		void CreatePipelineLayout()
+		{
+			auto plci = vk::PipelineLayoutCreateInfo{};
+			plci.setSetLayouts(_setLayouts);
+			_pipelineLayout = _renderDevice->get_device().createPipelineLayoutUnique(plci);
+		}
+
 		gsl::not_null<const kvf::RenderDevice*> _renderDevice;
 		vk::SampleCountFlagBits _framebufferSamples;
 
 		vk::UniquePipelineLayout _pipelineLayout{};
+		std::vector<vk::UniqueDescriptorSetLayout> _setLayoutStorage{};
+		std::vector<vk::DescriptorSetLayout> _setLayouts{};
+
 		std::unordered_map<std::size_t, vk::UniquePipeline> _pipelines{};
 	};
 } // namespace Tkge::Detail

Lib/Src/Detail/PipelinePool.hpp

@@ -20,6 +20,8 @@ namespace Tkge
 
 			[[nodiscard]] vk::PipelineLayout PipelineLayout() const final { return _pipelinePool.PipelineLayout(); }
 
+			[[nodiscard]] std::span<const vk::DescriptorSetLayout> SetLayouts() const final { return _pipelinePool.SetLayouts(); }
+
 			[[nodiscard]] vk::Pipeline GetPipeline(const Graphics::Shader& shader, const Graphics::PipelineFixedState& state) final
 			{
 				return _pipelinePool.GetPipeline(shader, state);

Lib/Src/Engine.cpp

@@ -4,11 +4,15 @@ layout (location = 0) in vec2 aPos;
 layout (location = 1) in vec4 aColour;
 layout (location = 2) in vec2 aUv;
 
+layout (set = 0, binding = 0) uniform View {
+	mat4 matVP;
+};
+
 layout (location = 0) out vec4 outColour;
 
 void main()
 {
 	outColour = aColour;
 
-	gl_Position = vec4(aPos, 0.0, 1.0);
+	gl_Position = matVP * vec4(aPos, 0.0, 1.0);
 }

Lib/Src/Glsl/Default.vert

@@ -1,4 +1,7 @@
 #include <Tkge/Graphics/Renderer.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <klib/assert.hpp>
+#include <klib/flex_array.hpp>
 #include <kvf/render_device.hpp>
 #include <kvf/util.hpp>
 #include <algorithm>
@@ -9,6 +12,7 @@ namespace Tkge::Graphics
 		: _renderPass(renderPass), _resourcePool(resourcePool)
 	{
 		_renderPass->begin_render(commandBuffer, kvf::util::to_vk_extent(framebufferSize));
+		_viewport = _renderPass->to_viewport(kvf::uv_rect_v);
 	}
 
 	void Renderer::EndRender()
@@ -52,9 +56,50 @@ namespace Tkge::Graphics
 			_renderPass->bind_pipeline(_pipeline);
 		}
 
+		if (!WriteSets()) { return; }
+
+		_renderPass->get_command_buffer().setViewport(0, _viewport);
+
 		BindVboAndDraw(primitive);
 	}
 
+	bool Renderer::WriteSets() const
+	{
+		auto& renderDevice = _renderPass->get_render_device();
+
+		const auto setLayouts = _resourcePool->SetLayouts();
+		auto descriptorSets = std::array<vk::DescriptorSet, 1>{};
+		KLIB_ASSERT(setLayouts.size() == descriptorSets.size()); // expected set count will change until render flow is stable
+		if (!renderDevice.allocate_sets(descriptorSets, setLayouts)) { return false; }
+
+		auto bufferInfos = klib::FlexArray<vk::DescriptorBufferInfo, 4>{};
+		auto descriptorWrites = klib::FlexArray<vk::WriteDescriptorSet, 8>{};
+		const auto pushBufferWrite = [&](vk::DescriptorSet set, std::uint32_t binding, const Buffer& buffer, const vk::DescriptorType type)
+		{
+			bufferInfos.push_back({});
+			auto& dbi = bufferInfos.back();
+			dbi.setBuffer(buffer.get_buffer()).setRange(buffer.get_size());
+			auto wds = vk::WriteDescriptorSet{};
+			wds.setBufferInfo(dbi).setDescriptorCount(1).setDescriptorType(type).setDstSet(set).setDstBinding(binding);
+			descriptorWrites.push_back(wds);
+		};
+
+		auto& ubo00 = _resourcePool->AllocateBuffer(vk::BufferUsageFlagBits::eUniformBuffer, sizeof(glm::mat4));
+		const auto halfRenderArea = 0.5f * glm::vec2{_viewport.width, -_viewport.height};
+		const auto matProj = glm::ortho(-halfRenderArea.x, halfRenderArea.x, -halfRenderArea.y, halfRenderArea.y);
+		const auto matVP = matProj * view.ToView();
+		kvf::util::overwrite(ubo00, matVP);
+		pushBufferWrite(descriptorSets[0], 0, ubo00, vk::DescriptorType::eUniformBuffer);
+
+		const auto writeSpan = std::span{descriptorWrites.data(), descriptorWrites.size()};
+		renderDevice.get_device().updateDescriptorSets(writeSpan, {});
+
+		const auto setSpan = std::span{descriptorSets.data(), descriptorSets.size()};
+		_renderPass->get_command_buffer().bindDescriptorSets(vk::PipelineBindPoint::eGraphics, _resourcePool->PipelineLayout(), 0, setSpan, {});
+
+		return true;
+	}
+
 	void Renderer::BindVboAndDraw(const Primitive& primitive) const
 	{
 		const auto vertSize = primitive.vertices.size_bytes();

Lib/Src/Graphics/Renderer.cpp

@@ -0,0 +1,41 @@
+#include <Tkge/Transform.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+namespace Tkge
+{
+	namespace
+	{
+		struct Trs
+		{
+			glm::mat4 t;
+			glm::mat4 r;
+			glm::mat4 s;
+
+			explicit Trs(const glm::vec2 position, const float orientation, const glm::vec2 scale)
+				: t(glm::translate(Transform::IdentityMat, glm::vec3{position, 0.0f})),
+				  r(glm::rotate(Transform::IdentityMat, glm::radians(orientation), glm::vec3{0.0f, 0.0f, 1.0f})),
+				  s(glm::scale(Transform::IdentityMat, glm::vec3{scale, 1.0f}))
+			{
+			}
+		};
+	} // namespace
+
+	auto Transform::ToModel() const -> glm::mat4
+	{
+		const auto trs = Trs{position, orientation, scale};
+		return trs.t * trs.r * trs.s;
+	}
+
+	auto Transform::ToView() const -> glm::mat4
+	{
+		const auto trs = Trs{-position, -orientation, scale};
+		return trs.s * trs.r * trs.t;
+	}
+
+	auto Transform::ToInverseView() const -> glm::mat4
+	{
+		if (scale == glm::vec2{0.0f}) { return {}; }
+		const auto trs = Trs{position, orientation, 1.0f / scale};
+		return trs.t * trs.r * trs.s;
+	}
+} // namespace Tkge