moved texture pipelines handling to window.cpp - messy

1 files changed, 315 insertions, 2 deletions

diff --git a/src/window.cpp b/src/window.cpp
index 857e6e9..58dcdb1 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -81,8 +81,10 @@ UniformBufferObject UBO{
 	.proj = glm::mat4(1),
 };
 VkDeviceMemory uniformBufferMemory;
+
 // public
 VkBuffer UniformBuffers[MAX_FRAMES_IN_FLIGHT];
+ImplementedPipelines pkePipelines{};
 
 /*
  * ImGui
@@ -863,7 +865,7 @@ void CreateRenderPass() {
 	}
 }
 
-void CreateGraphicsPipeline() {
+void CreateGraphicsPipelines() {
 	AssetHandle vertShaderAsset = AM_Register("assets/shaders/present.vert.spv");
 	AssetHandle fragShaderAsset = AM_Register("assets/shaders/present.frag.spv");
 	auto vertShader = UploadShader(vertShaderAsset);
@@ -1094,6 +1096,305 @@ void CreateGraphicsPipeline() {
 	vkDestroyShaderModule(vkDevice, vertShader, vkAllocator);
 	AM_Destroy(fragShaderAsset);
 	AM_Destroy(vertShaderAsset);
+
+	/*
+	 * Texture & Debug pipelines
+	 */
+
+	// layouts
+	{
+		VkDescriptorSetLayoutBinding vkDescriptorSetLayoutBindings[2];
+		for (long i = 0; i < 2; ++i) {
+			vkDescriptorSetLayoutBindings[i].pImmutableSamplers = nullptr;
+		}
+		vkDescriptorSetLayoutBindings[0].binding = 0;
+		vkDescriptorSetLayoutBindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+		vkDescriptorSetLayoutBindings[0].descriptorCount = 1;
+		vkDescriptorSetLayoutBindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
+		vkDescriptorSetLayoutBindings[1].binding = 1;
+		vkDescriptorSetLayoutBindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+		vkDescriptorSetLayoutBindings[1].descriptorCount = 1;
+		vkDescriptorSetLayoutBindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+		VkDescriptorSetLayoutCreateInfo vkDescriptorSetLayoutCreateInfo {
+			.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+			.pNext = nullptr,
+			.flags = 0,
+			.bindingCount = 2,
+			.pBindings = vkDescriptorSetLayoutBindings,
+		};
+		vkCreateDescriptorSetLayout(vkDevice, &vkDescriptorSetLayoutCreateInfo, vkAllocator, &pkePipelines.vkDescriptorSetLayout_Texture);
+
+		VkPipelineLayoutCreateInfo vkPipelineLayoutCreateInfo {
+			.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
+			.pNext = nullptr,
+			.flags = 0,
+			.setLayoutCount = 1,
+			.pSetLayouts = &pkePipelines.vkDescriptorSetLayout_Texture,
+			.pushConstantRangeCount = 0,
+			.pPushConstantRanges = nullptr,
+		};
+		vkCreatePipelineLayout(vkDevice, &vkPipelineLayoutCreateInfo, vkAllocator, &pkePipelines.vkPipelineLayout_Texture);
+
+		VkSamplerCreateInfo vkSamplerCreateInfo;
+		vkSamplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+		vkSamplerCreateInfo.pNext = nullptr;
+		vkSamplerCreateInfo.flags = 0;
+		vkSamplerCreateInfo.magFilter = VK_FILTER_NEAREST;
+		vkSamplerCreateInfo.minFilter = VK_FILTER_NEAREST;
+		vkSamplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
+		vkSamplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+		vkSamplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+		vkSamplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+		vkSamplerCreateInfo.mipLodBias = 0.0f;
+		vkSamplerCreateInfo.anisotropyEnable = VK_TRUE;
+		vkSamplerCreateInfo.maxAnisotropy = vkPhysicalDeviceProperties.limits.maxSamplerAnisotropy;
+		vkSamplerCreateInfo.compareEnable = VK_FALSE;
+		vkSamplerCreateInfo.compareOp = VK_COMPARE_OP_ALWAYS;
+		vkSamplerCreateInfo.minLod = 0.0f;
+		// TODO MipMap
+		vkSamplerCreateInfo.maxLod = 1;
+		vkSamplerCreateInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
+		vkSamplerCreateInfo.unnormalizedCoordinates = VK_FALSE;
+		vkCreateSampler(vkDevice, &vkSamplerCreateInfo, vkAllocator, &pkePipelines.vkSampler_Texture);
+	}
+
+	// pipelines
+	{
+		const long vertexBindingCount = 4;
+		long index = 0;
+		VkVertexInputBindingDescription vertInputBD[vertexBindingCount];
+		// model vertex
+		vertInputBD[index].binding = index;
+		vertInputBD[index].stride = sizeof(glm::vec3);
+		vertInputBD[index].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+		index += 1;
+		// model normals
+		vertInputBD[index].binding = index;
+		vertInputBD[index].stride = sizeof(glm::vec3);
+		vertInputBD[index].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+		index += 1;
+		// model UV
+		vertInputBD[index].binding = index;
+		vertInputBD[index].stride = sizeof(glm::vec2);
+		vertInputBD[index].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+		index += 1;
+		// model index
+		// vertInputBD[index].binding = index;
+		// vertInputBD[index].stride = sizeof(uint16_t);
+		// vertInputBD[index].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+		// index += 1;
+		// instance
+		vertInputBD[index].binding = index;
+		vertInputBD[index].stride = sizeof(glm::mat4);
+		vertInputBD[index].inputRate = VK_VERTEX_INPUT_RATE_INSTANCE;
+
+		const long vertexAttrDescCount = 7;
+		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 = 0;
+		index += 1;
+
+		// model normals
+		vertAttrDesc[index].binding = 1;
+		vertAttrDesc[index].format = VK_FORMAT_R32G32B32_SFLOAT;
+		vertAttrDesc[index].offset = 0;
+		index += 1;
+
+		// model UV
+		vertAttrDesc[index].binding = 2;
+		vertAttrDesc[index].format = VK_FORMAT_R32G32_SFLOAT;
+		vertAttrDesc[index].offset = 0;
+		index += 1;
+
+		// instPosRotScale
+		for (long i = 0; i < 4; ++i) {
+			vertAttrDesc[index].binding = 3;
+			vertAttrDesc[index].format = VK_FORMAT_R32G32B32A32_SFLOAT;
+			vertAttrDesc[index].offset = sizeof(glm::vec4) * i;
+			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.cullMode = VK_CULL_MODE_NONE;
+		vkPipelineRasterizationStateCreateInfoLine.polygonMode = VK_POLYGON_MODE_LINE;
+
+		VkPipelineMultisampleStateCreateInfo vkPipelineMultisampleStateCreateInfo;
+		vkPipelineMultisampleStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+		vkPipelineMultisampleStateCreateInfo.pNext = nullptr;
+		vkPipelineMultisampleStateCreateInfo.flags = 0;
+		vkPipelineMultisampleStateCreateInfo.rasterizationSamples = renderSampleCount;
+		vkPipelineMultisampleStateCreateInfo.sampleShadingEnable = VK_FALSE;
+		vkPipelineMultisampleStateCreateInfo.minSampleShading = 0.0f;
+		vkPipelineMultisampleStateCreateInfo.pSampleMask = nullptr;
+		vkPipelineMultisampleStateCreateInfo.alphaToCoverageEnable = VK_FALSE;
+		vkPipelineMultisampleStateCreateInfo.alphaToOneEnable = VK_FALSE;
+
+		// TODO Transparency
+		VkPipelineColorBlendAttachmentState vkPipelineColorBlendAttachmentState[1];
+		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;
+
+		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 *textureVertShaderAsset = AM_Get(vertShaderAssetHandle);
+		const Asset *textureFragShaderAsset = AM_Get(textureFragShaderAssetHandle);
+		VkShaderModuleCreateInfo vkShaderModuleCreateInfo[2];
+		vkShaderModuleCreateInfo[0].codeSize = textureVertShaderAsset->size;
+		vkShaderModuleCreateInfo[0].pCode = reinterpret_cast<const uint32_t *>(textureVertShaderAsset->ptr);
+		vkShaderModuleCreateInfo[1].codeSize = textureFragShaderAsset->size;
+		vkShaderModuleCreateInfo[1].pCode = reinterpret_cast<const uint32_t *>(textureFragShaderAsset->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[i], 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 vkGraphicsPipelineCreateInfo[2];
+		for (long i = 0; i < 2; ++i) {
+			vkGraphicsPipelineCreateInfo[i].sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+			vkGraphicsPipelineCreateInfo[i].pNext = nullptr;
+			vkGraphicsPipelineCreateInfo[i].flags = {};
+			vkGraphicsPipelineCreateInfo[i].stageCount = 2;
+			vkGraphicsPipelineCreateInfo[i].pStages = vkPipelineShaderStageCreateInfo;
+			vkGraphicsPipelineCreateInfo[i].pVertexInputState = &vkPipelineVertexInputStateCreateInfo;
+			vkGraphicsPipelineCreateInfo[i].pInputAssemblyState = &vkPipelineInputAssemblyStateCreateInfo;
+			vkGraphicsPipelineCreateInfo[i].pTessellationState = nullptr;
+			vkGraphicsPipelineCreateInfo[i].pViewportState = &vkPipelineViewportStateCreateInfo;
+			vkGraphicsPipelineCreateInfo[i].pMultisampleState = &vkPipelineMultisampleStateCreateInfo;
+			vkGraphicsPipelineCreateInfo[i].pDepthStencilState = &vkPipelineDepthStencilStateCreateInfo;
+			vkGraphicsPipelineCreateInfo[i].pColorBlendState = &vkPipelineColorBlendStateCreateInfo;
+			vkGraphicsPipelineCreateInfo[i].pDynamicState = &vkPipelineDynamicStateCreateInfo;
+			vkGraphicsPipelineCreateInfo[i].layout = pkePipelines.vkPipelineLayout_Texture;
+			vkGraphicsPipelineCreateInfo[i].renderPass = renderRenderPass;
+			vkGraphicsPipelineCreateInfo[i].subpass = 0;
+			vkGraphicsPipelineCreateInfo[i].basePipelineHandle = VK_NULL_HANDLE;
+			vkGraphicsPipelineCreateInfo[i].basePipelineIndex = {};
+		}
+
+		vkGraphicsPipelineCreateInfo[0].pRasterizationState = &vkPipelineRasterizationStateCreateInfoFill;
+		vkGraphicsPipelineCreateInfo[1].pRasterizationState = &vkPipelineRasterizationStateCreateInfoLine;
+
+		vkCreateGraphicsPipelines(vkDevice, VK_NULL_HANDLE, 2, vkGraphicsPipelineCreateInfo, vkAllocator, pkePipelines.pipelines.arr);
+
+		for (long i = 0; i < 2; ++i) {
+			vkDestroyShaderModule(vkDevice, shaderModules[i], vkAllocator);
+		}
+
+		AM_Destroy(textureFragShaderAssetHandle);
+		AM_Destroy(vertShaderAssetHandle);
+	}
 }
 
 void CreateFramebuffers() {
@@ -1530,7 +1831,7 @@ void CreateWindow(PKEWindowProperties *wp) {
 	glfwSetFramebufferSizeCallback(window, FramebufferResizeCallback);
 	CreateSwapchain();
 	CreateRenderPass();
-	CreateGraphicsPipeline();
+	CreateGraphicsPipelines();
 	UpdatePresentDescriptorSets();
 	UpdateCameraProjection();
 	CreateFramebuffers();
@@ -1547,6 +1848,18 @@ void DestroyWindow() {
 	ImGui_ImplGlfw_Shutdown();
 	ImGui::DestroyContext();
 	DestroySwapchain();
+
+	if (pkePipelines.vkSampler_Texture != VK_NULL_HANDLE)
+		vkDestroySampler(vkDevice, pkePipelines.vkSampler_Texture, vkAllocator);
+	for (long i = 0; i < 2; ++i) {
+		if (pkePipelines.pipelines.arr[i] != VK_NULL_HANDLE)
+			vkDestroyPipeline(vkDevice, pkePipelines.pipelines.arr[i], vkAllocator);
+	}
+	if (pkePipelines.vkPipelineLayout_Texture != VK_NULL_HANDLE)
+		vkDestroyPipelineLayout(vkDevice, pkePipelines.vkPipelineLayout_Texture, vkAllocator);
+	if (pkePipelines.vkDescriptorSetLayout_Texture != VK_NULL_HANDLE)
+		vkDestroyDescriptorSetLayout(vkDevice, pkePipelines.vkDescriptorSetLayout_Texture, vkAllocator);
+
 	for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
 		vkDestroyBuffer(vkDevice, UniformBuffers[i], vkAllocator);
 		vkDestroySemaphore(vkDevice, presentImageAvailableSemaphores[i], vkAllocator);