initial commit

ScopEngine/Runtime/Sources/Renderer/RenderPasses/2DPass.cpp

@@ -0,0 +1,113 @@
+#include <Renderer/RenderPasses/2DPass.h>
+#include <Renderer/Pipelines/Graphics.h>
+#include <Renderer/ViewerData.h>
+#include <Renderer/Renderer.h>
+#include <Graphics/Scene.h>
+#include <Core/Engine.h>
+#include <Maths/Mat4.h>
+
+namespace Scop
+{
+	struct SpriteData
+	{
+		Vec4f color;
+		Vec2f position;
+	};
+
+	struct ViewerData2D
+	{
+		Mat4f projection;
+	};
+
+	void Render2DPass::Init()
+	{
+		ShaderLayout vertex_shader_layout(
+			{
+				{ 0,
+					ShaderSetLayout({ 
+						{ 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER }
+					})
+				}
+			}, { ShaderPushConstantLayout({ 0, sizeof(SpriteData) }) }
+		);
+		p_vertex_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/2DVertex.spv", ShaderType::Vertex, std::move(vertex_shader_layout));
+		ShaderLayout fragment_shader_layout(
+			{
+				{ 1,
+					ShaderSetLayout({ 
+						{ 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER }
+					})
+				}
+			}, {}
+		);
+		p_fragment_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/2DFragment.spv", ShaderType::Fragment, std::move(fragment_shader_layout));
+
+		std::function<void(const EventBase&)> functor = [this](const EventBase& event)
+		{
+			if(event.What() == Event::ResizeEventCode || event.What() == Event::SceneHasChangedEventCode)
+				m_pipeline.Destroy();
+		};
+		EventBus::RegisterListener({ functor, "__ScopRender2DPass" });
+
+		p_viewer_data_set = std::make_shared<DescriptorSet>(p_vertex_shader->GetShaderLayout().set_layouts[0].second, p_vertex_shader->GetPipelineLayout().set_layouts[0], ShaderType::Vertex);
+		p_texture_set = std::make_shared<DescriptorSet>(p_fragment_shader->GetShaderLayout().set_layouts[0].second, p_fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
+
+		p_viewer_data_buffer = std::make_shared<UniformBuffer>();
+		p_viewer_data_buffer->Init(sizeof(ViewerData2D));
+		for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
+		{
+			p_viewer_data_set->SetUniformBuffer(i, 0, p_viewer_data_buffer->Get(i));
+			p_viewer_data_set->Update(i);
+		}
+	}
+
+	void Render2DPass::Pass(Scene& scene, Renderer& renderer, Texture& render_target)
+	{
+		if(m_pipeline.GetPipeline() == VK_NULL_HANDLE)
+		{
+			GraphicPipelineDescriptor pipeline_descriptor;
+			pipeline_descriptor.vertex_shader = p_vertex_shader;
+			pipeline_descriptor.fragment_shader = p_fragment_shader;
+			pipeline_descriptor.color_attachments = { &render_target };
+			pipeline_descriptor.culling = VK_CULL_MODE_NONE;
+			pipeline_descriptor.clear_color_attachments = false;
+			m_pipeline.Init(pipeline_descriptor);
+		}
+
+		std::uint32_t frame_index = renderer.GetCurrentFrameIndex();
+
+		ViewerData2D viewer_data;
+		viewer_data.projection = Mat4f::Ortho(0.0f, render_target.GetWidth(), render_target.GetHeight(), 0.0f);
+		static CPUBuffer buffer(sizeof(ViewerData2D));
+		std::memcpy(buffer.GetData(), &viewer_data, buffer.GetSize());
+		p_viewer_data_buffer->SetData(buffer, frame_index);
+
+		VkCommandBuffer cmd = renderer.GetActiveCommandBuffer();
+		m_pipeline.BindPipeline(cmd, 0, {});
+		for(auto sprite : scene.GetSprites())
+		{
+			SpriteData sprite_data;
+			sprite_data.position = Vec2f{ static_cast<float>(sprite->GetPosition().x), static_cast<float>(sprite->GetPosition().y) };
+			sprite_data.color = sprite->GetColor();
+			if(!sprite->IsSetInit())
+				sprite->UpdateDescriptorSet(*p_texture_set);
+			sprite->Bind(frame_index, cmd);
+			std::array<VkDescriptorSet, 2> sets = { p_viewer_data_set->GetSet(frame_index), sprite->GetSet(frame_index) };
+			RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);
+			RenderCore::Get().vkCmdPushConstants(cmd, m_pipeline.GetPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(SpriteData), &sprite_data);
+			sprite->GetMesh()->Draw(cmd, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef());
+		}
+		m_pipeline.EndPipeline(cmd);
+	}
+
+	void Render2DPass::Destroy()
+	{
+		RenderCore::Get().WaitDeviceIdle();
+		m_pipeline.Destroy();
+		p_vertex_shader.reset();
+		p_fragment_shader.reset();
+		p_viewer_data_set.reset();
+		p_viewer_data_buffer->Destroy();
+		p_texture_set.reset();
+	}
+}

