pke: MemBkt_Vulkan and transient bkt pass

1 files changed, 63 insertions, 61 deletions

diff --git a/src/window.cpp b/src/window.cpp
index 81c39e7..3d2f492 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -63,8 +63,8 @@ unsigned int transferFamilyIndex;
 bool shouldRecreateSwapchain = false;
 unsigned int CURRENT_FRAME = 0;
 unsigned int selectedSurfaceIndex = -1u;
-unsigned int prevSwapchainLength = 0u;
 unsigned int swapchainLength = 0u;
+unsigned int prevSwapchainLength = 0u;
 VkSwapchainKHR vkSwapchainKHR = VK_NULL_HANDLE;
 VkSurfaceFormatKHR vkSurfaceFormatKHR;
 VkFormat depthFormat;
@@ -636,7 +636,7 @@ unsigned int FindQueueFamilyIndex(VkPhysicalDevice device, char hasPresentSuppor
 
 	unsigned int queueFamilyPropertyCount = 0U;
 	vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyPropertyCount, nullptr);
-	auto *queueFamilyProperties = pk_new<VkQueueFamilyProperties>(queueFamilyPropertyCount);
+	auto *queueFamilyProperties = pk_new<VkQueueFamilyProperties>(queueFamilyPropertyCount, pkeSettings.mem.bkt);
 	vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyPropertyCount, queueFamilyProperties);
 
 	for (unsigned int i = 0; i < queueFamilyPropertyCount; i++) {
@@ -654,11 +654,9 @@ unsigned int FindQueueFamilyIndex(VkPhysicalDevice device, char hasPresentSuppor
 				continue;
 			}
 		}
-		pk_delete<VkQueueFamilyProperties>(queueFamilyProperties, queueFamilyPropertyCount);
 		return i;
 	}
 
-	pk_delete<VkQueueFamilyProperties>(queueFamilyProperties, queueFamilyPropertyCount);
 	return 0xFFFFFFFF;
 }
 
@@ -763,14 +761,13 @@ void InitVulkan() {
 		unsigned int layerCount;
 		vkResult = vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
 		assert(vkResult == VK_SUCCESS);
-		VkLayerProperties *availableLayerProperties = pk_new<VkLayerProperties>(layerCount);
+		VkLayerProperties *availableLayerProperties = pk_new<VkLayerProperties>(layerCount, pkeSettings.mem.bkt);
 		vkResult = vkEnumerateInstanceLayerProperties(&layerCount, availableLayerProperties);
 		assert(vkResult == VK_SUCCESS);
 		printf("Available Layers:\n");
 		for (long i = 0; i < layerCount; ++i) {
 			printf("\t%s\n", availableLayerProperties[i].layerName);
 		}
-		pk_delete<VkLayerProperties>(availableLayerProperties, layerCount);
 	}
 
 	VkApplicationInfo appInfo;
@@ -840,14 +837,13 @@ void InitVulkan() {
 		unsigned int extensionCount = 0;
 		vkResult = vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
 		assert(vkResult == VK_SUCCESS);
-		auto *extensions = pk_new<VkExtensionProperties>(extensionCount);
+		auto *extensions = pk_new<VkExtensionProperties>(extensionCount, pkeSettings.mem.bkt);
 		vkResult = vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions);
 		assert(vkResult == VK_SUCCESS);
 		printf("Available Extensions:\n");
 		for (long i = 0; i < extensionCount; ++i) {
 			printf("\t%s\n", extensions[i].extensionName);
 		}
-		pk_delete<VkExtensionProperties>(extensions, extensionCount);
 	}
 
 	vkResult = vkCreateInstance(&createInfo, vkAllocator, &vkInstance);
@@ -887,7 +883,7 @@ void InitVulkan() {
 	vkResult = vkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, nullptr);
 	assert(vkResult == VK_SUCCESS);
 	assert(physicalDeviceCount > 0);
-	auto *physicalDevices = pk_new<VkPhysicalDevice>(physicalDeviceCount);
+	auto *physicalDevices = pk_new<VkPhysicalDevice>(physicalDeviceCount, pkeSettings.mem.bkt);
 	vkResult = vkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, physicalDevices);
 	assert(vkResult == VK_SUCCESS);
 	graphicsFamilyIndex = 0;
