Vulkan: Some more work for the pipeline

include/anki/gr/Pipeline.h

@@ -49,7 +49,7 @@ public:
 class TessellationStateInfo
 {
 public:
-	U32 m_patchControlPointsCount = 3;
+	U32 m_patchControlPointCount = 3;
 };
 
 class ViewportStateInfo

include/anki/gr/vulkan/Common.h

@@ -40,10 +40,31 @@ class GrManagerImpl;
 #endif
 
 /// Convert compare op.
-VkCompareOp convertCompareOp(CompareOperation ak);
+ANKI_USE_RESULT VkCompareOp convertCompareOp(CompareOperation ak);
 
 /// Convert format.
-VkFormat convertFormat(PixelFormat ak);
+ANKI_USE_RESULT VkFormat convertFormat(PixelFormat ak);
+
+/// Convert topology.
+ANKI_USE_RESULT VkPrimitiveTopology convertTopology(PrimitiveTopology ak);
+
+/// Convert fill mode.
+ANKI_USE_RESULT VkPolygonMode convertFillMode(FillMode ak);
+
+/// Convert cull mode.
+ANKI_USE_RESULT VkCullModeFlags convertCullMode(CullMode ak);
+
+/// Convert blend method.
+ANKI_USE_RESULT VkBlendFactor convertBlendMethod(BlendMethod ak);
+
+/// Convert blend function.
+ANKI_USE_RESULT VkBlendOp convertBlendFunc(BlendFunction ak);
+
+/// Convert color write mask.
+inline ANKI_USE_RESULT VkColorComponentFlags convertColorWriteMask(ColorBit ak)
+{
+	return static_cast<U>(ak);
+}
 /// @}
 
 } // end namespace anki

include/anki/gr/vulkan/PipelineImpl.h

@@ -13,6 +13,11 @@ namespace anki
 // Forward
 class VertexStateInfo;
 class InputAssemblerStateInfo;
+class TessellationStateInfo;
+class ViewportStateInfo;
+class RasterizerStateInfo;
+class DepthStencilStateInfo;
+class ColorStateInfo;
 
 /// @addtogroup vulkan
 /// @{
@@ -45,6 +50,27 @@ private:
 	ANKI_USE_RESULT VkPipelineInputAssemblyStateCreateInfo*
 	initInputAssemblyState(const InputAssemblerStateInfo& ia,
 		VkPipelineInputAssemblyStateCreateInfo& ci);
+
+	ANKI_USE_RESULT VkPipelineTessellationStateCreateInfo*
+	initTessellationState(const TessellationStateInfo& t,
+		VkPipelineTessellationStateCreateInfo& ci);
+
+	ANKI_USE_RESULT VkPipelineViewportStateCreateInfo*
+	initViewportState(VkPipelineViewportStateCreateInfo& ci);
+
+	ANKI_USE_RESULT VkPipelineRasterizationStateCreateInfo*
+	initRasterizerState(const RasterizerStateInfo& r, 
+		VkPipelineRasterizationStateCreateInfo& ci);
+
+	ANKI_USE_RESULT VkPipelineMultisampleStateCreateInfo* initMsState(
+		VkPipelineMultisampleStateCreateInfo& ci);
+
+	ANKI_USE_RESULT VkPipelineDepthStencilStateCreateInfo* initDsState(
+		const DepthStencilStateInfo& ds,
+		VkPipelineDepthStencilStateCreateInfo& ci);
+
+	ANKI_USE_RESULT VkPipelineColorBlendStateCreateInfo* initColorState(
+		const ColorStateInfo& c, VkPipelineColorBlendStateCreateInfo& ci);
 };
 /// @}
 

src/gr/gl/PipelineImpl.cpp

@@ -527,7 +527,7 @@ void PipelineImpl::setTessellationState(GlState& state) const
 	state.m_stateHashes.m_tessellation = m_hashes.m_tessellation;
 
 	glPatchParameteri(
-		GL_PATCH_VERTICES, m_in.m_tessellation.m_patchControlPointsCount);
+		GL_PATCH_VERTICES, m_in.m_tessellation.m_patchControlPointCount);
 }
 
 //==============================================================================