ScopEngine/Runtime/Sources/Renderer/RenderPasses/FinalPass.cpp

@@ -0,0 +1,72 @@
+#include <Renderer/RenderPasses/FinalPass.h>
+#include <Renderer/Pipelines/Graphics.h>
+#include <Renderer/Renderer.h>
+#include <Graphics/Scene.h>
+#include <Core/EventBus.h>
+#include <Core/Engine.h>
+
+namespace Scop
+{
+	void FinalPass::Init()
+	{
+		ShaderLayout vertex_shader_layout(
+			{}, {}
+		);
+		p_vertex_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/ScreenVertex.spv", ShaderType::Vertex, std::move(vertex_shader_layout));
+		ShaderLayout fragment_shader_layout(
+			{
+				{ 0,
+					ShaderSetLayout({ 
+						{ 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER }
+					})
+				}
+			}, {}
+		);
+		p_fragment_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/ScreenFragment.spv", ShaderType::Fragment, std::move(fragment_shader_layout));
+
+		std::function<void(const EventBase&)> functor = [this](const EventBase& event)
+		{
+			if(event.What() == Event::ResizeEventCode)
+				m_pipeline.Destroy();
+		};
+		EventBus::RegisterListener({ functor, "__ScopFinalPass" });
+
+		p_set = std::make_shared<DescriptorSet>(p_fragment_shader->GetShaderLayout().set_layouts[0].second, p_fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
+	}
+
+	void FinalPass::Pass(Scene& scene, Renderer& renderer, Texture& render_target)
+	{
+		if(m_pipeline.GetPipeline() == VK_NULL_HANDLE)
+		{
+			GraphicPipelineDescriptor pipeline_descriptor;
+			pipeline_descriptor.vertex_shader = p_vertex_shader;
+			pipeline_descriptor.fragment_shader = p_fragment_shader;
+			pipeline_descriptor.renderer = &renderer;
+			pipeline_descriptor.culling = VK_CULL_MODE_NONE;
+			pipeline_descriptor.no_vertex_inputs = true;
+			m_pipeline.Init(pipeline_descriptor);
+		}
+
+		VkCommandBuffer cmd = renderer.GetActiveCommandBuffer();
+
+		p_set->SetImage(renderer.GetCurrentFrameIndex(), 0, render_target);
+		p_set->Update(renderer.GetCurrentFrameIndex(), cmd);
+
+		m_pipeline.BindPipeline(cmd, renderer.GetSwapchain().GetImageIndex(), { 0.0f, 0.0f, 0.0f, 1.0f });
+			VkDescriptorSet set = p_set->GetSet(renderer.GetCurrentFrameIndex());
+			RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, 1, &set, 0, nullptr);
+			RenderCore::Get().vkCmdDraw(cmd, 3, 1, 0, 0);
+			renderer.GetDrawCallsCounterRef()++;
+			renderer.GetPolygonDrawnCounterRef()++;
+		m_pipeline.EndPipeline(cmd);
+	}
+
+	void FinalPass::Destroy()
+	{
+		RenderCore::Get().WaitDeviceIdle();
+		m_pipeline.Destroy();
+		p_vertex_shader.reset();
+		p_fragment_shader.reset();
+		p_set.reset();
+	}
+}

