WIP

Author: karnkaul

guide/src/SUMMARY.md

@@ -27,3 +27,4 @@
 - [Graphics Pipeline](pipeline/README.md)
   - [Locating Assets](pipeline/locating_assets.md)
   - [Shaders](pipeline/shaders.md)
+  - [Pipeline Creation](pipeline/creation.md)

guide/src/pipeline/creation.md

@@ -0,0 +1 @@
+# Pipeline Creation

src/app.cpp

@@ -40,6 +40,7 @@ void App::run(std::string_view const assets_dir) {
 	create_swapchain();
 	create_render_sync();
 	create_imgui();
+	create_pipeline_builder();
 
 	create_pipeline();
 
@@ -177,8 +178,13 @@ void App::create_imgui() {
 	m_imgui.emplace(imgui_ci);
 }
 
-auto App::asset_path(std::string_view const uri) const -> fs::path {
-	return m_assets_dir / uri;
+void App::create_pipeline_builder() {
+	auto const pipeline_builder_ci = PipelineBuilder::CreateInfo{
+		.device = *m_device,
+		.samples = vk::SampleCountFlagBits::e1,
+		.color_format = m_swapchain->get_format(),
+	};
+	m_pipeline_builder.emplace(pipeline_builder_ci);
 }
 
 void App::create_pipeline() {
@@ -192,7 +198,19 @@ void App::create_pipeline() {
 	}
 	std::println("[lvk] Shaders loaded");
 
-	// TODO
+	m_pipeline_layout = m_device->createPipelineLayoutUnique({});
+	auto const pipeline_state = PipelineState{
+		.vertex_shader = *vertex,
+		.fragment_shader = *fragment,
+	};
+	m_pipeline = m_pipeline_builder->build(*m_pipeline_layout, pipeline_state);
+	if (!m_pipeline) {
+		throw std::runtime_error{"Failed to create Graphics Pipeline"};
+	}
+}
+
+auto App::asset_path(std::string_view const uri) const -> fs::path {
+	return m_assets_dir / uri;
 }
 
 void App::main_loop() {
@@ -282,7 +300,15 @@ void App::render(vk::CommandBuffer const command_buffer) {
 
 	command_buffer.beginRendering(rendering_info);
 	ImGui::ShowDemoWindow();
-	// draw stuff here.
+	command_buffer.bindPipeline(vk::PipelineBindPoint::eGraphics, *m_pipeline);
+	auto viewport = vk::Viewport{};
+	viewport.setX(0.0f)
+		.setY(static_cast<float>(m_render_target->extent.height))
+		.setWidth(static_cast<float>(m_render_target->extent.width))
+		.setHeight(-viewport.y);
+	command_buffer.setViewport(0, viewport);
+	command_buffer.setScissor(0, render_area);
+	command_buffer.draw(3, 1, 0, 0);
 	command_buffer.endRendering();
 
 	m_imgui->end_frame();

src/app.hpp

@@ -1,10 +1,10 @@
 #pragma once
 #include <dear_imgui.hpp>
 #include <gpu.hpp>
+#include <pipeline_builder.hpp>
 #include <resource_buffering.hpp>
 #include <scoped_waiter.hpp>
 #include <swapchain.hpp>
-#include <vulkan/vulkan.hpp>
 #include <window.hpp>
 #include <filesystem>
 
@@ -35,6 +35,7 @@ class App {
 	void create_swapchain();
 	void create_render_sync();
 	void create_imgui();
+	void create_pipeline_builder();
 	void create_pipeline();
 
 	[[nodiscard]] auto asset_path(std::string_view uri) const -> fs::path;
@@ -67,6 +68,10 @@ class App {
 	std::size_t m_frame_index{};
 
 	std::optional<DearImGui> m_imgui{};
+	std::optional<PipelineBuilder> m_pipeline_builder{};
+
+	vk::UniquePipelineLayout m_pipeline_layout{};
+	vk::UniquePipeline m_pipeline{};
 
 	glm::ivec2 m_framebuffer_size{};
 	std::optional<RenderTarget> m_render_target{};

src/pipeline_builder.cpp

@@ -0,0 +1,87 @@
+#include <pipeline_builder.hpp>
+
+namespace lvk {
+PipelineBuilder::PipelineBuilder(CreateInfo const& create_info)
+	: m_info(create_info) {}
+
+auto PipelineBuilder::build(vk::PipelineLayout const layout,
+							PipelineState const& state) const
+	-> vk::UniquePipeline {
+	auto shader_stages = std::array<vk::PipelineShaderStageCreateInfo, 2>{};
+	shader_stages[0]
+		.setStage(vk::ShaderStageFlagBits::eVertex)
+		.setPName("main")
+		.setModule(state.vertex_shader);
+	shader_stages[1]
+		.setStage(vk::ShaderStageFlagBits::eFragment)
+		.setPName("main")
+		.setModule(state.fragment_shader);
+
+	auto prsci = vk::PipelineRasterizationStateCreateInfo{};
+	prsci.setPolygonMode(state.polygon_mode).setCullMode(state.cull_mode);
+
+	auto pdssci = vk::PipelineDepthStencilStateCreateInfo{};
+	auto const depth_test =
+		(state.flags & PipelineFlag::DepthTest) == PipelineFlag::DepthTest;
+	pdssci.setDepthTestEnable(depth_test ? vk::True : vk::False)
+		.setDepthCompareOp(state.depth_compare);
+
+	auto const piasci =
+		vk::PipelineInputAssemblyStateCreateInfo{{}, state.topology};
+
+	auto pcbas = vk::PipelineColorBlendAttachmentState{};
+	auto const alpha_blend =
+		(state.flags & PipelineFlag::AlphaBlend) == PipelineFlag::AlphaBlend;
+	using CCF = vk::ColorComponentFlagBits;
+	pcbas.setColorWriteMask(CCF::eR | CCF::eG | CCF::eB | CCF::eA)
+		.setBlendEnable(alpha_blend ? vk::True : vk::False)
+		.setSrcColorBlendFactor(vk::BlendFactor::eSrcAlpha)
+		.setDstColorBlendFactor(vk::BlendFactor::eOneMinusSrcAlpha)
+		.setColorBlendOp(vk::BlendOp::eAdd)
+		.setSrcAlphaBlendFactor(vk::BlendFactor::eOne)
+		.setDstAlphaBlendFactor(vk::BlendFactor::eZero)
+		.setAlphaBlendOp(vk::BlendOp::eAdd);
+	auto pcbsci = vk::PipelineColorBlendStateCreateInfo{};
+	pcbsci.setAttachments(pcbas);
+
+	auto const pdscis = std::array{
+		vk::DynamicState::eViewport,
+		vk::DynamicState::eScissor,
+		vk::DynamicState::eLineWidth,
+	};
+	auto pdsci = vk::PipelineDynamicStateCreateInfo{};
+	pdsci.setDynamicStates(pdscis);
+
+	auto const pvsci = vk::PipelineViewportStateCreateInfo({}, 1, {}, 1);
+
+	auto pmsci = vk::PipelineMultisampleStateCreateInfo{};
+	pmsci.setRasterizationSamples(m_info.samples)
+		.setSampleShadingEnable(vk::False);
+
+	auto prci = vk::PipelineRenderingCreateInfo{};
+	if (m_info.color_format != vk::Format::eUndefined) {
+		prci.setColorAttachmentFormats(m_info.color_format);
+	}
+	prci.setDepthAttachmentFormat(m_info.depth_format);
+
+	auto gpci = vk::GraphicsPipelineCreateInfo{};
+	gpci.setStages(shader_stages)
+		.setPRasterizationState(&prsci)
+		.setPDepthStencilState(&pdssci)
+		.setPInputAssemblyState(&piasci)
+		.setPColorBlendState(&pcbsci)
+		.setPDynamicState(&pdsci)
+		.setPViewportState(&pvsci)
+		.setPMultisampleState(&pmsci)
+		.setLayout(layout)
+		.setPNext(&prci);
+
+	auto ret = vk::Pipeline{};
+	if (m_info.device.createGraphicsPipelines({}, 1, &gpci, {}, &ret) !=
+		vk::Result::eSuccess) {
+		return {};
+	}
+
+	return vk::UniquePipeline{ret, m_info.device};
+}
+} // namespace lvk

src/pipeline_builder.hpp

@@ -0,0 +1,25 @@
+#pragma once
+#include <pipeline_state.hpp>
+
+namespace lvk {
+struct PipelineBuilderCreateInfo {
+	vk::Device device{};
+	vk::SampleCountFlagBits samples{};
+	vk::Format color_format{};
+	vk::Format depth_format{};
+};
+
+class PipelineBuilder {
+  public:
+	using CreateInfo = PipelineBuilderCreateInfo;
+
+	explicit PipelineBuilder(CreateInfo const& create_info);
+
+	[[nodiscard]] auto build(vk::PipelineLayout layout,
+							 PipelineState const& state) const
+		-> vk::UniquePipeline;
+
+  private:
+	CreateInfo m_info{};
+};
+} // namespace lvk

src/pipeline_state.hpp

@@ -0,0 +1,29 @@
+#pragma once
+#include <vulkan/vulkan.hpp>
+
+namespace lvk {
+struct PipelineFlag {
+	enum : std::uint8_t {
+		None = 0,
+		AlphaBlend = 1 << 0,
+		DepthTest = 1 << 1,
+	};
+};
+
+struct PipelineState {
+	using Flag = PipelineFlag;
+
+	[[nodiscard]] static constexpr auto default_flags() -> std::uint8_t {
+		return Flag::AlphaBlend | Flag::DepthTest;
+	}
+
+	vk::ShaderModule vertex_shader;
+	vk::ShaderModule fragment_shader;
+
+	vk::PrimitiveTopology topology{vk::PrimitiveTopology::eTriangleList};
+	vk::PolygonMode polygon_mode{vk::PolygonMode::eFill};
+	vk::CullModeFlags cull_mode{vk::CullModeFlagBits::eNone};
+	vk::CompareOp depth_compare{vk::CompareOp::eLess};
+	std::uint8_t flags{default_flags()};
+};
+} // namespace lvk