pke: remove MAX_FRAMES_IN_FLIGHT

1 files changed, 79 insertions, 52 deletions

diff --git a/src/window.cpp b/src/window.cpp
index 57e773f..19f2695 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -87,7 +87,7 @@ VkRenderPass renderRenderPass;
 VkRenderPass d2OverlayRenderPass;
 VkDescriptorSetLayout vkDescriptorSetLayout;
 VkDescriptorPool presentDescriptorPool;
-VkDescriptorSet presentDescriptorSets[MAX_FRAMES_IN_FLIGHT];
+VkDescriptorSet *presentDescriptorSets;
 VkPipelineLayout pipelineLayout;
 VkPipeline graphicsPipeline;
 VkFramebuffer *swapchainFramebuffers = nullptr;
@@ -97,10 +97,10 @@ VkCommandPool transferCommandPool;
 VkCommandBuffer transferCommandBuffer;
 VkCommandPool graphicsCommandPool;
 VkCommandBuffer graphicsCommandBuffer;
-VkCommandBuffer presentCommandBuffers[MAX_FRAMES_IN_FLIGHT];
-VkSemaphore presentImageAvailableSemaphores[MAX_FRAMES_IN_FLIGHT];
-VkSemaphore presentRenderFinishedSemaphores[MAX_FRAMES_IN_FLIGHT];
-VkFence presentInFlightFences[MAX_FRAMES_IN_FLIGHT];
+VkCommandBuffer *presentCommandBuffers;
+VkSemaphore *presentImageAvailableSemaphores;
+VkSemaphore *presentRenderFinishedSemaphores;
+VkFence *presentInFlightFences;
 UniformBufferObject UBO{
 	.model = glm::mat4(1),
 	.view = glm::lookAt(glm::vec3(0), glm::vec3(2, 2, 0), glm::vec3(0, 1, 0)),
@@ -110,7 +110,7 @@ VkDeviceMemory uniformBufferMemory;
 VkDeviceSize paddedUboBufferSize;
 
 // public
-VkBuffer UniformBuffers[MAX_FRAMES_IN_FLIGHT];
+VkBuffer *UniformBuffers;
 DebugHitbox pkeDebugHitbox{};
 ImplementedPipelines pkePipelines{};
 
@@ -681,14 +681,14 @@ void CreateImageResources_Inner(VkImageCreateInfo *imageCreateInfo, VkImageViewC
 	VkMemoryAllocateInfo vkMemoryAllocateInfo{};
 	vkMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
 	vkMemoryAllocateInfo.pNext = nullptr;
-	vkMemoryAllocateInfo.allocationSize = paddedImageSize * MAX_FRAMES_IN_FLIGHT;
+	vkMemoryAllocateInfo.allocationSize = paddedImageSize * swapchainLength;
 	vkMemoryAllocateInfo.memoryTypeIndex = FindMemoryTypeIndex(imageMemoryRequirements.memoryTypeBits,
 			VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 
 	vkResult = vkAllocateMemory(vkDevice, &vkMemoryAllocateInfo, vkAllocator, deviceMemory);
 	assert(vkResult == VK_SUCCESS);
 
-	for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
+	for (long i = 0; i < swapchainLength; ++i) {
 		vkResult = vkCreateImage(vkDevice, imageCreateInfo, vkAllocator, &images[i]);
 		assert(vkResult == VK_SUCCESS);
 		vkResult = vkBindImageMemory(vkDevice, images[i], *deviceMemory, paddedImageSize * i);
@@ -705,9 +705,10 @@ void CreateSwapchain() {
 	VkResult vkResult;
 	VkSurfaceCapabilitiesKHR surfaceCapabilities;
 	vkResult = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vkPhysicalDevice, vkSurfaceKHR, &surfaceCapabilities);
+	swapchainLength = surfaceCapabilities.minImageCount;
 	assert(vkResult == VK_SUCCESS);
-	assert(MAX_FRAMES_IN_FLIGHT >= surfaceCapabilities.minImageCount);
-	assert(surfaceCapabilities.maxImageCount == 0 || MAX_FRAMES_IN_FLIGHT <= surfaceCapabilities.maxImageCount);
+	assert(swapchainLength >= surfaceCapabilities.minImageCount);
+	assert(surfaceCapabilities.maxImageCount == 0 || swapchainLength <= surfaceCapabilities.maxImageCount);
 
 	if (selectedSurfaceIndex == -1u) {
 		unsigned int surfaceFormatCounts;
@@ -787,7 +788,7 @@ void CreateSwapchain() {
 	vkSwapchainCreateInfo.pNext = nullptr;
 	vkSwapchainCreateInfo.flags = 0;
 	vkSwapchainCreateInfo.surface = vkSurfaceKHR;
-	vkSwapchainCreateInfo.minImageCount = MAX_FRAMES_IN_FLIGHT;
+	vkSwapchainCreateInfo.minImageCount = swapchainLength;
 	vkSwapchainCreateInfo.imageFormat = vkSurfaceFormatKHR.format;
 	vkSwapchainCreateInfo.imageColorSpace = vkSurfaceFormatKHR.colorSpace;
 	vkSwapchainCreateInfo.imageExtent = Extent;
@@ -882,25 +883,25 @@ void CreateSwapchain() {
 	renderTargetImageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
 	// render images
-	renderImages = pk_new<VkImage>(MAX_FRAMES_IN_FLIGHT);
-	renderImageViews = pk_new<VkImageView>(MAX_FRAMES_IN_FLIGHT);
+	renderImages = pk_new<VkImage>(swapchainLength);
+	renderImageViews = pk_new<VkImageView>(swapchainLength);
 	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, renderImages, renderImageViews, &renderImagesMemory);
 
 	// color images
-	colorImages = pk_new<VkImage>(MAX_FRAMES_IN_FLIGHT);
-	colorImageViews = pk_new<VkImageView>(MAX_FRAMES_IN_FLIGHT);
+	colorImages = pk_new<VkImage>(swapchainLength);
+	colorImageViews = pk_new<VkImageView>(swapchainLength);
 	renderTargetImageCI.samples = renderSampleCount;
 	renderTargetImageCI.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, colorImages, colorImageViews, &colorImagesMemory);
 
 	// 2d overlay images
-	d2OverlayImages = pk_new<VkImage>(MAX_FRAMES_IN_FLIGHT);
-	d2OverlayImageViews = pk_new<VkImageView>(MAX_FRAMES_IN_FLIGHT);
+	d2OverlayImages = pk_new<VkImage>(swapchainLength);
+	d2OverlayImageViews = pk_new<VkImageView>(swapchainLength);
 	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, d2OverlayImages, d2OverlayImageViews, &d2OverlayImagesMemory);
 
 	// depth images
-	depthImages = pk_new<VkImage>(MAX_FRAMES_IN_FLIGHT);
-	depthImageViews = pk_new<VkImageView>(MAX_FRAMES_IN_FLIGHT);
+	depthImages = pk_new<VkImage>(swapchainLength);
+	depthImageViews = pk_new<VkImageView>(swapchainLength);
 	renderTargetImageCI.format = depthFormat;
 	vkImageViewCreateInfo.format = depthFormat;
 	renderTargetImageCI.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
@@ -909,9 +910,9 @@ void CreateSwapchain() {
 }
 
 void UpdatePresentDescriptorSets() {
-	VkWriteDescriptorSet writeDescriptorSets[MAX_FRAMES_IN_FLIGHT];
-	VkDescriptorImageInfo descriptorImageInfo[MAX_FRAMES_IN_FLIGHT];
-	for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
+	VkWriteDescriptorSet *writeDescriptorSets = pk_new<VkWriteDescriptorSet>(swapchainLength);
+	VkDescriptorImageInfo *descriptorImageInfo = pk_new<VkDescriptorImageInfo>(swapchainLength);
+	for (long i = 0; i < swapchainLength; ++i) {
 		writeDescriptorSets[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 		writeDescriptorSets[i].pNext = nullptr;
 		writeDescriptorSets[i].dstBinding = 0U;
@@ -928,7 +929,9 @@ void UpdatePresentDescriptorSets() {
 		writeDescriptorSets[i].dstSet = presentDescriptorSets[i];
 	}
 
-	vkUpdateDescriptorSets(vkDevice, MAX_FRAMES_IN_FLIGHT, writeDescriptorSets, 0, nullptr);
+	vkUpdateDescriptorSets(vkDevice, swapchainLength, writeDescriptorSets, 0, nullptr);
+	pk_delete<VkWriteDescriptorSet>(writeDescriptorSets, swapchainLength);
+	pk_delete<VkDescriptorImageInfo>(descriptorImageInfo, swapchainLength);
 }
 
 void UpdateCamera() {
@@ -1292,25 +1295,28 @@ void CreatePresentPipeline() {
 	descriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
 	descriptorPoolCreateInfo.pNext = nullptr;
 	descriptorPoolCreateInfo.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
-	descriptorPoolCreateInfo.maxSets = MAX_FRAMES_IN_FLIGHT;
+	descriptorPoolCreateInfo.maxSets = swapchainLength;
 	descriptorPoolCreateInfo.poolSizeCount = 1;
 	descriptorPoolCreateInfo.pPoolSizes = &vkDescriptorPoolSize;
 
 	vkResult = vkCreateDescriptorPool(vkDevice, &descriptorPoolCreateInfo, vkAllocator, &presentDescriptorPool);
 	assert(vkResult == VK_SUCCESS);
 
-	VkDescriptorSetLayout setLayouts[MAX_FRAMES_IN_FLIGHT];
-	for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
+	VkDescriptorSetLayout *setLayouts = pk_new<VkDescriptorSetLayout>(swapchainLength);
+	for (long i = 0; i < swapchainLength; ++i) {
 		setLayouts[i] = vkDescriptorSetLayout;
 	}
 	VkDescriptorSetAllocateInfo allocInfo;
 	allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
 	allocInfo.pNext = nullptr;
 	allocInfo.descriptorPool = presentDescriptorPool;
-	allocInfo.descriptorSetCount = MAX_FRAMES_IN_FLIGHT;
+	allocInfo.descriptorSetCount = swapchainLength;
 	allocInfo.pSetLayouts = setLayouts;
 
+	presentDescriptorSets = pk_new<VkDescriptorSet>(swapchainLength, MemBkt_Vulkan);
 	vkResult = vkAllocateDescriptorSets(vkDevice, &allocInfo, presentDescriptorSets);
+	pk_delete<VkDescriptorSetLayout>(setLayouts, swapchainLength);
+	// setLayouts = CAFE_BABE(VkDescriptorSetLayout);
 	if (vkResult != VK_SUCCESS) {
 		throw "failed to allocate present descriptor sets";
 	}
@@ -1458,8 +1464,9 @@ void CreateCommandBuffer() {
 	allocInfo.pNext = nullptr;
 	allocInfo.commandPool = graphicsCommandPool;
 	allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-	allocInfo.commandBufferCount = MAX_FRAMES_IN_FLIGHT;
+	allocInfo.commandBufferCount = swapchainLength;
 
+	presentCommandBuffers = pk_new<VkCommandBuffer>(swapchainLength, MemBkt_Vulkan);
 	auto result = vkAllocateCommandBuffers(vkDevice, &allocInfo, presentCommandBuffers);
 	if (result != VK_SUCCESS) {
 		throw "failed to allocate command buffer";
@@ -1479,6 +1486,8 @@ void CreateCommandBuffer() {
 }
 
 void CreateUniformBuffers() {
+	VkResult result;
+
 	uint32_t queueFamilyIndexes[2] = {graphicsFamilyIndex, transferFamilyIndex};
 	VkBufferCreateInfo vkBufferCreateInfo;
 	vkBufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
@@ -1490,7 +1499,7 @@ void CreateUniformBuffers() {
 	vkBufferCreateInfo.queueFamilyIndexCount = graphicsFamilyIndex == transferFamilyIndex ? 1 : 2;
 	vkBufferCreateInfo.pQueueFamilyIndices = queueFamilyIndexes;
 
-	VkResult result;
+	UniformBuffers = pk_new<VkBuffer>(swapchainLength, MemBkt_Vulkan);
 	result = vkCreateBuffer(vkDevice, &vkBufferCreateInfo, vkAllocator, &UniformBuffers[0]);
 	assert(result == VK_SUCCESS);
 
@@ -1501,7 +1510,7 @@ void CreateUniformBuffers() {
 	VkMemoryAllocateInfo vkMemoryAllocateInfo;
 	vkMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
 	vkMemoryAllocateInfo.pNext = nullptr;
-	vkMemoryAllocateInfo.allocationSize = paddedUboBufferSize * MAX_FRAMES_IN_FLIGHT;
+	vkMemoryAllocateInfo.allocationSize = paddedUboBufferSize * swapchainLength;
 	vkMemoryAllocateInfo.memoryTypeIndex = FindMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
 
 	result = vkAllocateMemory(vkDevice, &vkMemoryAllocateInfo, vkAllocator, &uniformBufferMemory);
@@ -1510,7 +1519,7 @@ void CreateUniformBuffers() {
 	vkDestroyBuffer(vkDevice, UniformBuffers[0], vkAllocator);
 	vkBufferCreateInfo.size = paddedUboBufferSize;
 
-	for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
+	for (long i = 0; i < swapchainLength; ++i) {
 		result = vkCreateBuffer(vkDevice, &vkBufferCreateInfo, vkAllocator, &UniformBuffers[i]);
 		assert(result == VK_SUCCESS);
 		result = vkBindBufferMemory(vkDevice, UniformBuffers[i], uniformBufferMemory, paddedUboBufferSize * i);
@@ -1529,7 +1538,10 @@ void CreateSyncObjects() {
 	fenceInfo.pNext = nullptr;
 	fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
 
-	for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
+	presentImageAvailableSemaphores = pk_new<VkSemaphore>(swapchainLength, MemBkt_Vulkan);
+	presentRenderFinishedSemaphores = pk_new<VkSemaphore>(swapchainLength, MemBkt_Vulkan);
+	presentInFlightFences = pk_new<VkFence>(swapchainLength, MemBkt_Vulkan);
+	for (long i = 0; i < swapchainLength; ++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]);
@@ -2246,15 +2258,15 @@ void UpdateDebugGraphicsPipeline() {
 	// descriptor pool & sets
 	VkDescriptorPoolSize descriptorPoolSizes[2];
 	descriptorPoolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-	descriptorPoolSizes[0].descriptorCount = MAX_FRAMES_IN_FLIGHT;
+	descriptorPoolSizes[0].descriptorCount = swapchainLength;
 	descriptorPoolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-	descriptorPoolSizes[1].descriptorCount = MAX_FRAMES_IN_FLIGHT;
+	descriptorPoolSizes[1].descriptorCount = swapchainLength;
 
 	VkDescriptorPoolCreateInfo vkDescriptorPoolCreateInfo;
 	vkDescriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
 	vkDescriptorPoolCreateInfo.pNext = nullptr;
 	vkDescriptorPoolCreateInfo.flags = 0;
-	vkDescriptorPoolCreateInfo.maxSets = MAX_FRAMES_IN_FLIGHT;
+	vkDescriptorPoolCreateInfo.maxSets = swapchainLength;
 	vkDescriptorPoolCreateInfo.poolSizeCount = (uint32_t)2;
 	vkDescriptorPoolCreateInfo.pPoolSizes = descriptorPoolSizes;
 
@@ -2262,26 +2274,28 @@ void UpdateDebugGraphicsPipeline() {
 	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) {
+	VkDescriptorSetLayout *descriptorSets = pk_new<VkDescriptorSetLayout>(swapchainLength);
+	for (long i = 0; i < swapchainLength; ++i) {
 		descriptorSets[i] = pkePipelines.descr_layouts.named.texture;
 	}
 	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.descriptorSetCount = swapchainLength;
 	vkDescriptorSetAllocateInfo.pSetLayouts = descriptorSets;
 
-	pkeDebugHitbox.vkDescriptorSets = pk_new<VkDescriptorSet>(MAX_FRAMES_IN_FLIGHT);
-	for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
+	pkeDebugHitbox.vkDescriptorSets = pk_new<VkDescriptorSet>(swapchainLength);
+	for (long i = 0; i < swapchainLength; ++i) {
 		pkeDebugHitbox.vkDescriptorSets[i] = VkDescriptorSet{};
 	}
 	vkResult = vkAllocateDescriptorSets(vkDevice, &vkDescriptorSetAllocateInfo, pkeDebugHitbox.vkDescriptorSets);
+	pk_delete<VkDescriptorSetLayout>(descriptorSets, swapchainLength);
+	// descriptorSets = CAFE_BABE(VkDescriptorSetLayout);
 	assert(vkResult == VK_SUCCESS);
 
-	VkWriteDescriptorSet writeDescriptorSets[2 * MAX_FRAMES_IN_FLIGHT];
-	for (long i = 0; i < 2 * MAX_FRAMES_IN_FLIGHT; ++i) {
+	VkWriteDescriptorSet *writeDescriptorSets = pk_new<VkWriteDescriptorSet>(2 * swapchainLength);
+	for (long i = 0; i < 2 * swapchainLength; ++i) {
 		writeDescriptorSets[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 		writeDescriptorSets[i].pNext = nullptr;
 		writeDescriptorSets[i].dstSet = nullptr;
@@ -2300,9 +2314,9 @@ void UpdateDebugGraphicsPipeline() {
 	textureDescriptorInfo.imageView = pkeDebugHitbox.vkImageView;
 	textureDescriptorInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
-	VkDescriptorBufferInfo vkDescriptorBufferInfo[MAX_FRAMES_IN_FLIGHT];
+	VkDescriptorBufferInfo *vkDescriptorBufferInfo = pk_new<VkDescriptorBufferInfo>(swapchainLength);
 
-	for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
+	for (long i = 0; i < swapchainLength; ++i) {
 		vkDescriptorBufferInfo[i].buffer = UniformBuffers[i];
 		vkDescriptorBufferInfo[i].offset = 0;
 		vkDescriptorBufferInfo[i].range = sizeof(UniformBufferObject);
@@ -2317,7 +2331,9 @@ void UpdateDebugGraphicsPipeline() {
 		writeDescriptorSets[samplerIndex].dstSet = pkeDebugHitbox.vkDescriptorSets[i];
 	}
 
-	vkUpdateDescriptorSets(vkDevice, 2 * MAX_FRAMES_IN_FLIGHT, writeDescriptorSets, 0, nullptr);
+	vkUpdateDescriptorSets(vkDevice, 2 * swapchainLength, writeDescriptorSets, 0, nullptr);
+	pk_delete<VkWriteDescriptorSet>(writeDescriptorSets, 2 * swapchainLength);
+	pk_delete<VkDescriptorBufferInfo>(vkDescriptorBufferInfo, swapchainLength);
 }
 
 void CreateImGui() {
@@ -2360,10 +2376,10 @@ void CreateImGui() {
 	// initInfo.ColorAttachmentFormat = VkFormat::VK_FORMAT_B8G8R8A8_SRGB;
 	initInfo.DescriptorPool = imGuiDescriptorPool;
 	initInfo.Device = vkDevice;
-	initInfo.ImageCount = MAX_FRAMES_IN_FLIGHT;
+	initInfo.ImageCount = swapchainLength;
 	initInfo.Instance = vkInstance;
 	initInfo.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
-	initInfo.MinImageCount = MAX_FRAMES_IN_FLIGHT;
+	initInfo.MinImageCount = swapchainLength;
 	initInfo.PhysicalDevice = vkPhysicalDevice;
 	initInfo.PipelineCache = {};
 	initInfo.Queue = graphicsQueue;
@@ -2419,7 +2435,7 @@ void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
 		throw "failed to begin recording command buffer";
 	}
 
-	VkClearColorValue clearColorTransparent = {{0.0f, 0.0f, 0.0f, 0.0f}};
+	// VkClearColorValue clearColorTransparent = {{0.0f, 0.0f, 0.0f, 0.0f}};
 	VkClearColorValue clearColorBlack = {{0.0f, 0.0f, 0.0f, 1.0f}};
 	VkClearDepthStencilValue clearDepth;
 	clearDepth.depth = 1.0;
@@ -2746,7 +2762,7 @@ void DestroyWindow() {
 	DestroySwapchain();
 
 	vkDestroyDescriptorPool(vkDevice, pkeDebugHitbox.vkDescriptorPool, vkAllocator);
-	pk_delete<VkDescriptorSet>(pkeDebugHitbox.vkDescriptorSets, MAX_FRAMES_IN_FLIGHT);
+	pk_delete<VkDescriptorSet>(pkeDebugHitbox.vkDescriptorSets, swapchainLength);
 
 	vkDestroyBuffer(vkDevice, pkeDebugHitbox.indexBuffer, vkAllocator);
 	vkDestroyBuffer(vkDevice, pkeDebugHitbox.uvBuffer, vkAllocator);
@@ -2773,18 +2789,29 @@ void DestroyWindow() {
 			vkDestroyDescriptorSetLayout(vkDevice, pkePipelines.descr_layouts.arr[i], vkAllocator);
 	}
 
-	for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
+	for (long i = 0; i < swapchainLength; ++i) {
 		vkDestroyBuffer(vkDevice, UniformBuffers[i], vkAllocator);
 		vkDestroySemaphore(vkDevice, presentImageAvailableSemaphores[i], vkAllocator);
 		vkDestroySemaphore(vkDevice, presentRenderFinishedSemaphores[i], vkAllocator);
 		vkDestroyFence(vkDevice, presentInFlightFences[i], vkAllocator);
 	}
+	pk_delete<VkBuffer>(UniformBuffers, swapchainLength, MemBkt_Vulkan);
+	UniformBuffers = CAFE_BABE(VkBuffer);
+	pk_delete<VkSemaphore>(presentImageAvailableSemaphores, swapchainLength, MemBkt_Vulkan);
+	presentImageAvailableSemaphores = CAFE_BABE(VkSemaphore);
+	pk_delete<VkSemaphore>(presentRenderFinishedSemaphores, swapchainLength, MemBkt_Vulkan);
+	presentRenderFinishedSemaphores = CAFE_BABE(VkSemaphore);
+	pk_delete<VkFence>(presentInFlightFences, swapchainLength, MemBkt_Vulkan);
+	presentInFlightFences = CAFE_BABE(VkFence);
+
 	vkFreeMemory(vkDevice, uniformBufferMemory, vkAllocator);
 	vkDestroyCommandPool(vkDevice, graphicsCommandPool, vkAllocator);
 	vkDestroyCommandPool(vkDevice, transferCommandPool, vkAllocator);
 	vkDestroyPipeline(vkDevice, graphicsPipeline, vkAllocator);
 	vkDestroyPipelineLayout(vkDevice, pipelineLayout, vkAllocator);
-	vkFreeDescriptorSets(vkDevice, presentDescriptorPool, MAX_FRAMES_IN_FLIGHT, presentDescriptorSets);
+	vkFreeDescriptorSets(vkDevice, presentDescriptorPool, swapchainLength, presentDescriptorSets);
+	pk_delete<VkDescriptorSet>(presentDescriptorSets, swapchainLength, MemBkt_Vulkan);
+	presentDescriptorSets = CAFE_BABE(VkDescriptorSet);
 	vkDestroyDescriptorPool(vkDevice, presentDescriptorPool, vkAllocator);
 	vkDestroyDescriptorPool(vkDevice, imGuiDescriptorPool, vkAllocator);
 	vkDestroyDescriptorSetLayout(vkDevice, vkDescriptorSetLayout, vkAllocator);
@@ -2927,6 +2954,6 @@ void Render() {
 		throw "failed to present swapchain image";
 	}
 
-	CURRENT_FRAME = (CURRENT_FRAME + 1) % MAX_FRAMES_IN_FLIGHT;
+	CURRENT_FRAME = (CURRENT_FRAME + 1) % swapchainLength;
 }