From 561c5ea5295005a6f1262b6c7b77028aa8bf6c4d Mon Sep 17 00:00:00 2001 From: Jonathan Bradley Date: Mon, 18 Sep 2023 09:31:57 -0400 Subject: checkpoint - first pass create texture pipelines --- CMakeLists.txt | 2 + assets/shaders/vert.vert | 24 +++-- src/entities.cpp | 257 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 273 insertions(+), 10 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index ce3be95..0c651c2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -93,6 +93,8 @@ file(MAKE_DIRECTORY ${SHADER_OUTPUT_DIR}) set(SHADERS ${SHADER_DIR}/present.vert ${SHADER_DIR}/present.frag + ${SHADER_DIR}/vert.vert + ${SHADER_DIR}/texture.frag ) foreach(SHADER IN LISTS SHADERS) diff --git a/assets/shaders/vert.vert b/assets/shaders/vert.vert index f3e7cf2..07044c8 100644 --- a/assets/shaders/vert.vert +++ b/assets/shaders/vert.vert @@ -7,17 +7,19 @@ layout(binding = 0) uniform UniformBufferObject { } ubo; // vertex -layout(location = 0) in vec4 inColor; -layout(location = 1) in vec3 inPosition; -layout(location = 2) in vec3 inNorm; -layout(location = 3) in vec2 inTexCoord; +// layout(location = 0) in vec4 inColor; +layout(location = 0) in vec3 inPosition; +layout(location = 1) in vec3 inNorm; +layout(location = 2) in vec2 inUV; // instance -layout(location = 4) in mat4 instPosRotScale; -layout(location = 8) in float textureIndex; +layout(location = 3) in vec3 instPos; +layout(location = 4) in vec3 instRot; +layout(location = 5) in vec3 instScale; +// layout(location = 6) in float textureIndex; // output -layout(location = 0) out vec3 fragColor; +layout(location = 0) out vec4 fragColor; layout(location = 1) out vec3 fragTexCoord; void main() { @@ -25,8 +27,10 @@ void main() { ubo.proj * ubo.view * ubo.model * - instPosRotScale * + vec4(instPos, 1.0) * + vec4(instRot, 1.0) * + vec4(instScale, 1.0) * vec4(inPosition, 1.0); - fragColor = inColor; - fragTexCoord = vec3(inTexCoord, textureIndex); + fragColor = vec4(0.0, 0.0, 0.0, 0.0); + fragTexCoord = vec3(inUV, 0); } 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 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(vertShaderAsset->ptr); + vkShaderModuleCreateInfo[1].codeSize = fragShaderAsset->size; + vkShaderModuleCreateInfo[1].pCode = reinterpret_cast(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]); -- cgit v1.2.3