ScopEngine/Runtime/Sources/Renderer/RenderPasses/ForwardPass.cpp

@@ -0,0 +1,50 @@
+#include <Renderer/RenderPasses/ForwardPass.h>
+#include <Renderer/Pipelines/Graphics.h>
+#include <Renderer/ViewerData.h>
+#include <Renderer/Renderer.h>
+#include <Graphics/Scene.h>
+#include <Maths/Mat4.h>
+
+namespace Scop
+{
+	struct ModelData
+	{
+		Mat4f model_mat;
+		Mat4f normal_mat;
+	};
+
+	void ForwardPass::Pass(Scene& scene, Renderer& renderer, class Texture& render_target)
+	{
+		Scene::ForwardData& data = scene.GetForwardData();
+		GraphicPipeline& pipeline = scene.GetPipeline();
+
+		if(pipeline.GetPipeline() == VK_NULL_HANDLE)
+		{
+			GraphicPipelineDescriptor pipeline_descriptor;
+			pipeline_descriptor.vertex_shader = RenderCore::Get().GetDefaultVertexShader();
+			pipeline_descriptor.fragment_shader = scene.GetFragmentShader();
+			pipeline_descriptor.color_attachments = { &render_target };
+			pipeline_descriptor.depth = &scene.GetDepth();
+			if(scene.GetForwardData().wireframe)
+				pipeline_descriptor.mode = VK_POLYGON_MODE_LINE;
+			pipeline_descriptor.clear_color_attachments = false;
+			pipeline.Init(pipeline_descriptor);
+		}
+
+		VkCommandBuffer cmd = renderer.GetActiveCommandBuffer();
+		pipeline.BindPipeline(cmd, 0, {});
+		for(auto actor : scene.GetActors())
+		{
+			ModelData model_data;
+			model_data.model_mat = Mat4f::Identity();
+			model_data.model_mat.SetTranslation(actor->GetPosition() - actor->GetModel().GetCenter());
+			model_data.model_mat.SetScale(actor->GetScale());
+			model_data.model_mat = Mat4f::Translate(-actor->GetModel().GetCenter()) * Mat4f::Rotate(actor->GetOrientation()) * model_data.model_mat;
+			model_data.normal_mat = model_data.model_mat;
+			model_data.normal_mat.Inverse().Transpose();
+			RenderCore::Get().vkCmdPushConstants(cmd, pipeline.GetPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(ModelData), &model_data);
+			actor->GetModel().Draw(cmd, *data.matrices_set, pipeline, *data.albedo_set, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef(), renderer.GetCurrentFrameIndex());
+		}
+		pipeline.EndPipeline(cmd);
+	}
+}

ScopEngine/Runtime/Sources/Renderer/RenderPasses/Passes.cpp

@@ -0,0 +1,50 @@
+#include <Renderer/RenderPasses/Passes.h>
+#include <Renderer/Renderer.h>
+#include <Graphics/Scene.h>
+
+namespace Scop
+{
+	void RenderPasses::Init()
+	{
+		m_skybox.Init();
+		m_2Dpass.Init();
+		m_final.Init();
+
+		std::function<void(const EventBase&)> functor = [this](const EventBase& event)
+		{
+			if(event.What() == Event::ResizeEventCode)
+				m_main_render_texture.Destroy();
+		};
+		EventBus::RegisterListener({ functor, "__ScopRenderPasses" });
+	}
+
+	void RenderPasses::Pass(Scene& scene, Renderer& renderer)
+	{
+		if(!m_main_render_texture.IsInit())
+		{
+			auto extent = kvfGetSwapchainImagesSize(renderer.GetSwapchain().Get());
+			m_main_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_UNORM);
+		}
+
+		m_main_render_texture.Clear(renderer.GetActiveCommandBuffer(), Vec4f{ 0.0f, 0.0f, 0.0f, 1.0f });
+		scene.GetDepth().Clear(renderer.GetActiveCommandBuffer(), {});
+
+		if(scene.GetDescription().render_3D_enabled)
+			m_forward.Pass(scene, renderer, m_main_render_texture);
+		if(scene.GetDescription().render_skybox_enabled)
+			m_skybox.Pass(scene, renderer, m_main_render_texture);
+		if(scene.GetDescription().render_2D_enabled)
+			m_2Dpass.Pass(scene, renderer, m_main_render_texture);
+
+		m_final.Pass(scene, renderer, m_main_render_texture);
+	}
+
+	void RenderPasses::Destroy()
+	{
+		RenderCore::Get().WaitDeviceIdle();
+		m_skybox.Destroy();
+		m_2Dpass.Destroy();
+		m_final.Destroy();
+		m_main_render_texture.Destroy();
+	}
+}