src/gr/vulkan/Common.cpp

@@ -269,4 +269,178 @@ VkFormat convertFormat(PixelFormat ak)
 	return out;
 }
 
+//==============================================================================
+VkPrimitiveTopology convertTopology(PrimitiveTopology ak)
+{
+	VkPrimitiveTopology out = VK_PRIMITIVE_TOPOLOGY_MAX_ENUM;
+	switch(ak)
+	{
+	case POINTS:
+		out = VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
+		break;
+	case LINES:
+		out = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
+		break;
+	case LINE_STIP:
+		out = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
+		break;
+	case TRIANGLES:
+		out = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+		break;
+	case TRIANGLE_STRIP:
+		out = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
+		break;
+	case PATCHES:
+		out = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
+		break;
+	default:
+		ANKI_ASSERT(0);
+	}
+
+	return out;
+}
+
+//==============================================================================
+VkPolygonMode convertFillMode(FillMode ak)
+{
+	VkPolygonMode out = VK_POLYGON_MODE_FILL;
+	switch(ak)
+	{
+	case FillMode::POINTS:
+		out = VK_POLYGON_MODE_POINT;
+		break;
+	case FillMode::WIREFRAME:
+		out = VK_POLYGON_MODE_LINE;
+		break;
+	case FillMode::SOLID:
+		out = VK_POLYGON_MODE_FILL;
+		break;
+	default:
+		ANKI_ASSERT(0);
+	}
+
+	return out;
+}
+
+//==============================================================================
+VkCullModeFlags convertCullMode(CullMode ak)
+{
+	VkCullModeFlags out = 0;
+	switch(ak)
+	{
+	case CullMode::FRONT:
+		out = VK_CULL_MODE_FRONT_BIT;
+		break;
+	case CullMode::BACK:
+		out = VK_CULL_MODE_BACK_BIT;
+		break;
+	case CullMode::FRONT_AND_BACK:
+		out = VK_CULL_MODE_FRONT_BIT | VK_CULL_MODE_BACK_BIT;
+		break;
+	default:
+		ANKI_ASSERT(0);
+	}
+
+	return out;
+}
+
+//==============================================================================
+VkBlendFactor convertBlendMethod(BlendMethod ak)
+{
+	VkBlendFactor out = VK_BLEND_FACTOR_MAX_ENUM;
+	switch(ak)
+	{
+	case BlendMethod::ZERO:
+		out = VK_BLEND_FACTOR_ZERO;
+		break;
+	case BlendMethod::ONE:
+		out = VK_BLEND_FACTOR_ONE;
+		break;
+	case BlendMethod::SRC_COLOR:
+		out = VK_BLEND_FACTOR_SRC_COLOR;
+		break;
+	case BlendMethod::ONE_MINUS_SRC_COLOR:
+		out = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
+		break;
+	case BlendMethod::DST_COLOR:
+		out = VK_BLEND_FACTOR_DST_COLOR;
+		break;
+	case BlendMethod::ONE_MINUS_DST_COLOR:
+		out = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
+		break;
+	case BlendMethod::SRC_ALPHA:
+		out = VK_BLEND_FACTOR_SRC_ALPHA;
+		break;
+	case BlendMethod::ONE_MINUS_SRC_ALPHA:
+		out = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+		break;
+	case BlendMethod::DST_ALPHA:
+		out = VK_BLEND_FACTOR_DST_ALPHA;
+		break;
+	case BlendMethod::ONE_MINUS_DST_ALPHA:
+		out = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
+		break;
+	case BlendMethod::CONSTANT_COLOR:
+		out = VK_BLEND_FACTOR_CONSTANT_COLOR;
+		break;
+	case BlendMethod::ONE_MINUS_CONSTANT_COLOR:
+		out = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR;
+		break;
+	case BlendMethod::CONSTANT_ALPHA:
+		out = VK_BLEND_FACTOR_CONSTANT_ALPHA;
+		break;
+	case BlendMethod::ONE_MINUS_CONSTANT_ALPHA:
+		out = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA;
+		break;
+	case BlendMethod::SRC_ALPHA_SATURATE:
+		out = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;
+		break;
+	case BlendMethod::SRC1_COLOR:
+		out = VK_BLEND_FACTOR_SRC1_COLOR;
+		break;
+	case BlendMethod::ONE_MINUS_SRC1_COLOR:
+		out = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR;
+		break;
+	case BlendMethod::SRC1_ALPHA:
+		out = VK_BLEND_FACTOR_SRC1_ALPHA;
+		break;
+	case BlendMethod::ONE_MINUS_SRC1_ALPHA:
+		out = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA;
+		break;
+	default:
+		ANKI_ASSERT(0);
+	}
+
+	return out;
+}
+
+//==============================================================================
+VkBlendOp convertBlendFunc(BlendFunction ak)
+{
+	VkBlendOp out = VK_BLEND_OP_MAX_ENUM;
+
+	switch(ak)
+	{
+	case BlendFunction::ADD:
+		out = VK_BLEND_OP_ADD;
+		break;
+	case BlendFunction::SUBTRACT:
+		out = VK_BLEND_OP_SUBTRACT;
+		break;
+	case BlendFunction::REVERSE_SUBTRACT:
+		out = VK_BLEND_OP_REVERSE_SUBTRACT;
+		break;
+	case BlendFunction::MIN:
+		out = VK_BLEND_OP_MIN;
+		break;
+	case BlendFunction::MAX:
+		out = VK_BLEND_OP_MAX;
+		break;
+	default:
+		ANKI_ASSERT(0);
+	}
+
+	return out;
+}
+
 } // end namespace anki

