initial commit

ScopEngine/Runtime/Includes/Renderer/Pipelines/Graphics.h

@@ -0,0 +1,67 @@
+#ifndef __SCOP_GRAPHICS_PIPELINE__
+#define __SCOP_GRAPHICS_PIPELINE__
+
+#include <memory>
+#include <vector>
+
+#include <kvf.h>
+
+#include <Renderer/Image.h>
+#include <Utils/NonOwningPtr.h>
+#include <Renderer/Pipelines/Shader.h>
+#include <Renderer/Pipelines/Pipeline.h>
+
+namespace Scop
+{
+	struct GraphicPipelineDescriptor
+	{
+		std::shared_ptr<Shader> vertex_shader;
+		std::shared_ptr<Shader> fragment_shader;
+		std::vector<NonOwningPtr<Texture>> color_attachments;
+		NonOwningPtr<DepthImage> depth = nullptr;
+		NonOwningPtr<class Renderer> renderer = nullptr;
+		VkCullModeFlagBits culling = VK_CULL_MODE_FRONT_BIT;
+		VkPolygonMode mode = VK_POLYGON_MODE_FILL;
+		bool no_vertex_inputs = false;
+		bool depth_test_equal = false;
+		bool clear_color_attachments = true;
+	};
+
+	class GraphicPipeline : public Pipeline
+	{
+		public:
+			GraphicPipeline() = default;
+
+			void Init(const GraphicPipelineDescriptor& descriptor);
+			bool BindPipeline(VkCommandBuffer command_buffer, std::size_t framebuffer_index, std::array<float, 4> clear) noexcept;
+			void EndPipeline(VkCommandBuffer command_buffer) noexcept override;
+			void Destroy() noexcept;
+
+			[[nodiscard]] inline VkPipeline GetPipeline() const override { return m_pipeline; }
+			[[nodiscard]] inline VkPipelineLayout GetPipelineLayout() const override { return m_pipeline_layout; }
+			[[nodiscard]] inline VkPipelineBindPoint GetPipelineBindPoint() const override { return VK_PIPELINE_BIND_POINT_GRAPHICS; }
+
+			~GraphicPipeline() = default;
+
+		private:
+			void CreateFramebuffers(const std::vector<NonOwningPtr<Texture>>& render_targets, bool clear_attachments);
+			void TransitionAttachments(VkCommandBuffer cmd = VK_NULL_HANDLE);
+
+			// Private override to remove access
+			bool BindPipeline(VkCommandBuffer) noexcept override { return false; };
+
+		private:
+			std::vector<NonOwningPtr<Texture>> m_attachments;
+			std::vector<VkFramebuffer> m_framebuffers;
+			std::vector<VkClearValue> m_clears;
+			std::shared_ptr<Shader> p_vertex_shader;
+			std::shared_ptr<Shader> p_fragment_shader;
+			VkRenderPass m_renderpass = VK_NULL_HANDLE;
+			VkPipeline m_pipeline = VK_NULL_HANDLE;
+			VkPipelineLayout m_pipeline_layout = VK_NULL_HANDLE;
+			NonOwningPtr<class Renderer> p_renderer;
+			NonOwningPtr<DepthImage> p_depth;
+	};
+}
+
+#endif

ScopEngine/Runtime/Includes/Renderer/Pipelines/Pipeline.h

@@ -0,0 +1,25 @@
+#ifndef __SCOP_PIPELINE__
+#define __SCOP_PIPELINE__
+
+#include <kvf.h>
+#include <Renderer/RenderCore.h>
+
+namespace Scop
+{
+	class Pipeline
+	{
+		public:
+			Pipeline() = default;
+
+			inline virtual bool BindPipeline(VkCommandBuffer command_buffer) noexcept { RenderCore::Get().vkCmdBindPipeline(command_buffer, GetPipelineBindPoint(), GetPipeline()); return true; }
+			inline virtual void EndPipeline([[maybe_unused]] VkCommandBuffer command_buffer) noexcept {}
+
+			virtual VkPipeline GetPipeline() const = 0;
+			virtual VkPipelineLayout GetPipelineLayout() const = 0;
+			virtual VkPipelineBindPoint GetPipelineBindPoint() const = 0;
+
+			virtual ~Pipeline() = default;
+	};
+}
+
+#endif

ScopEngine/Runtime/Includes/Renderer/Pipelines/Shader.h

@@ -0,0 +1,78 @@
+#ifndef __SCOP_SHADER__
+#define __SCOP_SHADER__
+
+#include <vector>
+#include <cstdint>
+#include <filesystem>
+
+#include <kvf.h>
+
+namespace Scop
+{
+	struct ShaderSetLayout
+	{
+		std::vector<std::pair<int, VkDescriptorType> > binds;
+
+		ShaderSetLayout(std::vector<std::pair<int, VkDescriptorType> > b) : binds(std::move(b)) {}
+	};
+
+	struct ShaderPushConstantLayout
+	{
+		std::size_t offset;
+		std::size_t size;
+
+		ShaderPushConstantLayout(std::size_t o, std::size_t s) : offset(o), size(s) {}
+	};
+
+	struct ShaderLayout
+	{
+		std::vector<std::pair<int, ShaderSetLayout> > set_layouts;
+		std::vector<ShaderPushConstantLayout> push_constants;
+
+		ShaderLayout(std::vector<std::pair<int, ShaderSetLayout> > s, std::vector<ShaderPushConstantLayout> pc) : set_layouts(std::move(s)), push_constants(std::move(pc)) {}
+	};
+
+	enum class ShaderType
+	{
+		Vertex,
+		Fragment,
+		Compute
+	};
+
+	struct ShaderPipelineLayoutPart
+	{
+		std::vector<VkPushConstantRange> push_constants;
+		std::vector<VkDescriptorSetLayout> set_layouts;
+	};
+
+	class Shader
+	{
+		public:
+			Shader(const std::vector<std::uint32_t>& bytecode, ShaderType type, ShaderLayout layout);
+
+			[[nodiscard]] inline const ShaderLayout& GetShaderLayout() const { return m_layout; }
+			[[nodiscard]] inline const std::vector<std::uint32_t>& GetByteCode() const noexcept { return m_bytecode; }
+			[[nodiscard]] inline const ShaderPipelineLayoutPart& GetPipelineLayout() const noexcept { return m_pipeline_layout_part; }
+			[[nodiscard]] inline VkShaderModule GetShaderModule() const noexcept { return m_module; }
+			[[nodiscard]] inline VkShaderStageFlagBits GetShaderStage() const noexcept { return m_stage; }
+
+			void Destroy();
+
+			~Shader();
+
+		private:
+			void GeneratePipelineLayout(ShaderLayout layout);
+
+		private:
+			ShaderLayout m_layout;
+			ShaderPipelineLayoutPart m_pipeline_layout_part;
+			std::vector<std::uint32_t> m_bytecode;
+			std::vector<VkDescriptorSetLayout> m_set_layouts;
+			VkShaderStageFlagBits m_stage;
+			VkShaderModule m_module = VK_NULL_HANDLE;
+	};
+
+	std::shared_ptr<Shader> LoadShaderFromFile(const std::filesystem::path& filepath, ShaderType type, ShaderLayout layout);
+}
+
+#endif