checkpoint - first pass create texture pipelines

1 files changed, 257 insertions, 0 deletions

diff --git a/src/entities.cpp b/src/entities.cpp
index 15b2b76..58420b2 100644
--- a/src/entities.cpp
+++ b/src/entities.cpp
@@ -5,6 +5,8 @@ DynArray<EntityType> globalEntityTypes{16};
 VkDescriptorSetLayout vkDescriptorSetLayout_Texture = VK_NULL_HANDLE;
 VkPipelineLayout vkPipelineLayout_Texture = VK_NULL_HANDLE;
 VkSampler vkSampler_Texture = VK_NULL_HANDLE;
+VkPipeline vkPipeline_Texture;
+VkPipeline vkPipeline_TextureWireframe;
 
 VkPipelineLayoutCreateInfo sharedVkPipelineLayoutCreateInfo {
 	.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
@@ -119,6 +121,261 @@ void EntityType_Init() {
 	vkSamplerCreateInfo.unnormalizedCoordinates = VK_FALSE;
 	vkCreateSampler(vkDevice, &vkSamplerCreateInfo, vkAllocator, &vkSampler_Texture);
 
+	// pipelines
+	{
+		const long vertexBindingCount = 4;
+		long index = 0;
+		VkVertexInputBindingDescription vertInputBD[vertexBindingCount];
+		for (long i = 0; i < vertexBindingCount; ++i) {
+			vertInputBD[i].binding = i;
+		}
+		// model vertex
+		vertInputBD[index].stride = sizeof(glm::vec3);
+		vertInputBD[index].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+		index += 1;
+		// model normals
+		vertInputBD[index].stride = sizeof(glm::vec3);
+		vertInputBD[index].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+		index += 1;
+		// model UV
+		vertInputBD[index].stride = sizeof(glm::vec2);
+		vertInputBD[index].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+		index += 1;
+		// model index
+		// vertInputBD[index].stride = sizeof(uint16_t);
+		// vertInputBD[index++].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+		// index += 1;
+		// instance
+		vertInputBD[index].stride = sizeof(glm::vec3) * 3;
+		vertInputBD[index].inputRate = VK_VERTEX_INPUT_RATE_INSTANCE;
+
+		const long vertexAttrDescCount = 6;
+		long runningOffset = 0;
+		index = 0;
+		VkVertexInputAttributeDescription vertAttrDesc[vertexAttrDescCount];
+		for (long i = 0; i < vertexAttrDescCount; ++i) {
+			vertAttrDesc[i].location = i;
+		}
+
+		// model vertex
+		vertAttrDesc[index].binding = 0;
+		vertAttrDesc[index].format = VK_FORMAT_R32G32B32_SFLOAT;
+		vertAttrDesc[index].offset = runningOffset;
+		runningOffset += sizeof(glm::vec3);
+		index += 1;
+
+		// model normals
+		vertAttrDesc[index].binding = 1;
+		vertAttrDesc[index].format = VK_FORMAT_R32G32B32_SFLOAT;
+		vertAttrDesc[index].offset = runningOffset;
+		runningOffset += sizeof(glm::vec3);
+		index += 1;
+
+		// model UV
+		vertAttrDesc[index].binding = 2;
+		vertAttrDesc[index].format = VK_FORMAT_R32G32_SFLOAT;
+		vertAttrDesc[index].offset = runningOffset;
+		runningOffset += sizeof(glm::vec2);
+		index += 1;
+
+		// instance pos
+		vertAttrDesc[index].binding = 3;
+		vertAttrDesc[index].format = VK_FORMAT_R32G32B32_SFLOAT;
+		vertAttrDesc[index].offset = runningOffset;
+		runningOffset += sizeof(glm::vec3);
+		index += 1;
+
+		// instance rot
+		vertAttrDesc[index].binding = 3;
+		vertAttrDesc[index].format = VK_FORMAT_R32G32B32_SFLOAT;
+		vertAttrDesc[index].offset = runningOffset;
+		runningOffset += sizeof(glm::vec3);
+		index += 1;
+
+		// instance scale
+		vertAttrDesc[index].binding = 3;
+		vertAttrDesc[index].format = VK_FORMAT_R32G32B32_SFLOAT;
+		vertAttrDesc[index].offset = runningOffset;
+		// runningOffset += sizeof(glm::vec3);
+		// index += 1;
+
+		// instance texture index
+		// vertAttrDesc[index].binding = 3;
+		// vertAttrDesc[index].format = VK_FORMAT_R32_SFLOAT;
+		// vertAttrDesc[index].offset = runningOffset;
+		// runningOffset += sizeof(float);
+		// index += 1;
+
+		VkPipelineVertexInputStateCreateInfo vkPipelineVertexInputStateCreateInfo;
+		vkPipelineVertexInputStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+		vkPipelineVertexInputStateCreateInfo.pNext = nullptr;
+		vkPipelineVertexInputStateCreateInfo.flags = {};
+		vkPipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount = vertexBindingCount;
+		vkPipelineVertexInputStateCreateInfo.pVertexBindingDescriptions = vertInputBD;
+		vkPipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount = vertexAttrDescCount;
+		vkPipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions = vertAttrDesc;
+
+		VkPipelineInputAssemblyStateCreateInfo vkPipelineInputAssemblyStateCreateInfo;
+		vkPipelineInputAssemblyStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+		vkPipelineInputAssemblyStateCreateInfo.pNext = nullptr;
+		vkPipelineInputAssemblyStateCreateInfo.flags = {};
+		vkPipelineInputAssemblyStateCreateInfo.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+		vkPipelineInputAssemblyStateCreateInfo.primitiveRestartEnable = VK_FALSE;
+
+		// TODO - is this right? set to dynamic later
+		VkPipelineViewportStateCreateInfo vkPipelineViewportStateCreateInfo;
+		vkPipelineViewportStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+		vkPipelineViewportStateCreateInfo.pNext = nullptr;
+		vkPipelineViewportStateCreateInfo.flags = {};
+		vkPipelineViewportStateCreateInfo.viewportCount = 1;
+		vkPipelineViewportStateCreateInfo.pViewports = nullptr;
+		vkPipelineViewportStateCreateInfo.scissorCount = 1;
+		vkPipelineViewportStateCreateInfo.pScissors = nullptr;
+
+		VkPipelineRasterizationStateCreateInfo vkPipelineRasterizationStateCreateInfoFill;
+		vkPipelineRasterizationStateCreateInfoFill.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+		vkPipelineRasterizationStateCreateInfoFill.pNext = nullptr;
+		vkPipelineRasterizationStateCreateInfoFill.flags = {};
+		vkPipelineRasterizationStateCreateInfoFill.depthClampEnable = VK_FALSE;
+		vkPipelineRasterizationStateCreateInfoFill.rasterizerDiscardEnable = VK_FALSE;
+		vkPipelineRasterizationStateCreateInfoFill.polygonMode = VK_POLYGON_MODE_FILL;
+		vkPipelineRasterizationStateCreateInfoFill.cullMode = VK_CULL_MODE_BACK_BIT;
+		vkPipelineRasterizationStateCreateInfoFill.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+		vkPipelineRasterizationStateCreateInfoFill.depthBiasEnable = VK_FALSE;
+		vkPipelineRasterizationStateCreateInfoFill.depthBiasConstantFactor = 0.0f;
+		vkPipelineRasterizationStateCreateInfoFill.depthBiasClamp = 0.0f;
+		vkPipelineRasterizationStateCreateInfoFill.depthBiasSlopeFactor = 0.0f;
+		vkPipelineRasterizationStateCreateInfoFill.lineWidth = 1.0f;
+
+		VkPipelineRasterizationStateCreateInfo vkPipelineRasterizationStateCreateInfoLine{vkPipelineRasterizationStateCreateInfoFill};
+		vkPipelineRasterizationStateCreateInfoLine.polygonMode = VK_POLYGON_MODE_LINE;
+
+		// TODO MultiSampling
+		VkPipelineMultisampleStateCreateInfo vkPipelineMultisampleStateCreateInfo;
+		vkPipelineMultisampleStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+		vkPipelineMultisampleStateCreateInfo.pNext = nullptr;
+		vkPipelineMultisampleStateCreateInfo.flags = {};
+		vkPipelineMultisampleStateCreateInfo.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+		vkPipelineMultisampleStateCreateInfo.sampleShadingEnable = VK_FALSE;
+		vkPipelineMultisampleStateCreateInfo.minSampleShading = 0.0f;
+		vkPipelineMultisampleStateCreateInfo.pSampleMask = nullptr;
+		vkPipelineMultisampleStateCreateInfo.alphaToCoverageEnable = {};
+		vkPipelineMultisampleStateCreateInfo.alphaToOneEnable = {};
+
+		// TODO Transparency
+		VkPipelineColorBlendAttachmentState vkPipelineColorBlendAttachmentState[0];
+		vkPipelineColorBlendAttachmentState[0].blendEnable = VK_FALSE;
+		vkPipelineColorBlendAttachmentState[0].srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+		vkPipelineColorBlendAttachmentState[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+		vkPipelineColorBlendAttachmentState[0].colorBlendOp = VK_BLEND_OP_ADD;
+		vkPipelineColorBlendAttachmentState[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+		vkPipelineColorBlendAttachmentState[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+		vkPipelineColorBlendAttachmentState[0].alphaBlendOp = VK_BLEND_OP_SUBTRACT;
+		vkPipelineColorBlendAttachmentState[0].colorWriteMask =
+			VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
+			VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+
+		VkPipelineColorBlendStateCreateInfo vkPipelineColorBlendStateCreateInfo;
+		vkPipelineColorBlendStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+		vkPipelineColorBlendStateCreateInfo.pNext = nullptr;
+		vkPipelineColorBlendStateCreateInfo.flags = {};
+		vkPipelineColorBlendStateCreateInfo.logicOpEnable = VK_FALSE;
+		vkPipelineColorBlendStateCreateInfo.logicOp = VK_LOGIC_OP_COPY;
+		vkPipelineColorBlendStateCreateInfo.attachmentCount = 1;
+		vkPipelineColorBlendStateCreateInfo.pAttachments = vkPipelineColorBlendAttachmentState;
+		vkPipelineColorBlendStateCreateInfo.blendConstants[0] = 0.0f;
+		vkPipelineColorBlendStateCreateInfo.blendConstants[1] = 0.0f;
+		vkPipelineColorBlendStateCreateInfo.blendConstants[2] = 0.0f;
+		vkPipelineColorBlendStateCreateInfo.blendConstants[3] = 0.0f;
+
+		VkDynamicState dynamicStates[2] = { VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_VIEWPORT };
+		VkPipelineDynamicStateCreateInfo vkPipelineDynamicStateCreateInfo;
+		vkPipelineDynamicStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+		vkPipelineDynamicStateCreateInfo.pNext = nullptr;
+		vkPipelineDynamicStateCreateInfo.flags = {};
+		vkPipelineDynamicStateCreateInfo.dynamicStateCount = 2;
+		vkPipelineDynamicStateCreateInfo.pDynamicStates = dynamicStates;
+
+		VkPipelineDepthStencilStateCreateInfo vkPipelineDepthStencilStateCreateInfo;
+		vkPipelineDepthStencilStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+		vkPipelineDepthStencilStateCreateInfo.pNext = nullptr;
+		vkPipelineDepthStencilStateCreateInfo.flags = {};
+		vkPipelineDepthStencilStateCreateInfo.depthTestEnable = VK_TRUE;
+		vkPipelineDepthStencilStateCreateInfo.depthWriteEnable = VK_TRUE;
+		vkPipelineDepthStencilStateCreateInfo.depthCompareOp = VK_COMPARE_OP_LESS;
+		vkPipelineDepthStencilStateCreateInfo.depthBoundsTestEnable = VK_FALSE;
+		vkPipelineDepthStencilStateCreateInfo.stencilTestEnable = VK_FALSE;
+		vkPipelineDepthStencilStateCreateInfo.front = {};
+		vkPipelineDepthStencilStateCreateInfo.back = {};
+		vkPipelineDepthStencilStateCreateInfo.minDepthBounds = {};
+		vkPipelineDepthStencilStateCreateInfo.maxDepthBounds = {};
+
+		AssetHandle vertShaderAssetHandle = AM_Register("assets/shaders/vert.vert.spv");
+		AssetHandle textureFragShaderAssetHandle = AM_Register("assets/shaders/texture.frag.spv");
+		const Asset *vertShaderAsset = AM_Get(vertShaderAssetHandle);
+		const Asset *fragShaderAsset = AM_Get(vertShaderAssetHandle);
+		VkShaderModuleCreateInfo vkShaderModuleCreateInfo[2];
+		vkShaderModuleCreateInfo[0].codeSize = vertShaderAsset->size;
+		vkShaderModuleCreateInfo[0].pCode = reinterpret_cast<const uint32_t *>(vertShaderAsset->ptr);
+		vkShaderModuleCreateInfo[1].codeSize = fragShaderAsset->size;
+		vkShaderModuleCreateInfo[1].pCode = reinterpret_cast<const uint32_t *>(fragShaderAsset->ptr);
+		VkShaderModule shaderModules[2];
+
+		VkPipelineShaderStageCreateInfo vkPipelineShaderStageCreateInfo[2];
+		for (long i = 0; i < 2; ++i) {
+			vkShaderModuleCreateInfo[i].sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+			vkShaderModuleCreateInfo[i].pNext = nullptr;
+			vkShaderModuleCreateInfo[i].flags = {};
+			vkPipelineShaderStageCreateInfo[i].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+			vkPipelineShaderStageCreateInfo[i].pNext = nullptr;
+			vkPipelineShaderStageCreateInfo[i].flags = {};
+			vkPipelineShaderStageCreateInfo[i].pName = "main";
+			vkPipelineShaderStageCreateInfo[i].pSpecializationInfo = nullptr;
+
+			vkCreateShaderModule(vkDevice, &vkShaderModuleCreateInfo[0], vkAllocator, &shaderModules[i]);
+		}
+
+		vkPipelineShaderStageCreateInfo[0].module = shaderModules[0];
+		vkPipelineShaderStageCreateInfo[1].module = shaderModules[1];
+		vkPipelineShaderStageCreateInfo[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
+		vkPipelineShaderStageCreateInfo[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+
+		VkGraphicsPipelineCreateInfo vkGraphicsPipelineCreateInfoFill;
+		vkGraphicsPipelineCreateInfoFill.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+		vkGraphicsPipelineCreateInfoFill.pNext = nullptr;
+		vkGraphicsPipelineCreateInfoFill.flags = {};
+		vkGraphicsPipelineCreateInfoFill.stageCount = 2;
+		vkGraphicsPipelineCreateInfoFill.pStages = vkPipelineShaderStageCreateInfo;
+		vkGraphicsPipelineCreateInfoFill.pVertexInputState = &vkPipelineVertexInputStateCreateInfo;
+		vkGraphicsPipelineCreateInfoFill.pInputAssemblyState = &vkPipelineInputAssemblyStateCreateInfo;
+		vkGraphicsPipelineCreateInfoFill.pTessellationState = nullptr;
+		vkGraphicsPipelineCreateInfoFill.pViewportState = &vkPipelineViewportStateCreateInfo;
+		vkGraphicsPipelineCreateInfoFill.pRasterizationState = &vkPipelineRasterizationStateCreateInfoLine;
+		vkGraphicsPipelineCreateInfoFill.pMultisampleState = &vkPipelineMultisampleStateCreateInfo;
+		vkGraphicsPipelineCreateInfoFill.pDepthStencilState = &vkPipelineDepthStencilStateCreateInfo;
+		vkGraphicsPipelineCreateInfoFill.pColorBlendState = &vkPipelineColorBlendStateCreateInfo;
+		vkGraphicsPipelineCreateInfoFill.pDynamicState = &vkPipelineDynamicStateCreateInfo;
+		vkGraphicsPipelineCreateInfoFill.layout = vkPipelineLayout_Texture;
+		vkGraphicsPipelineCreateInfoFill.renderPass = vkRenderPass;
+		vkGraphicsPipelineCreateInfoFill.subpass = 0;
+		vkGraphicsPipelineCreateInfoFill.basePipelineHandle = VK_NULL_HANDLE;
+		vkGraphicsPipelineCreateInfoFill.basePipelineIndex = {};
+
+		VkGraphicsPipelineCreateInfo vkGraphicsPipelineCreateInfoLine{vkGraphicsPipelineCreateInfoFill};
+		vkGraphicsPipelineCreateInfoLine.pRasterizationState = &vkPipelineRasterizationStateCreateInfoLine;
+
+		VkGraphicsPipelineCreateInfo createPipelineInfos[2] = { vkGraphicsPipelineCreateInfoFill, vkGraphicsPipelineCreateInfoLine };
+		VkPipeline pipelines[2] = { vkPipeline_Texture, vkPipeline_TextureWireframe };
+		vkCreateGraphicsPipelines(vkDevice, VK_NULL_HANDLE, 2, createPipelineInfos, vkAllocator, pipelines);
+
+		for (long i = 0; i < 2; ++i) {
+			vkDestroyShaderModule(vkDevice, shaderModules[i], vkAllocator);
+		}
+
+		AM_Destroy(textureFragShaderAssetHandle);
+		AM_Destroy(vertShaderAssetHandle);
+	}
+
 	long entityTypeCount = globalEntityTypes.Count();
 	for (long i = 0; i < entityTypeCount; ++i) {
 		EntityType_Load(globalEntityTypes[i]);