src/gr/vulkan/PipelineImpl.cpp

@@ -29,6 +29,8 @@ public:
 	VkPipelineRasterizationStateCreateInfo m_rast;
 	VkPipelineMultisampleStateCreateInfo m_ms;
 	VkPipelineDepthStencilStateCreateInfo m_ds;
+	Array<VkPipelineColorBlendAttachmentState, MAX_COLOR_ATTACHMENTS> 
+		m_attachments;
 	VkPipelineColorBlendStateCreateInfo m_color;
 	VkPipelineDynamicStateCreateInfo m_dyn;
 
@@ -63,6 +65,7 @@ public:
 
 		m_color.sType =
 			VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+		m_color.pAttachments = &m_attachments[0];
 
 		m_dyn.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
 	}
@@ -82,12 +85,27 @@ Error PipelineImpl::initGraphics(const PipelineInitInfo& init)
 	ci.pStages = &ci.m_stages[0];
 	initShaders(init, ci);
 
+	// Init sub-states
 	ci.pVertexInputState = initVertexStage(init.m_vertex, ci.m_vertex);
-
+	ci.pInputAssemblyState = initInputAssemblyState(
+		init.m_inputAssembler, ci.m_ia);
+	ci.pTessellationState = initTessellationState(
+		init.m_tessellation, ci.m_tess);
+	ci.pViewportState = initViewportState(ci.m_vp);
+	ci.pRasterizationState = initRasterizerState(init.m_rasterizer, ci.m_rast);
+	ci.pMultisampleState = initMsState(ci.m_ms);
+	ci.pDepthStencilState = initDsState(init.m_depthStencil, ci.m_ds);
+	ci.pColorBlendState = initColorState(init.m_color, ci.m_color);
+	ci.pDynamicState = nullptr; // No dynamic state as static at the moment
+
+	// Finalize
 	ci.layout = getGrManagerImpl().m_globalPipelineLayout;
 	ci.renderPass = getGrManagerImpl().getOrCreateCompatibleRenderPass(init);
 	ci.basePipelineHandle = VK_NULL_HANDLE;
 
+	ANKI_VK_CHECK(vkCreateGraphicsPipelines(
+		getDevice(), nullptr, 1, &ci, nullptr, &m_handle));
+
 	return ErrorCode::NONE;
 }
 