ScopEngine/Runtime/Sources/Renderer/RenderPasses/SkyboxPass.cpp

@@ -0,0 +1,85 @@
+#include <Renderer/RenderPasses/SkyboxPass.h>
+#include <Renderer/Pipelines/Graphics.h>
+#include <Graphics/MeshFactory.h>
+#include <Renderer/ViewerData.h>
+#include <Renderer/Renderer.h>
+#include <Graphics/Scene.h>
+#include <Core/EventBus.h>
+#include <Core/Engine.h>
+
+namespace Scop
+{
+	void SkyboxPass::Init()
+	{
+		ShaderLayout vertex_shader_layout(
+			{
+				{ 0,
+					ShaderSetLayout({ 
+						{ 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER }
+					})
+				}
+			}, {}
+		);
+		p_vertex_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/SkyboxVertex.spv", ShaderType::Vertex, std::move(vertex_shader_layout));
+		ShaderLayout fragment_shader_layout(
+			{
+				{ 1,
+					ShaderSetLayout({ 
+						{ 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER }
+					})
+				}
+			}, {}
+		);
+		p_fragment_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/SkyboxFragment.spv", ShaderType::Fragment, std::move(fragment_shader_layout));
+
+		std::function<void(const EventBase&)> functor = [this](const EventBase& event)
+		{
+			if(event.What() == Event::ResizeEventCode || event.What() == Event::SceneHasChangedEventCode)
+				m_pipeline.Destroy();
+		};
+		EventBus::RegisterListener({ functor, "__ScopSkyboxPass" });
+
+		m_cube = CreateCube();
+		p_set = std::make_shared<DescriptorSet>(p_fragment_shader->GetShaderLayout().set_layouts[0].second, p_fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
+	}
+
+	void SkyboxPass::Pass(Scene& scene, Renderer& renderer, class Texture& render_target)
+	{
+		if(!scene.GetSkybox())
+			return;
+
+		if(m_pipeline.GetPipeline() == VK_NULL_HANDLE)
+		{
+			GraphicPipelineDescriptor pipeline_descriptor;
+			pipeline_descriptor.vertex_shader = p_vertex_shader;
+			pipeline_descriptor.fragment_shader = p_fragment_shader;
+			pipeline_descriptor.color_attachments = { &render_target };
+			pipeline_descriptor.depth = &scene.GetDepth();
+			pipeline_descriptor.culling = VK_CULL_MODE_NONE;
+			pipeline_descriptor.depth_test_equal = true;
+			pipeline_descriptor.clear_color_attachments = false;
+			m_pipeline.Init(pipeline_descriptor);
+		}
+
+		VkCommandBuffer cmd = renderer.GetActiveCommandBuffer();
+
+		p_set->SetImage(renderer.GetCurrentFrameIndex(), 0, *scene.GetSkybox());
+		p_set->Update(renderer.GetCurrentFrameIndex(), cmd);
+
+		m_pipeline.BindPipeline(cmd, 0, {});
+			std::array<VkDescriptorSet, 2> sets = { scene.GetForwardData().matrices_set->GetSet(renderer.GetCurrentFrameIndex()), p_set->GetSet(renderer.GetCurrentFrameIndex()) };
+			RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);
+			m_cube->Draw(cmd, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef());
+		m_pipeline.EndPipeline(cmd);
+	}
+
+	void SkyboxPass::Destroy()
+	{
+		RenderCore::Get().WaitDeviceIdle();
+		m_pipeline.Destroy();
+		p_vertex_shader.reset();
+		p_fragment_shader.reset();
+		m_cube.reset();
+		p_set.reset();
+	}
+}