@@ -907,7 +903,7 @@ void InitVulkan() {
 		unsigned int extensionCount = 0;
 		vkResult = vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
 		assert(vkResult == VK_SUCCESS);
-		auto *extensionProperties = pk_new<VkExtensionProperties>(extensionCount);
+		auto *extensionProperties = pk_new<VkExtensionProperties>(extensionCount, pkeSettings.mem.bkt);
 		vkResult = vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, extensionProperties);
 		assert(vkResult == VK_SUCCESS);
 		for (long k = 0; k < extensionCount; ++k) {
@@ -921,7 +917,6 @@ void InitVulkan() {
 				}
 			}
 		}
-		pk_delete<VkExtensionProperties>(extensionProperties, extensionCount);
 		if (requiredExtensions.empty() == false) {
 			continue;
 		}
@@ -950,7 +945,6 @@ void InitVulkan() {
 		break;
 	}
 	assert(vkPhysicalDevice != nullptr && "Failed to find suitable physical device");
-	pk_delete<VkPhysicalDevice>(physicalDevices, physicalDeviceCount);
 
 	// Create logical device
 	{
@@ -1166,7 +1160,7 @@ void CreateSwapchain() {
 		unsigned int surfaceFormatCounts;
 		vkResult = vkGetPhysicalDeviceSurfaceFormatsKHR(vkPhysicalDevice, vkSurfaceKHR, &surfaceFormatCounts, nullptr);
 		assert(vkResult == VK_SUCCESS);
-		VkSurfaceFormatKHR *surfaceFormats = pk_new<VkSurfaceFormatKHR>(surfaceFormatCounts);
+		VkSurfaceFormatKHR *surfaceFormats = pk_new<VkSurfaceFormatKHR>(surfaceFormatCounts, pkeSettings.mem.bkt);
 		vkResult = vkGetPhysicalDeviceSurfaceFormatsKHR(vkPhysicalDevice, vkSurfaceKHR, &surfaceFormatCounts, surfaceFormats);
 		assert(vkResult == VK_SUCCESS);
 		selectedSurfaceIndex = 0;
@@ -1178,8 +1172,6 @@ void CreateSwapchain() {
 			vkSurfaceFormatKHR.format = surfaceFormats[i].format;
 			break;
 		}
-
-		pk_delete<VkSurfaceFormatKHR>(surfaceFormats, surfaceFormatCounts);
 	}
 
 	int width, height;
@@ -1194,11 +1186,10 @@ void CreateSwapchain() {
 		unsigned int presentModeCount = 0;
 		vkResult = vkGetPhysicalDeviceSurfacePresentModesKHR(vkPhysicalDevice, vkSurfaceKHR, &presentModeCount, nullptr);
 		assert(vkResult == VK_SUCCESS);
-		VkPresentModeKHR *presentModes = pk_new<VkPresentModeKHR>(presentModeCount);
+		VkPresentModeKHR *presentModes = pk_new<VkPresentModeKHR>(presentModeCount, pkeSettings.mem.bkt);
 		vkResult = vkGetPhysicalDeviceSurfacePresentModesKHR(vkPhysicalDevice, vkSurfaceKHR, &presentModeCount, presentModes);
 		assert(vkResult == VK_SUCCESS);
 		vkPresentModeKHR = PickPresentMode(presentModes, presentModeCount);
-		pk_delete<VkPresentModeKHR>(presentModes, presentModeCount);
 	}
 
 	VkSwapchainCreateInfoKHR vkSwapchainCreateInfo;
@@ -1253,10 +1244,10 @@ void CreateSwapchain() {
 	assert(vkResult == VK_SUCCESS);
 	assert(swapchainLength >= surfaceCapabilities.minImageCount);
 	assert(surfaceCapabilities.maxImageCount == 0 || swapchainLength <= surfaceCapabilities.maxImageCount);
-	pkvk_present.images = pk_new<VkImage>(swapchainLength);
+	pkvk_present.images = pk_new<VkImage>(swapchainLength, MemBkt_Vulkan);
 	vkResult = vkGetSwapchainImagesKHR(vkDevice, vkSwapchainKHR, &swapchainLength, pkvk_present.images);
 	assert(vkResult == VK_SUCCESS);
-	pkvk_present.image_views = pk_new<VkImageView>(swapchainLength);
+	pkvk_present.image_views = pk_new<VkImageView>(swapchainLength, MemBkt_Vulkan);
 
 	VkImageSubresourceRange vkImageSubresourceRange;
 	vkImageSubresourceRange.aspectMask = VkImageAspectFlagBits::VK_IMAGE_ASPECT_COLOR_BIT;
@@ -1306,13 +1297,13 @@ void CreateSwapchain() {
 	renderTargetImageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
 	// 3d color (fragment) images
-	pkvk_3d.render_images = pk_new<VkImage>(swapchainLength);
-	pkvk_3d.image_views = pk_new<VkImageView>(swapchainLength);
+	pkvk_3d.render_images = pk_new<VkImage>(swapchainLength, MemBkt_Vulkan);
+	pkvk_3d.image_views = pk_new<VkImageView>(swapchainLength, MemBkt_Vulkan);
 	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, pkvk_3d.render_images, pkvk_3d.image_views, &pkvk_3d.images_memory);
 
 	// 2d color (fragment) images
-	pkvk_2d.images = pk_new<VkImage>(swapchainLength);
-	pkvk_2d.image_views = pk_new<VkImageView>(swapchainLength);
+	pkvk_2d.images = pk_new<VkImage>(swapchainLength, MemBkt_Vulkan);
+	pkvk_2d.image_views = pk_new<VkImageView>(swapchainLength, MemBkt_Vulkan);
 	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, pkvk_2d.images, pkvk_2d.image_views, &pkvk_2d.images_memory);
 
 	// resolve settings
@@ -1320,13 +1311,13 @@ void CreateSwapchain() {
 	renderTargetImageCI.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
 
 	// 3d color (resolve)
-	pkvk_3d.images_color_resolve = pk_new<VkImage>(swapchainLength);
-	pkvk_3d.image_views_color_resolve = pk_new<VkImageView>(swapchainLength);
+	pkvk_3d.images_color_resolve = pk_new<VkImage>(swapchainLength, MemBkt_Vulkan);
+	pkvk_3d.image_views_color_resolve = pk_new<VkImageView>(swapchainLength, MemBkt_Vulkan);
 	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, pkvk_3d.images_color_resolve, pkvk_3d.image_views_color_resolve, &pkvk_3d.images_memory_color_resolve);
 
 	// 2d color (resolve)
-	pkvk_2d.images_color_resolve = pk_new<VkImage>(swapchainLength);
-	pkvk_2d.image_views_color_resolve = pk_new<VkImageView>(swapchainLength);
+	pkvk_2d.images_color_resolve = pk_new<VkImage>(swapchainLength, MemBkt_Vulkan);
+	pkvk_2d.image_views_color_resolve = pk_new<VkImageView>(swapchainLength, MemBkt_Vulkan);
 	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, pkvk_2d.images_color_resolve, pkvk_2d.image_views_color_resolve, &pkvk_2d.images_memory_color_resolve);
 
 	// depth settings
