diff options
| -rw-r--r-- | CMakeLists.txt | 2 | ||||
| -rw-r--r-- | src/static/cube.cpp | 49 | ||||
| -rw-r--r-- | src/static/cube.hpp | 16 | ||||
| -rw-r--r-- | src/window.cpp | 764 | ||||
| -rw-r--r-- | src/window.hpp | 13 |
5 files changed, 715 insertions, 129 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 1d7bbc3..31a6ce9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -35,6 +35,8 @@ set(PKE_SOURCE_FILES src/dynamic-array.cpp src/asset-manager.hpp src/asset-manager.cpp + src/static/cube.hpp + src/static/cube.cpp src/vendor/cgltf-include.hpp src/vendor/cgltf-include.cpp src/vendor/glm_include.hpp diff --git a/src/static/cube.cpp b/src/static/cube.cpp new file mode 100644 index 0000000..92c6274 --- /dev/null +++ b/src/static/cube.cpp @@ -0,0 +1,49 @@ + +#include "./cube.hpp" + +IntrinsicShapeCube pkeIntrinsicsCube { + .vert = { + {-1, -1, -1}, + {-1, -1, 1}, + {-1, 1, 1}, + {-1, 1, -1}, + {1, 1, 1}, + {1, 1, -1}, + {1, -1, -1}, + {1, -1, 1}, + }, + .norm = { + {-1, -1, -1}, + {-1, -1, 1}, + {-1, 1, 1}, + {-1, 1, -1}, + {1, 1, 1}, + {1, 1, -1}, + {1, -1, -1}, + {1, -1, 1}, + }, + .uv = { + {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, + }, + .index = { + 0, 1, 2, + 5, 0, 3, + 7, 0, 6, + 5, 6, 0, + 0, 2, 3, + 7, 1, 0, + 2, 1, 7, + 4, 6, 5, + 6, 4, 7, + 4, 5, 3, + 4, 3, 2, + 4, 2, 7, + }, +}; diff --git a/src/static/cube.hpp b/src/static/cube.hpp new file mode 100644 index 0000000..77ff439 --- /dev/null +++ b/src/static/cube.hpp @@ -0,0 +1,16 @@ +#ifndef PKE_STATIC_CUBE_HPP +#define PKE_STATIC_CUBE_HPP + +#include <glm/ext/vector_float3.hpp> +#include <glm/ext/vector_float2.hpp> + +struct IntrinsicShapeCube { + glm::vec3 vert[8]; + glm::vec3 norm[8]; + glm::vec2 uv[8]; + uint16_t index[36]; +}; + +extern IntrinsicShapeCube pkeIntrinsicsCube; + +#endif /* PKE_STATIC_CUBE_HPP */ diff --git a/src/window.cpp b/src/window.cpp index 58dcdb1..d124c21 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -6,6 +6,7 @@ #include "glm/ext/matrix_transform.hpp" #include "glm/gtc/matrix_transform.hpp" #include "game-settings.hpp" +#include "static/cube.hpp" #define NELEMS(x) (sizeof(x) / sizeof((x)[0])) @@ -84,6 +85,7 @@ VkDeviceMemory uniformBufferMemory; // public VkBuffer UniformBuffers[MAX_FRAMES_IN_FLIGHT]; +DebugHitbox pkeDebugHitbox{}; ImplementedPipelines pkePipelines{}; /* @@ -469,7 +471,7 @@ void InitVulkan() { // surface formats { - VkFormat acceptableDepthFormats[3] = { + const VkFormat acceptableDepthFormats[3] = { VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT, @@ -865,7 +867,7 @@ void CreateRenderPass() { } } -void CreateGraphicsPipelines() { +void CreatePresentPipeline() { AssetHandle vertShaderAsset = AM_Register("assets/shaders/present.vert.spv"); AssetHandle fragShaderAsset = AM_Register("assets/shaders/present.frag.spv"); auto vertShader = UploadShader(vertShaderAsset); @@ -1096,12 +1098,156 @@ void CreateGraphicsPipelines() { vkDestroyShaderModule(vkDevice, vertShader, vkAllocator); AM_Destroy(fragShaderAsset); AM_Destroy(vertShaderAsset); +} - /* - * Texture & Debug pipelines - */ +void CreateFramebuffers() { + assert(swapchainFramebuffers == nullptr || swapchainFramebuffers == CAFE_BABE(VkFramebuffer)); + assert(renderImageFramebuffers == nullptr || renderImageFramebuffers == CAFE_BABE(VkFramebuffer)); + swapchainFramebuffers = Pke_New<VkFramebuffer>(swapchainLength); + renderImageFramebuffers = Pke_New<VkFramebuffer>(swapchainLength); + + VkFramebufferCreateInfo framebufferInfo; + framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + framebufferInfo.pNext = nullptr; + framebufferInfo.flags = {}; + framebufferInfo.renderPass = presentRenderPass; + framebufferInfo.attachmentCount = 1; + framebufferInfo.pAttachments = nullptr; + framebufferInfo.width = extent.width; + framebufferInfo.height = extent.height; + framebufferInfo.layers = 1; + + for (long i = 0; i < swapchainLength; ++i) { + VkImageView attachments[] = { + swapchainImageViews[i] + }; + framebufferInfo.pAttachments = attachments; + auto result = vkCreateFramebuffer(vkDevice, &framebufferInfo, vkAllocator, &swapchainFramebuffers[i]); + if (result != VK_SUCCESS) { + throw "failed to create framebuffer"; + } + } + + framebufferInfo.attachmentCount = 3; + framebufferInfo.renderPass = renderRenderPass; + for (long i = 0; i < swapchainLength; ++i) { + VkImageView attachments[] = { + colorImageViews[i], + depthImageViews[i], + renderImageViews[i], + }; + framebufferInfo.pAttachments = attachments; + auto result = vkCreateFramebuffer(vkDevice, &framebufferInfo, vkAllocator, &renderImageFramebuffers[i]); + if (result != VK_SUCCESS) { + throw "failed to create framebuffer"; + } + } +} + +void CreateCommandPool() { + VkCommandPoolCreateInfo poolInfo; + poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + poolInfo.pNext = nullptr; + poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; + poolInfo.queueFamilyIndex = graphicsFamilyIndex; + + auto result = vkCreateCommandPool(vkDevice, &poolInfo, vkAllocator, &graphicsCommandPool); + if (result != VK_SUCCESS) { + throw "failed to create command pool"; + } + + poolInfo.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; + poolInfo.queueFamilyIndex = transferFamilyIndex; + result = vkCreateCommandPool(vkDevice, &poolInfo, vkAllocator, &transferCommandPool); + if (result != VK_SUCCESS) { + throw "failed to create transfer command pool"; + } +} + +void CreateCommandBuffer() { + VkCommandBufferAllocateInfo allocInfo; + allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.pNext = nullptr; + allocInfo.commandPool = graphicsCommandPool; + allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandBufferCount = MAX_FRAMES_IN_FLIGHT; + + auto result = vkAllocateCommandBuffers(vkDevice, &allocInfo, presentCommandBuffers); + if (result != VK_SUCCESS) { + throw "failed to allocate command buffer"; + } + + allocInfo.commandBufferCount = 1; + result = vkAllocateCommandBuffers(vkDevice, &allocInfo, &graphicsCommandBuffer); + if (result != VK_SUCCESS) { + throw "failed to allocate command buffer"; + } + + allocInfo.commandPool = transferCommandPool; + result = vkAllocateCommandBuffers(vkDevice, &allocInfo, &transferCommandBuffer); + if (result != VK_SUCCESS) { + throw "failed to allocate command buffer"; + } +} + +void CreateUniformBuffers() { + uint32_t queueFamilyIndexes[2] = {graphicsFamilyIndex, transferFamilyIndex}; + VkBufferCreateInfo vkBufferCreateInfo; + vkBufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; + vkBufferCreateInfo.pNext = nullptr; + vkBufferCreateInfo.flags = {}; + vkBufferCreateInfo.size = sizeof(UniformBufferObject); + vkBufferCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; + vkBufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + vkBufferCreateInfo.queueFamilyIndexCount = graphicsFamilyIndex == transferFamilyIndex ? 1 : 2; + vkBufferCreateInfo.pQueueFamilyIndices = queueFamilyIndexes; + + vkCreateBuffer(vkDevice, &vkBufferCreateInfo, vkAllocator, &UniformBuffers[0]); + + VkMemoryRequirements memReqs; + vkGetBufferMemoryRequirements(vkDevice, UniformBuffers[0], &memReqs); + + VkMemoryAllocateInfo vkMemoryAllocateInfo; + vkMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + vkMemoryAllocateInfo.pNext = nullptr; + vkMemoryAllocateInfo.allocationSize = memReqs.size * MAX_FRAMES_IN_FLIGHT; + vkMemoryAllocateInfo.memoryTypeIndex = FindMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); - // layouts + vkAllocateMemory(vkDevice, &vkMemoryAllocateInfo, vkAllocator, &uniformBufferMemory); + + vkDestroyBuffer(vkDevice, UniformBuffers[0], vkAllocator); + vkBufferCreateInfo.size = memReqs.size; + + for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) { + vkCreateBuffer(vkDevice, &vkBufferCreateInfo, vkAllocator, &UniformBuffers[i]); + vkBindBufferMemory(vkDevice, UniformBuffers[i], uniformBufferMemory, memReqs.size * i); + } +} + +void CreateSyncObjects() { + VkSemaphoreCreateInfo semaphoreInfo; + semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; + semaphoreInfo.pNext = nullptr; + semaphoreInfo.flags = {}; + + VkFenceCreateInfo fenceInfo; + fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + fenceInfo.pNext = nullptr; + fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT; + + for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) { + auto result1 = vkCreateSemaphore(vkDevice, &semaphoreInfo, vkAllocator, &presentImageAvailableSemaphores[i]); + auto result2 = vkCreateSemaphore(vkDevice, &semaphoreInfo, vkAllocator, &presentRenderFinishedSemaphores[i]); + auto result3 = vkCreateFence(vkDevice, &fenceInfo, vkAllocator, &presentInFlightFences[i]); + auto result = result1 == result2 && result2 == result3 && result3 == VK_SUCCESS; + if (!result) { + throw "failed to create sync objects"; + } + } +} + +void CreateGraphicsPipelines() { + // layouts & sampler { VkDescriptorSetLayoutBinding vkDescriptorSetLayoutBindings[2]; for (long i = 0; i < 2; ++i) { @@ -1310,6 +1456,10 @@ void CreateGraphicsPipelines() { vkPipelineColorBlendStateCreateInfo.blendConstants[2] = 0.0f; vkPipelineColorBlendStateCreateInfo.blendConstants[3] = 0.0f; + VkDynamicState dynamicStates[2] = { + VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_SCISSOR + }; VkPipelineDynamicStateCreateInfo vkPipelineDynamicStateCreateInfo; vkPipelineDynamicStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; vkPipelineDynamicStateCreateInfo.pNext = nullptr; @@ -1395,152 +1545,490 @@ void CreateGraphicsPipelines() { AM_Destroy(textureFragShaderAssetHandle); AM_Destroy(vertShaderAssetHandle); } -} -void CreateFramebuffers() { - assert(swapchainFramebuffers == nullptr || swapchainFramebuffers == CAFE_BABE(VkFramebuffer)); - assert(renderImageFramebuffers == nullptr || renderImageFramebuffers == CAFE_BABE(VkFramebuffer)); - swapchainFramebuffers = Pke_New<VkFramebuffer>(swapchainLength); - renderImageFramebuffers = Pke_New<VkFramebuffer>(swapchainLength); - - VkFramebufferCreateInfo framebufferInfo; - framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; - framebufferInfo.pNext = nullptr; - framebufferInfo.flags = {}; - framebufferInfo.renderPass = presentRenderPass; - framebufferInfo.attachmentCount = 1; - framebufferInfo.pAttachments = nullptr; - framebufferInfo.width = extent.width; - framebufferInfo.height = extent.height; - framebufferInfo.layers = 1; - - for (long i = 0; i < swapchainLength; ++i) { - VkImageView attachments[] = { - swapchainImageViews[i] - }; - framebufferInfo.pAttachments = attachments; - auto result = vkCreateFramebuffer(vkDevice, &framebufferInfo, vkAllocator, &swapchainFramebuffers[i]); - if (result != VK_SUCCESS) { - throw "failed to create framebuffer"; + // debug texture + { + VkImageCreateInfo dbgTextureCI; + dbgTextureCI.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; + dbgTextureCI.pNext = nullptr; + dbgTextureCI.flags = 0; + dbgTextureCI.imageType = VK_IMAGE_TYPE_2D; + dbgTextureCI.format = VK_FORMAT_R8G8B8A8_SRGB; + dbgTextureCI.extent = VkExtent3D { .width = 2, .height = 2, .depth = 1, }; + dbgTextureCI.mipLevels = 1; + dbgTextureCI.arrayLayers = 1; + dbgTextureCI.samples = VK_SAMPLE_COUNT_1_BIT; + dbgTextureCI.tiling = VK_IMAGE_TILING_OPTIMAL; + dbgTextureCI.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT; + dbgTextureCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + dbgTextureCI.queueFamilyIndexCount = 0; + dbgTextureCI.pQueueFamilyIndices = nullptr; + dbgTextureCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + + vkCreateImage(vkDevice, &dbgTextureCI, vkAllocator, &pkeDebugHitbox.vkImage); + + VkMemoryRequirements imageMemReqs; + vkGetImageMemoryRequirements(vkDevice, pkeDebugHitbox.vkImage, &imageMemReqs); + VkMemoryAllocateInfo imageAllocInfo; + imageAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + imageAllocInfo.pNext = nullptr; + imageAllocInfo.allocationSize = imageMemReqs.size; + imageAllocInfo.memoryTypeIndex = FindMemoryTypeIndex(imageMemReqs.memoryTypeBits, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT); + if (imageAllocInfo.memoryTypeIndex == 0) { + imageAllocInfo.memoryTypeIndex = FindMemoryTypeIndex(imageMemReqs.memoryTypeBits, 0); } - } + vkAllocateMemory(vkDevice, &imageAllocInfo, vkAllocator, &pkeDebugHitbox.textureMemory); + vkBindImageMemory(vkDevice, pkeDebugHitbox.vkImage, pkeDebugHitbox.textureMemory, 0); + + VkImageViewCreateInfo dbgImageViewCI; + dbgImageViewCI.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + dbgImageViewCI.pNext = nullptr; + dbgImageViewCI.flags = 0; + dbgImageViewCI.image = pkeDebugHitbox.vkImage; + dbgImageViewCI.viewType = VK_IMAGE_VIEW_TYPE_2D; + dbgImageViewCI.format = VK_FORMAT_R8G8B8A8_SRGB; + dbgImageViewCI.components = VkComponentMapping { + .r = VK_COMPONENT_SWIZZLE_IDENTITY, + .g = VK_COMPONENT_SWIZZLE_IDENTITY, + .b = VK_COMPONENT_SWIZZLE_IDENTITY, + .a = VK_COMPONENT_SWIZZLE_IDENTITY, + }; + dbgImageViewCI.subresourceRange = VkImageSubresourceRange { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = 0, + .levelCount = 1, + .baseArrayLayer = 0, + .layerCount = 1, + }; - framebufferInfo.attachmentCount = 3; - framebufferInfo.renderPass = renderRenderPass; - for (long i = 0; i < swapchainLength; ++i) { - VkImageView attachments[] = { - colorImageViews[i], - depthImageViews[i], - renderImageViews[i], + vkCreateImageView(vkDevice, &dbgImageViewCI, vkAllocator, &pkeDebugHitbox.vkImageView); + + /* + * 0: #373b3e (55,59,62) // dark grey (desaturated light blue) + * 1: #bec8d1 (190,200,209) // light grey (desaturated light blue) + * 2: #86cecb (134,206,203) // light cyan + * 3: #137a7f (19,122,127) // dark cyan + * 4: #e12885 (225,40,133) // magenta + */ + // transition image layout and copy to buffer + const uint8_t pixels[] = { + 0x37, 0x3b, 0x3e, 0xff, // 0 + 0x86, 0xce, 0xcb, 0xff, // 2 + 0x13, 0x7a, 0x7f, 0xff, // 3 + 0xe1, 0x28, 0x85, 0xff, // 4 }; - framebufferInfo.pAttachments = attachments; - auto result = vkCreateFramebuffer(vkDevice, &framebufferInfo, vkAllocator, &renderImageFramebuffers[i]); - if (result != VK_SUCCESS) { - throw "failed to create framebuffer"; + VkBuffer transferImageBuffer; + VkDeviceMemory transferImageMemory; + void *deviceData; + BeginTransferBuffer(4 * 4, transferImageBuffer, transferImageMemory, deviceData); + memcpy(deviceData, pixels, 4 * 4); + { + VkImageMemoryBarrier vkImageMemoryBarrier; + vkImageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + vkImageMemoryBarrier.pNext = nullptr; + vkImageMemoryBarrier.srcAccessMask = {}; + vkImageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + vkImageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; + vkImageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + vkImageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + vkImageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + vkImageMemoryBarrier.image = pkeDebugHitbox.vkImage; + vkImageMemoryBarrier.subresourceRange = VkImageSubresourceRange { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = 0, + .levelCount = 1, + .baseArrayLayer = 0, + .layerCount = 1, + }; + + VkCommandBufferBeginInfo vkCommandBufferBeginInfo; + vkCommandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + vkCommandBufferBeginInfo.pNext = nullptr; + vkCommandBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + vkCommandBufferBeginInfo.pInheritanceInfo = nullptr; + + vkBeginCommandBuffer(transferCommandBuffer, &vkCommandBufferBeginInfo); + + vkCmdPipelineBarrier(transferCommandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &vkImageMemoryBarrier); + + VkBufferImageCopy vkBufferImageCopy; + vkBufferImageCopy.bufferOffset = 0; + vkBufferImageCopy.bufferRowLength = 2; + vkBufferImageCopy.bufferImageHeight = 2; + vkBufferImageCopy.imageSubresource = VkImageSubresourceLayers { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .mipLevel = 0, + .baseArrayLayer = 0, + .layerCount = 1, + }; + vkBufferImageCopy.imageOffset = VkOffset3D { + .x = 0, + .y = 0, + .z = 0, + }; + vkBufferImageCopy.imageExtent = VkExtent3D { + .width = 2, + .height = 2, + .depth = 1, + }; + vkCmdCopyBufferToImage(transferCommandBuffer, transferImageBuffer, pkeDebugHitbox.vkImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &vkBufferImageCopy); + + vkEndCommandBuffer(transferCommandBuffer); + + VkSubmitInfo submitInfo; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.pNext = nullptr; + submitInfo.waitSemaphoreCount = 0; + submitInfo.pWaitSemaphores = nullptr; + submitInfo.pWaitDstStageMask = nullptr; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &transferCommandBuffer; + submitInfo.signalSemaphoreCount = 0; + submitInfo.pSignalSemaphores = nullptr; + vkQueueSubmit(transferQueue, 1, &submitInfo, nullptr); + vkQueueWaitIdle(transferQueue); + vkResetCommandBuffer(transferCommandBuffer, 0); + } + EndTransferBuffer(transferImageBuffer, transferImageMemory); + { + VkImageMemoryBarrier vkImageMemoryBarrier; + vkImageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + vkImageMemoryBarrier.pNext = nullptr; + vkImageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + vkImageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; + vkImageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + vkImageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + vkImageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + vkImageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + vkImageMemoryBarrier.image = pkeDebugHitbox.vkImage; + vkImageMemoryBarrier.subresourceRange = VkImageSubresourceRange { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = 0, + .levelCount = 1, + .baseArrayLayer = 0, + .layerCount = 1, + }; + + VkCommandBufferBeginInfo vkCommandBufferBeginInfo; + vkCommandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + vkCommandBufferBeginInfo.pNext = nullptr; + vkCommandBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + vkCommandBufferBeginInfo.pInheritanceInfo = nullptr; + + vkBeginCommandBuffer(graphicsCommandBuffer, &vkCommandBufferBeginInfo); + + vkCmdPipelineBarrier(graphicsCommandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &vkImageMemoryBarrier); + + vkEndCommandBuffer(graphicsCommandBuffer); + + VkSubmitInfo submitInfo; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.pNext = nullptr; + submitInfo.waitSemaphoreCount = 0; + submitInfo.pWaitSemaphores = nullptr; + submitInfo.pWaitDstStageMask = nullptr; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &graphicsCommandBuffer; + submitInfo.signalSemaphoreCount = 0; + submitInfo.pSignalSemaphores = nullptr; + vkQueueSubmit(graphicsQueue, 1, &submitInfo, nullptr); + vkQueueWaitIdle(graphicsQueue); } } -} -void CreateCommandPool() { - VkCommandPoolCreateInfo poolInfo; - poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; - poolInfo.pNext = nullptr; - poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; - poolInfo.queueFamilyIndex = graphicsFamilyIndex; + // debug model + { - auto result = vkCreateCommandPool(vkDevice, &poolInfo, vkAllocator, &graphicsCommandPool); - if (result != VK_SUCCESS) { - throw "failed to create command pool"; - } + // ((sizeof(glm::vec3) + sizeof(glm::vec3) + sizeof(glm::vec2)) * 8) + // + (sizeof(uint16_t) * 36); + long index = 0; + VkMemoryRequirements vkMemoryRequirements[4]; + VkBufferCreateInfo dbgModelBufferCI{}; + dbgModelBufferCI.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; + dbgModelBufferCI.pNext = nullptr; + dbgModelBufferCI.flags = 0; + dbgModelBufferCI.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; + dbgModelBufferCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + dbgModelBufferCI.queueFamilyIndexCount = 1; + dbgModelBufferCI.pQueueFamilyIndices = &graphicsFamilyIndex; + + // vertex + dbgModelBufferCI.size = sizeof(glm::vec3) * 8; + vkCreateBuffer(vkDevice, &dbgModelBufferCI, vkAllocator, &pkeDebugHitbox.vertexBuffer); + vkGetBufferMemoryRequirements(vkDevice, pkeDebugHitbox.vertexBuffer, &vkMemoryRequirements[index]); + index++; + + // normals + dbgModelBufferCI.size = sizeof(glm::vec3) * 8; + vkCreateBuffer(vkDevice, &dbgModelBufferCI, vkAllocator, &pkeDebugHitbox.normalsBuffer); + vkGetBufferMemoryRequirements(vkDevice, pkeDebugHitbox.normalsBuffer, &vkMemoryRequirements[index]); + index++; + + // uv + dbgModelBufferCI.size = sizeof(glm::vec2) * 8; + vkCreateBuffer(vkDevice, &dbgModelBufferCI, vkAllocator, &pkeDebugHitbox.uvBuffer); + vkGetBufferMemoryRequirements(vkDevice, pkeDebugHitbox.uvBuffer, &vkMemoryRequirements[index]); + index++; + + // index + dbgModelBufferCI.size = sizeof(uint16_t) * 36; + dbgModelBufferCI.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT; + vkCreateBuffer(vkDevice, &dbgModelBufferCI, vkAllocator, &pkeDebugHitbox.indexBuffer); + vkGetBufferMemoryRequirements(vkDevice, pkeDebugHitbox.indexBuffer, &vkMemoryRequirements[index]); + // index++; + + VkMemoryRequirements combinedMemReqs{}; + combinedMemReqs.alignment = vkMemoryRequirements[0].alignment; + combinedMemReqs.memoryTypeBits = 0; + combinedMemReqs.size = 0; + for (long i = 1; i < 4; ++i) { + if (combinedMemReqs.alignment == vkMemoryRequirements[i].alignment) { + continue; + } + int larger, smaller; + if (combinedMemReqs.alignment > vkMemoryRequirements[i].alignment) { + larger = combinedMemReqs.alignment; + smaller = vkMemoryRequirements[i].alignment; + } else { + larger = vkMemoryRequirements[i].alignment; + smaller = combinedMemReqs.alignment; + } + if (larger % smaller == 0) { + combinedMemReqs.alignment = larger; + continue; + } + int combined = larger * smaller; + while ((combined / 2) % 2 == 0 && (combined / 2) % larger == 0) { + combined /= 2; + } + combinedMemReqs.alignment = combined; + } + for (long i = 0; i < 4; ++i) { + uint32_t alignmentPadding = vkMemoryRequirements[i].size % combinedMemReqs.alignment; + combinedMemReqs.size += vkMemoryRequirements[i].size + (alignmentPadding == 0 ? 0 : combinedMemReqs.alignment - alignmentPadding); + combinedMemReqs.memoryTypeBits |= vkMemoryRequirements[i].memoryTypeBits; + } - poolInfo.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; - poolInfo.queueFamilyIndex = transferFamilyIndex; - result = vkCreateCommandPool(vkDevice, &poolInfo, vkAllocator, &transferCommandPool); - if (result != VK_SUCCESS) { - throw "failed to create transfer command pool"; + VkMemoryAllocateInfo vkMemoryAllocateInfo; + vkMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + vkMemoryAllocateInfo.pNext = nullptr; + vkMemoryAllocateInfo.allocationSize = combinedMemReqs.size; + vkMemoryAllocateInfo.memoryTypeIndex = FindMemoryTypeIndex(combinedMemReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + vkAllocateMemory(vkDevice, &vkMemoryAllocateInfo, vkAllocator, &pkeDebugHitbox.vertBufferMemory); + + vkDestroyBuffer(vkDevice, pkeDebugHitbox.indexBuffer, vkAllocator); + vkDestroyBuffer(vkDevice, pkeDebugHitbox.uvBuffer, vkAllocator); + vkDestroyBuffer(vkDevice, pkeDebugHitbox.normalsBuffer, vkAllocator); + vkDestroyBuffer(vkDevice, pkeDebugHitbox.vertexBuffer, vkAllocator); + + // bind buffers + uint32_t runningOffset = 0; + uint32_t alignmentPadding; + + // vertex + uint32_t offsetVert = runningOffset; + uint32_t sizeVert = sizeof(glm::vec3) * 8; + alignmentPadding = sizeVert % combinedMemReqs.alignment; + alignmentPadding = alignmentPadding == 0 ? 0 : combinedMemReqs.alignment - alignmentPadding; + sizeVert += alignmentPadding; + dbgModelBufferCI.size = sizeVert; + dbgModelBufferCI.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; + vkCreateBuffer(vkDevice, &dbgModelBufferCI, vkAllocator, &pkeDebugHitbox.vertexBuffer); + vkBindBufferMemory(vkDevice, pkeDebugHitbox.vertexBuffer, pkeDebugHitbox.vertBufferMemory, offsetVert); + runningOffset += sizeVert; + + // norm + uint32_t offsetNorm = runningOffset; + uint32_t sizeNorm = sizeof(glm::vec3) * 8; + alignmentPadding = sizeNorm % combinedMemReqs.alignment; + alignmentPadding = alignmentPadding == 0 ? 0 : combinedMemReqs.alignment - alignmentPadding; + sizeNorm += alignmentPadding; + dbgModelBufferCI.size = sizeNorm; + vkCreateBuffer(vkDevice, &dbgModelBufferCI, vkAllocator, &pkeDebugHitbox.normalsBuffer); + vkBindBufferMemory(vkDevice, pkeDebugHitbox.normalsBuffer, pkeDebugHitbox.vertBufferMemory, offsetNorm); + runningOffset += sizeNorm; + + // uv + uint32_t offsetUV = runningOffset; + uint32_t sizeUV = sizeof(glm::vec2) * 8; + alignmentPadding = sizeUV % combinedMemReqs.alignment; + alignmentPadding = alignmentPadding == 0 ? 0 : combinedMemReqs.alignment - alignmentPadding; + sizeUV += alignmentPadding; + dbgModelBufferCI.size = sizeUV; + vkCreateBuffer(vkDevice, &dbgModelBufferCI, vkAllocator, &pkeDebugHitbox.uvBuffer); + vkBindBufferMemory(vkDevice, pkeDebugHitbox.uvBuffer , pkeDebugHitbox.vertBufferMemory, offsetUV); + runningOffset += sizeUV; + + // index + uint32_t offsetIndex = runningOffset; + uint32_t sizeIndex = sizeof(uint16_t) * 36; + alignmentPadding = sizeIndex % combinedMemReqs.alignment; + alignmentPadding = alignmentPadding == 0 ? 0 : combinedMemReqs.alignment - alignmentPadding; + sizeIndex += alignmentPadding; + dbgModelBufferCI.size = sizeIndex; + dbgModelBufferCI.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT; + vkCreateBuffer(vkDevice, &dbgModelBufferCI, vkAllocator, &pkeDebugHitbox.indexBuffer); + vkBindBufferMemory(vkDevice, pkeDebugHitbox.indexBuffer, pkeDebugHitbox.vertBufferMemory, offsetIndex); + runningOffset += sizeIndex; + + assert(runningOffset == combinedMemReqs.size); + + // create transfer items && transfer + { + VkDeviceMemory transferDeviceMemory; + VkBuffer transferBuffer; + void *data; + BeginTransferBuffer(combinedMemReqs.size, transferBuffer, transferDeviceMemory, data); + memset(data, '\0', combinedMemReqs.size); + + char *dstPtr = nullptr; + char *srcPtr = nullptr; + + dstPtr = static_cast<char *>(data) + offsetVert; + srcPtr = reinterpret_cast<char *>(pkeIntrinsicsCube.vert); + memcpy(dstPtr, srcPtr, sizeVert); + + dstPtr = static_cast<char *>(data) + offsetNorm; + srcPtr = reinterpret_cast<char *>(pkeIntrinsicsCube.norm); + memcpy(dstPtr, srcPtr, sizeNorm); + + dstPtr = static_cast<char *>(data) + offsetUV; + srcPtr = reinterpret_cast<char *>(pkeIntrinsicsCube.uv); + memcpy(dstPtr, srcPtr, sizeUV); + + dstPtr = static_cast<char *>(data) + offsetIndex; + srcPtr = reinterpret_cast<char *>(pkeIntrinsicsCube.index); + memcpy(dstPtr, srcPtr, sizeIndex); + + + VkCommandBufferBeginInfo vkCommandBufferBeginInfo; + vkCommandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + vkCommandBufferBeginInfo.pNext = nullptr; + // TODO consider single-use? + vkCommandBufferBeginInfo.flags = 0; + vkCommandBufferBeginInfo.pInheritanceInfo = nullptr; + vkBeginCommandBuffer(transferCommandBuffer, &vkCommandBufferBeginInfo); + VkBufferCopy bufferCopys[4]; + for (long i = 0; i < 4; ++i) { + bufferCopys[i].dstOffset = 0; + } + index = 0; + bufferCopys[index].srcOffset = offsetVert; + bufferCopys[index].size = sizeVert; + vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, pkeDebugHitbox.vertexBuffer, 1, &bufferCopys[index]); + index+=1; + + bufferCopys[index].srcOffset = offsetNorm; + bufferCopys[index].size = sizeNorm; + vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, pkeDebugHitbox.normalsBuffer, 1, &bufferCopys[index]); + index+=1; + + bufferCopys[index].srcOffset = offsetUV; + bufferCopys[index].size = sizeUV; + vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, pkeDebugHitbox.uvBuffer, 1, &bufferCopys[index]); + index+=1; + + bufferCopys[index].srcOffset = offsetIndex; + bufferCopys[index].size = sizeIndex; + vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, pkeDebugHitbox.indexBuffer, 1, &bufferCopys[index]); + // index+=1; + + vkEndCommandBuffer(transferCommandBuffer); + + VkSubmitInfo submitInfo; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.pNext = nullptr; + submitInfo.waitSemaphoreCount = 0; + submitInfo.pWaitSemaphores = nullptr; + submitInfo.pWaitDstStageMask = nullptr; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &transferCommandBuffer; + submitInfo.signalSemaphoreCount = 0; + submitInfo.pSignalSemaphores = nullptr; + vkQueueSubmit(transferQueue, 1, &submitInfo, nullptr); + vkQueueWaitIdle(transferQueue); + + EndTransferBuffer(transferBuffer, transferDeviceMemory); + } } } -void CreateCommandBuffer() { - VkCommandBufferAllocateInfo allocInfo; - allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; - allocInfo.pNext = nullptr; - allocInfo.commandPool = graphicsCommandPool; - allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; - allocInfo.commandBufferCount = MAX_FRAMES_IN_FLIGHT; - - auto result = vkAllocateCommandBuffers(vkDevice, &allocInfo, presentCommandBuffers); - if (result != VK_SUCCESS) { - throw "failed to allocate command buffer"; +void UpdateDebugGraphicsPipeline() { + // descriptor pool & sets + VkDescriptorPoolSize descriptorPoolSizes[2]; + descriptorPoolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + descriptorPoolSizes[0].descriptorCount = MAX_FRAMES_IN_FLIGHT; + descriptorPoolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + descriptorPoolSizes[1].descriptorCount = MAX_FRAMES_IN_FLIGHT; + + VkDescriptorPoolCreateInfo vkDescriptorPoolCreateInfo; + vkDescriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + vkDescriptorPoolCreateInfo.pNext = nullptr; + vkDescriptorPoolCreateInfo.flags = 0; + vkDescriptorPoolCreateInfo.maxSets = MAX_FRAMES_IN_FLIGHT; + vkDescriptorPoolCreateInfo.poolSizeCount = (uint32_t)2; + vkDescriptorPoolCreateInfo.pPoolSizes = descriptorPoolSizes; + + // consider making me a global pool + auto vkResult = vkCreateDescriptorPool(vkDevice, &vkDescriptorPoolCreateInfo, vkAllocator, &pkeDebugHitbox.vkDescriptorPool); + assert(vkResult == VK_SUCCESS); + + VkDescriptorSetLayout descriptorSets[MAX_FRAMES_IN_FLIGHT]; + for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) { + descriptorSets[i] = pkePipelines.vkDescriptorSetLayout_Texture; } - - allocInfo.commandBufferCount = 1; - result = vkAllocateCommandBuffers(vkDevice, &allocInfo, &graphicsCommandBuffer); - if (result != VK_SUCCESS) { - throw "failed to allocate command buffer"; + VkDescriptorSetAllocateInfo vkDescriptorSetAllocateInfo; + vkDescriptorSetAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + vkDescriptorSetAllocateInfo.pNext = nullptr; + vkDescriptorSetAllocateInfo.descriptorPool = pkeDebugHitbox.vkDescriptorPool; + vkDescriptorSetAllocateInfo.descriptorSetCount = MAX_FRAMES_IN_FLIGHT; + vkDescriptorSetAllocateInfo.pSetLayouts = descriptorSets; + + pkeDebugHitbox.vkDescriptorSets = Pke_New<VkDescriptorSet>(MAX_FRAMES_IN_FLIGHT); + for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) { + pkeDebugHitbox.vkDescriptorSets[i] = VkDescriptorSet{}; } + vkResult = vkAllocateDescriptorSets(vkDevice, &vkDescriptorSetAllocateInfo, pkeDebugHitbox.vkDescriptorSets); + assert(vkResult == VK_SUCCESS); - allocInfo.commandPool = transferCommandPool; - result = vkAllocateCommandBuffers(vkDevice, &allocInfo, &transferCommandBuffer); - if (result != VK_SUCCESS) { - throw "failed to allocate command buffer"; + VkWriteDescriptorSet writeDescriptorSets[2 * MAX_FRAMES_IN_FLIGHT]; + for (long i = 0; i < 2 * MAX_FRAMES_IN_FLIGHT; ++i) { + writeDescriptorSets[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + writeDescriptorSets[i].pNext = nullptr; + writeDescriptorSets[i].dstSet = nullptr; + writeDescriptorSets[i].dstBinding = i % 2; + writeDescriptorSets[i].dstArrayElement = 0; + writeDescriptorSets[i].descriptorCount = 1; + writeDescriptorSets[i].descriptorType = (i % 2) == 0 + ? VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER : VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + writeDescriptorSets[i].pImageInfo = nullptr; + writeDescriptorSets[i].pBufferInfo = nullptr; + writeDescriptorSets[i].pTexelBufferView = nullptr; } -} - -void CreateUniformBuffers() { - uint32_t queueFamilyIndexes[2] = {graphicsFamilyIndex, transferFamilyIndex}; - VkBufferCreateInfo vkBufferCreateInfo; - vkBufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; - vkBufferCreateInfo.pNext = nullptr; - vkBufferCreateInfo.flags = {}; - vkBufferCreateInfo.size = sizeof(UniformBufferObject); - vkBufferCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; - vkBufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; - vkBufferCreateInfo.queueFamilyIndexCount = graphicsFamilyIndex == transferFamilyIndex ? 1 : 2; - vkBufferCreateInfo.pQueueFamilyIndices = queueFamilyIndexes; - - vkCreateBuffer(vkDevice, &vkBufferCreateInfo, vkAllocator, &UniformBuffers[0]); - - VkMemoryRequirements memReqs; - vkGetBufferMemoryRequirements(vkDevice, UniformBuffers[0], &memReqs); - VkMemoryAllocateInfo vkMemoryAllocateInfo; - vkMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; - vkMemoryAllocateInfo.pNext = nullptr; - vkMemoryAllocateInfo.allocationSize = memReqs.size * MAX_FRAMES_IN_FLIGHT; - vkMemoryAllocateInfo.memoryTypeIndex = FindMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + VkDescriptorImageInfo textureDescriptorInfo; + textureDescriptorInfo.sampler = pkePipelines.vkSampler_Texture; + textureDescriptorInfo.imageView = pkeDebugHitbox.vkImageView; + textureDescriptorInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - vkAllocateMemory(vkDevice, &vkMemoryAllocateInfo, vkAllocator, &uniformBufferMemory); - - vkDestroyBuffer(vkDevice, UniformBuffers[0], vkAllocator); - vkBufferCreateInfo.size = memReqs.size; + VkDescriptorBufferInfo vkDescriptorBufferInfo[MAX_FRAMES_IN_FLIGHT]; for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) { - vkCreateBuffer(vkDevice, &vkBufferCreateInfo, vkAllocator, &UniformBuffers[i]); - vkBindBufferMemory(vkDevice, UniformBuffers[i], uniformBufferMemory, memReqs.size * i); - } -} + vkDescriptorBufferInfo[i].buffer = UniformBuffers[i]; + vkDescriptorBufferInfo[i].offset = 0; + vkDescriptorBufferInfo[i].range = sizeof(UniformBufferObject); -void CreateSyncObjects() { - VkSemaphoreCreateInfo semaphoreInfo; - semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; - semaphoreInfo.pNext = nullptr; - semaphoreInfo.flags = {}; + long uboIndex = i * 2; + long samplerIndex = uboIndex + 1; - VkFenceCreateInfo fenceInfo; - fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; - fenceInfo.pNext = nullptr; - fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT; + writeDescriptorSets[uboIndex].pBufferInfo = &vkDescriptorBufferInfo[i]; + writeDescriptorSets[uboIndex].dstSet = pkeDebugHitbox.vkDescriptorSets[i]; - for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) { - auto result1 = vkCreateSemaphore(vkDevice, &semaphoreInfo, vkAllocator, &presentImageAvailableSemaphores[i]); - auto result2 = vkCreateSemaphore(vkDevice, &semaphoreInfo, vkAllocator, &presentRenderFinishedSemaphores[i]); - auto result3 = vkCreateFence(vkDevice, &fenceInfo, vkAllocator, &presentInFlightFences[i]); - auto result = result1 == result2 && result2 == result3 && result3 == VK_SUCCESS; - if (!result) { - throw "failed to create sync objects"; - } + writeDescriptorSets[samplerIndex].pImageInfo = &textureDescriptorInfo; + writeDescriptorSets[samplerIndex].dstSet = pkeDebugHitbox.vkDescriptorSets[i]; } + + vkUpdateDescriptorSets(vkDevice, 2 * MAX_FRAMES_IN_FLIGHT, writeDescriptorSets, 0, nullptr); } void CreateImGui() { @@ -1700,6 +2188,9 @@ void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) { vkCmdBindVertexBuffers(commandBuffer, binder->instanceFirstBinding, binder->instanceBindingCount, &binder->instanceBuffer, &binder->instanceOffsets); vkCmdDrawIndexed(commandBuffer, binder->indexCount, binder->instanceCounter, 0, 0, 0); + + if (pkeSettings.isRenderingDebug) { + } } } @@ -1831,7 +2322,7 @@ void CreateWindow(PKEWindowProperties *wp) { glfwSetFramebufferSizeCallback(window, FramebufferResizeCallback); CreateSwapchain(); CreateRenderPass(); - CreateGraphicsPipelines(); + CreatePresentPipeline(); UpdatePresentDescriptorSets(); UpdateCameraProjection(); CreateFramebuffers(); @@ -1839,6 +2330,8 @@ void CreateWindow(PKEWindowProperties *wp) { CreateCommandBuffer(); CreateUniformBuffers(); CreateSyncObjects(); + CreateGraphicsPipelines(); + UpdateDebugGraphicsPipeline(); CreateImGui(); } @@ -1849,6 +2342,19 @@ void DestroyWindow() { ImGui::DestroyContext(); DestroySwapchain(); + vkDestroyDescriptorPool(vkDevice, pkeDebugHitbox.vkDescriptorPool, vkAllocator); + Pke_Delete<VkDescriptorSet>(pkeDebugHitbox.vkDescriptorSets, MAX_FRAMES_IN_FLIGHT); + + vkDestroyBuffer(vkDevice, pkeDebugHitbox.indexBuffer, vkAllocator); + vkDestroyBuffer(vkDevice, pkeDebugHitbox.uvBuffer, vkAllocator); + vkDestroyBuffer(vkDevice, pkeDebugHitbox.normalsBuffer, vkAllocator); + vkDestroyBuffer(vkDevice, pkeDebugHitbox.vertexBuffer, vkAllocator); + vkFreeMemory(vkDevice, pkeDebugHitbox.vertBufferMemory, vkAllocator); + + vkDestroyImageView(vkDevice, pkeDebugHitbox.vkImageView, vkAllocator); + vkDestroyImage(vkDevice, pkeDebugHitbox.vkImage, vkAllocator); + vkFreeMemory(vkDevice, pkeDebugHitbox.textureMemory, vkAllocator); + if (pkePipelines.vkSampler_Texture != VK_NULL_HANDLE) vkDestroySampler(vkDevice, pkePipelines.vkSampler_Texture, vkAllocator); for (long i = 0; i < 2; ++i) { diff --git a/src/window.hpp b/src/window.hpp index 0ab3910..91f9929 100644 --- a/src/window.hpp +++ b/src/window.hpp @@ -54,6 +54,19 @@ struct UniformBufferObject { extern UniformBufferObject UBO; extern VkBuffer UniformBuffers[MAX_FRAMES_IN_FLIGHT]; +struct DebugHitbox { + VkImage vkImage = VK_NULL_HANDLE; + VkImageView vkImageView = VK_NULL_HANDLE; + VkDeviceMemory textureMemory = VK_NULL_HANDLE; + VkDeviceMemory vertBufferMemory = VK_NULL_HANDLE; + VkBuffer vertexBuffer; + VkBuffer normalsBuffer; + VkBuffer uvBuffer; + VkBuffer indexBuffer; + VkDescriptorPool vkDescriptorPool; + VkDescriptorSet *vkDescriptorSets = nullptr; +}; +extern DebugHitbox pkeDebugHitbox; struct ImplementedPipelines { VkDescriptorSetLayout vkDescriptorSetLayout_Texture = VK_NULL_HANDLE; VkPipelineLayout vkPipelineLayout_Texture = VK_NULL_HANDLE; |