@@ -182,7 +200,90 @@ VkPipelineInputAssemblyStateCreateInfo* PipelineImpl::initInputAssemblyState(
 	const InputAssemblerStateInfo& ia,
 	VkPipelineInputAssemblyStateCreateInfo& ci)
 {
-	// TODO
+	ci.topology = convertTopology(ia.m_topology);
+	ci.primitiveRestartEnable = ia.m_primitiveRestartEnabled;
+
+	return &ci;
+}
+
+//==============================================================================
+VkPipelineTessellationStateCreateInfo* PipelineImpl::initTessellationState(
+	const TessellationStateInfo& t, VkPipelineTessellationStateCreateInfo& ci)
+{
+	ci.patchControlPoints = t.m_patchControlPointCount;
+	return &ci;
+}
+
+//==============================================================================
+VkPipelineViewportStateCreateInfo* PipelineImpl::initViewportState(
+	VkPipelineViewportStateCreateInfo& ci)
+{
+	// Viewport is dynamic
+	return nullptr;
+}
+
+//==============================================================================
+VkPipelineRasterizationStateCreateInfo* PipelineImpl::initRasterizerState(
+	const RasterizerStateInfo& r, VkPipelineRasterizationStateCreateInfo& ci)
+{
+	ci.depthClampEnable = VK_FALSE;
+	ci.rasterizerDiscardEnable = VK_FALSE;
+	ci.polygonMode = convertFillMode(r.m_fillMode);
+	ci.cullMode = convertCullMode(r.m_cullMode);
+	ci.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+	ci.depthBiasEnable = VK_FALSE; // Dynamic
+
+	return &ci;
+}
+
+//==============================================================================
+VkPipelineMultisampleStateCreateInfo* PipelineImpl::initMsState(
+	VkPipelineMultisampleStateCreateInfo& ci)
+{
+	// No MS for now
+	return nullptr;
+}
+
+//==============================================================================
+VkPipelineDepthStencilStateCreateInfo* PipelineImpl::initDsState(
+	const DepthStencilStateInfo& ds,
+	VkPipelineDepthStencilStateCreateInfo& ci)
+{
+	ci.depthTestEnable = ds.m_depthCompareFunction != CompareOperation::ALWAYS 
+		|| ds.m_depthWriteEnabled;
+	ci.depthWriteEnable = ds.m_depthWriteEnabled;
+	ci.depthCompareOp = convertCompareOp(ds.m_depthCompareFunction);
+	ci.depthBoundsTestEnable = VK_FALSE;
+	ci.stencilTestEnable = VK_FALSE; // For now no stencil
+
+	return &ci;
+}
+
+//==============================================================================
+VkPipelineColorBlendStateCreateInfo* PipelineImpl::initColorState(
+	const ColorStateInfo& c, VkPipelineColorBlendStateCreateInfo& ci)
+{
+	ci.logicOpEnable = VK_FALSE;
+	ci.attachmentCount = c.m_attachmentCount;
+
+	for(U i = 0; i < ci.attachmentCount; ++i)
+	{
+		VkPipelineColorBlendAttachmentState& out = 
+			const_cast<VkPipelineColorBlendAttachmentState&>(
+				ci.pAttachments[i]);
+		const ColorAttachmentStateInfo& in = c.m_attachments[i];
+		out.blendEnable = !(in.m_srcBlendMethod == BlendMethod::ONE 
+			&& in.m_dstBlendMethod == BlendMethod::ZERO);
+		out.srcColorBlendFactor = convertBlendMethod(in.m_srcBlendMethod);
+		out.dstColorBlendFactor = convertBlendMethod(in.m_dstBlendMethod);
+		out.colorBlendOp = convertBlendFunc(in.m_blendFunction);
+		out.srcAlphaBlendFactor = out.srcColorBlendFactor;
+		out.dstAlphaBlendFactor = out.dstColorBlendFactor;
+		out.alphaBlendOp = out.colorBlendOp;
+
+		out.colorWriteMask = convertColorWriteMask(in.m_channelWriteMask);
+	}
+
 	return &ci;
 }