@@ -1337,14 +1328,14 @@ void CreateSwapchain() {
 	vkImageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
 
 	// depth images
-	depthImages = pk_new<VkImage>(swapchainLength);
-	depthImageViews = pk_new<VkImageView>(swapchainLength);
+	depthImages = pk_new<VkImage>(swapchainLength, MemBkt_Vulkan);
+	depthImageViews = pk_new<VkImageView>(swapchainLength, MemBkt_Vulkan);
 	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, depthImages, depthImageViews, &depthImagesMemory);
 }
 
 void UpdatePresentDescriptorSets() {
-	VkWriteDescriptorSet *writeDescriptorSets = pk_new<VkWriteDescriptorSet>(swapchainLength * 2);
-	VkDescriptorImageInfo *descriptorImageInfo = pk_new<VkDescriptorImageInfo>(swapchainLength * 2);
+	VkWriteDescriptorSet *writeDescriptorSets = pk_new<VkWriteDescriptorSet>(swapchainLength * 2, pkeSettings.mem.bkt);
+	VkDescriptorImageInfo *descriptorImageInfo = pk_new<VkDescriptorImageInfo>(swapchainLength * 2, pkeSettings.mem.bkt);
 	for (long i = 0; i < swapchainLength * 2; ++i) {
 		writeDescriptorSets[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 		writeDescriptorSets[i].pNext = nullptr;
@@ -1365,8 +1356,6 @@ void UpdatePresentDescriptorSets() {
 	}
 
 	vkUpdateDescriptorSets(vkDevice, swapchainLength * 2, writeDescriptorSets, 0, nullptr);
-	pk_delete<VkWriteDescriptorSet>(writeDescriptorSets, swapchainLength * 2);
-	pk_delete<VkDescriptorImageInfo>(descriptorImageInfo, swapchainLength * 2);
 }
 
 void UpdateCamera() {
@@ -1582,6 +1571,8 @@ void CreatePresentDescriptorSetLayout() {
 void CreatePresentPipeline() {
 	VkResult vkResult;
 
+	assert(pkvk_present.descriptor_sets == nullptr || pkvk_present.descriptor_sets == CAFE_BABE(VkDescriptorSet));
+
 	// enqueue asset loading
 	AssetHandle vertShaderAsset{AM_GetHandle(AssetKey{"pke_prsnt_vrt\0\0"})};
 	AssetHandle fragShaderAsset{AM_GetHandle(AssetKey{"pke_prsnt_frg\0\0"})};
@@ -1733,7 +1724,7 @@ void CreatePresentPipeline() {
 	vkResult = vkCreateDescriptorPool(vkDevice, &descriptorPoolCreateInfo, vkAllocator, &pkvk_present.descriptor_pool);
 	assert(vkResult == VK_SUCCESS);
 
-	VkDescriptorSetLayout *setLayouts = pk_new<VkDescriptorSetLayout>(swapchainLength * 2);
+	VkDescriptorSetLayout *setLayouts = pk_new<VkDescriptorSetLayout>(swapchainLength * 2, pkeSettings.mem.bkt);
 	for (long i = 0; i < swapchainLength * 2; ++i) {
 		setLayouts[i] = pkvk_present.descriptor_set_layout;
 	}
@@ -1746,7 +1737,6 @@ void CreatePresentPipeline() {
 
 	pkvk_present.descriptor_sets = pk_new<VkDescriptorSet>(swapchainLength * 2, MemBkt_Vulkan);
 	vkResult = vkAllocateDescriptorSets(vkDevice, &allocInfo, pkvk_present.descriptor_sets);
-	pk_delete<VkDescriptorSetLayout>(setLayouts, swapchainLength * 2);
 	// setLayouts = CAFE_BABE(VkDescriptorSetLayout);
 	if (vkResult != VK_SUCCESS) {
 		throw "failed to allocate present descriptor sets";
@@ -1813,9 +1803,9 @@ void CreateFramebuffers() {
 	assert(pkvk_present.framebuffers == nullptr || pkvk_present.framebuffers == CAFE_BABE(VkFramebuffer));
 	assert(pkvk_3d.framebuffers == nullptr || pkvk_3d.framebuffers == CAFE_BABE(VkFramebuffer));
 	assert(pkvk_2d.framebuffers == nullptr || pkvk_2d.framebuffers == CAFE_BABE(VkFramebuffer));
-	pkvk_present.framebuffers = pk_new<VkFramebuffer>(swapchainLength);
-	pkvk_3d.framebuffers = pk_new<VkFramebuffer>(swapchainLength);
-	pkvk_2d.framebuffers = pk_new<VkFramebuffer>(swapchainLength);
+	pkvk_present.framebuffers = pk_new<VkFramebuffer>(swapchainLength, MemBkt_Vulkan);
+	pkvk_3d.framebuffers = pk_new<VkFramebuffer>(swapchainLength, MemBkt_Vulkan);
+	pkvk_2d.framebuffers = pk_new<VkFramebuffer>(swapchainLength, MemBkt_Vulkan);
 
 	VkFramebufferCreateInfo framebufferInfo;
 	framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
@@ -1898,6 +1888,8 @@ void DestroyPresentCommandBuffers() {
 }
 
 void CreatePresentCommandBuffers() {
+	assert(pkvk_present.command_buffers == nullptr);
+
 	VkCommandBufferAllocateInfo allocInfo;
 	allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
 	allocInfo.pNext = nullptr;
@@ -2958,12 +2950,16 @@ void CreateGraphicsPipelines() {
 void DestroyDebugDescriptors() {
 	if (pkeDebugHitbox.vkDescriptorPool != VK_NULL_HANDLE) {
 		vkDestroyDescriptorPool(vkDevice, pkeDebugHitbox.vkDescriptorPool, vkAllocator);
-		pk_delete<VkDescriptorSet>(pkeDebugHitbox.vkDescriptorSets, prevSwapchainLength);
+		pk_delete<VkDescriptorSet>(pkeDebugHitbox.vkDescriptorSets, prevSwapchainLength, MemBkt_Vulkan);
+		pkeDebugHitbox.vkDescriptorPool = VK_NULL_HANDLE;
 		pkeDebugHitbox.vkDescriptorSets = nullptr;
 	}
 }
 
 void CreateDebugDescriptors() {
+	assert(pkeDebugHitbox.vkDescriptorPool == VK_NULL_HANDLE);
+	assert(pkeDebugHitbox.vkDescriptorSets == nullptr || pkeDebugHitbox.vkDescriptorSets == CAFE_BABE(VkDescriptorSet));
+
 	// descriptor pool & sets
 	VkDescriptorPoolSize descriptorPoolSizes[2];
 	descriptorPoolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
@@ -2983,7 +2979,7 @@ void CreateDebugDescriptors() {
 	auto vkResult = vkCreateDescriptorPool(vkDevice, &vkDescriptorPoolCreateInfo, vkAllocator, &pkeDebugHitbox.vkDescriptorPool);
 	assert(vkResult == VK_SUCCESS);
 
-	VkDescriptorSetLayout *descriptorSets = pk_new<VkDescriptorSetLayout>(swapchainLength);
+	VkDescriptorSetLayout *descriptorSets = pk_new<VkDescriptorSetLayout>(swapchainLength, pkeSettings.mem.bkt);
 	for (long i = 0; i < swapchainLength; ++i) {
 		descriptorSets[i] = pkePipelines.descr_layouts.named.ubo_txtr;
 	}
@@ -2994,18 +2990,17 @@ void CreateDebugDescriptors() {
 	vkDescriptorSetAllocateInfo.descriptorSetCount = swapchainLength;
 	vkDescriptorSetAllocateInfo.pSetLayouts = descriptorSets;
 
-	pkeDebugHitbox.vkDescriptorSets = pk_new<VkDescriptorSet>(swapchainLength);
+	pkeDebugHitbox.vkDescriptorSets = pk_new<VkDescriptorSet>(swapchainLength, MemBkt_Vulkan);
 	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);
 }
 
 void UpdateDebugDescriptors() {
-	VkWriteDescriptorSet *writeDescriptorSets = pk_new<VkWriteDescriptorSet>(2 * swapchainLength);
+	VkWriteDescriptorSet *writeDescriptorSets = pk_new<VkWriteDescriptorSet>(2 * swapchainLength, pkeSettings.mem.bkt);
 	for (long i = 0; i < 2 * swapchainLength; ++i) {
 		writeDescriptorSets[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 		writeDescriptorSets[i].pNext = nullptr;
@@ -3025,7 +3020,7 @@ void UpdateDebugDescriptors() {
 	textureDescriptorInfo.imageView = pkeDebugHitbox.vkImageView;
 	textureDescriptorInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
-	VkDescriptorBufferInfo *vkDescriptorBufferInfo = pk_new<VkDescriptorBufferInfo>(swapchainLength);
+	VkDescriptorBufferInfo *vkDescriptorBufferInfo = pk_new<VkDescriptorBufferInfo>(swapchainLength, pkeSettings.mem.bkt);
 
 	for (long i = 0; i < swapchainLength; ++i) {
 		vkDescriptorBufferInfo[i].buffer = UniformBuffers[i];
@@ -3043,8 +3038,6 @@ void UpdateDebugDescriptors() {
 	}
 
 	vkUpdateDescriptorSets(vkDevice, 2 * swapchainLength, writeDescriptorSets, 0, nullptr);
-	pk_delete<VkWriteDescriptorSet>(writeDescriptorSets, 2 * swapchainLength);
-	pk_delete<VkDescriptorBufferInfo>(vkDescriptorBufferInfo, swapchainLength);
 }
 
 void CreateImGui() {
@@ -3393,21 +3386,21 @@ void DestroySwapchain() {
 		for (long i = 0; i < swapchainLength; ++i) {
 			vkDestroyFramebuffer(vkDevice, pkvk_2d.framebuffers[i], vkAllocator);
 		}
-		pk_delete<VkFramebuffer>(pkvk_2d.framebuffers, swapchainLength);
+		pk_delete<VkFramebuffer>(pkvk_2d.framebuffers, swapchainLength, MemBkt_Vulkan);
 		pkvk_2d.framebuffers = CAFE_BABE(VkFramebuffer);
 	}
 	if (pkvk_3d.framebuffers != nullptr && pkvk_3d.framebuffers != CAFE_BABE(VkFramebuffer)) {
 		for (long i = 0; i < swapchainLength; ++i) {
 			vkDestroyFramebuffer(vkDevice, pkvk_3d.framebuffers[i], vkAllocator);
 		}
-		pk_delete<VkFramebuffer>(pkvk_3d.framebuffers, swapchainLength);
+		pk_delete<VkFramebuffer>(pkvk_3d.framebuffers, swapchainLength, MemBkt_Vulkan);
 		pkvk_3d.framebuffers = CAFE_BABE(VkFramebuffer);
 	}
 	if (pkvk_present.framebuffers != nullptr && pkvk_present.framebuffers != CAFE_BABE(VkFramebuffer)) {
 		for (long i = 0; i < swapchainLength; ++i) {
 			vkDestroyFramebuffer(vkDevice, pkvk_present.framebuffers[i], vkAllocator);
 		}
-		pk_delete<VkFramebuffer>(pkvk_present.framebuffers, swapchainLength);
+		pk_delete<VkFramebuffer>(pkvk_present.framebuffers, swapchainLength, MemBkt_Vulkan);
 		pkvk_present.framebuffers = CAFE_BABE(VkFramebuffer);
 	}
 	if (depthImageViews != nullptr && depthImageViews != CAFE_BABE(VkImageView)) {
@@ -3415,9 +3408,9 @@ void DestroySwapchain() {
 			vkDestroyImageView(vkDevice, depthImageViews[i], vkAllocator);
 			vkDestroyImage(vkDevice, depthImages[i], vkAllocator);
 		}
-		pk_delete<VkImageView>(depthImageViews, swapchainLength);
+		pk_delete<VkImageView>(depthImageViews, swapchainLength, MemBkt_Vulkan);
 		depthImageViews = CAFE_BABE(VkImageView);
-		pk_delete<VkImage>(depthImages, swapchainLength);
+		pk_delete<VkImage>(depthImages, swapchainLength, MemBkt_Vulkan);
 		depthImages = CAFE_BABE(VkImage);
 		vkFreeMemory(vkDevice, depthImagesMemory, vkAllocator);
 	}
@@ -3426,9 +3419,9 @@ void DestroySwapchain() {
 			vkDestroyImageView(vkDevice, pkvk_2d.image_views[i], vkAllocator);
 			vkDestroyImage(vkDevice, pkvk_2d.images[i], vkAllocator);
 		}
-		pk_delete<VkImageView>(pkvk_2d.image_views, swapchainLength);
+		pk_delete<VkImageView>(pkvk_2d.image_views, swapchainLength, MemBkt_Vulkan);
 		pkvk_2d.image_views = CAFE_BABE(VkImageView);
-		pk_delete<VkImage>(pkvk_2d.images, swapchainLength);
+		pk_delete<VkImage>(pkvk_2d.images, swapchainLength, MemBkt_Vulkan);
 		pkvk_2d.images = CAFE_BABE(VkImage);
 		vkFreeMemory(vkDevice, pkvk_2d.images_memory, vkAllocator);
 	}
@@ -3437,9 +3430,9 @@ void DestroySwapchain() {
 			vkDestroyImageView(vkDevice, pkvk_2d.image_views_color_resolve[i], vkAllocator);
 			vkDestroyImage(vkDevice, pkvk_2d.images_color_resolve[i], vkAllocator);
 		}
-		pk_delete<VkImageView>(pkvk_2d.image_views_color_resolve, swapchainLength);
+		pk_delete<VkImageView>(pkvk_2d.image_views_color_resolve, swapchainLength, MemBkt_Vulkan);
 		pkvk_2d.image_views_color_resolve = CAFE_BABE(VkImageView);
-		pk_delete<VkImage>(pkvk_2d.images_color_resolve, swapchainLength);
+		pk_delete<VkImage>(pkvk_2d.images_color_resolve, swapchainLength, MemBkt_Vulkan);
 		pkvk_2d.images_color_resolve = CAFE_BABE(VkImage);
 		vkFreeMemory(vkDevice, pkvk_2d.images_memory_color_resolve, vkAllocator);
 	}
@@ -3448,10 +3441,10 @@ void DestroySwapchain() {
 			vkDestroyImageView(vkDevice, pkvk_3d.image_views_color_resolve[i], vkAllocator);
 			vkDestroyImage(vkDevice, pkvk_3d.images_color_resolve[i], vkAllocator);
 		}
-		pk_delete<VkImageView>(pkvk_3d.image_views_color_resolve, swapchainLength);
+		pk_delete<VkImageView>(pkvk_3d.image_views_color_resolve, swapchainLength, MemBkt_Vulkan);
 		pkvk_3d.image_views_color_resolve = CAFE_BABE(VkImageView);
 		vkFreeMemory(vkDevice, pkvk_3d.images_memory_color_resolve, vkAllocator);
-		pk_delete<VkImage>(pkvk_3d.images_color_resolve, swapchainLength);
+		pk_delete<VkImage>(pkvk_3d.images_color_resolve, swapchainLength, MemBkt_Vulkan);
 		pkvk_3d.images_color_resolve = CAFE_BABE(VkImage);
 	}
 	if (pkvk_3d.image_views != nullptr && pkvk_3d.image_views != CAFE_BABE(VkImageView)) {
@@ -3459,9 +3452,9 @@ void DestroySwapchain() {
 			vkDestroyImageView(vkDevice, pkvk_3d.image_views[i], vkAllocator);
 			vkDestroyImage(vkDevice, pkvk_3d.render_images[i], vkAllocator);
 		}
-		pk_delete<VkImageView>(pkvk_3d.image_views, swapchainLength);
+		pk_delete<VkImageView>(pkvk_3d.image_views, swapchainLength, MemBkt_Vulkan);
 		pkvk_3d.image_views = CAFE_BABE(VkImageView);
-		pk_delete<VkImage>(pkvk_3d.render_images, swapchainLength);
+		pk_delete<VkImage>(pkvk_3d.render_images, swapchainLength, MemBkt_Vulkan);
 		pkvk_3d.render_images = CAFE_BABE(VkImage);
 		vkFreeMemory(vkDevice, pkvk_3d.images_memory, vkAllocator);
 	}
@@ -3469,9 +3462,9 @@ void DestroySwapchain() {
 		for (long i = 0; i < swapchainLength; ++i) {
 			vkDestroyImageView(vkDevice, pkvk_present.image_views[i], vkAllocator);
 		}
-		pk_delete<VkImageView>(pkvk_present.image_views, swapchainLength);
+		pk_delete<VkImageView>(pkvk_present.image_views, swapchainLength, MemBkt_Vulkan);
 		pkvk_present.image_views = CAFE_BABE(VkImageView);
-		pk_delete<VkImage>(pkvk_present.images, swapchainLength);
+		pk_delete<VkImage>(pkvk_present.images, swapchainLength, MemBkt_Vulkan);
 		pkvk_present.images = CAFE_BABE(VkImage);
 		// no memory free for present because they are managed by the swapchain
 	}
@@ -3657,10 +3650,19 @@ void DestroyWindow() {
 		vkDestroyDebugReportCallbackEXT(vkInstance, vkDebugReport, vkAllocator);
 	}
 	vkDestroyInstance(vkInstance, vkAllocator);
+	pk_delete<VkAllocationCallbacks>(vkAllocator, MemBkt_Vulkan);
+	vkAllocator = CAFE_BABE(VkAllocationCallbacks);
 	glfwDestroyWindow(window);
 	glfwTerminate();
 
+	if (vulkanAllocs->Count() > 0) {
+		fprintf(stderr, "VkAllocator has '%ld' outstanding allocations!", vulkanAllocs->Count());
+	}
 	vulkanAllocs->~DynArray();
+	pk_delete<DynArray<pke_vkAllocData>>(vulkanAllocs, MemBkt_Vulkan);
+	vulkanAllocs = CAFE_BABE(DynArray<pke_vkAllocData>);
+	// TODO there's un-freed vulkan stuff in the bucket
+	// comment this out to see it in the debug printout
 	pk_bucket_destroy(MemBkt_Vulkan);
 }