pke: refactor: reduce image resource var ambiguity

1 files changed, 452 insertions, 380 deletions

diff --git a/src/window.cpp b/src/window.cpp
index 19f2695..923ff99 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -43,9 +43,7 @@ VkPhysicalDevice vkPhysicalDevice = nullptr;
 VkPhysicalDeviceProperties vkPhysicalDeviceProperties;
 VkPhysicalDeviceMemoryProperties vkPhysicalDeviceMemoryProperties;
 VkDevice vkDevice = nullptr;
-VkQueue graphicsQueue = nullptr;
 VkQueue presentQueue = nullptr;
-VkQueue transferQueue = nullptr;
 VkSurfaceKHR vkSurfaceKHR = nullptr;
 VkDebugReportCallbackEXT vkDebugReport = nullptr;
 VkAllocationCallbacks vkAllocatorStruct = {};
@@ -66,41 +64,77 @@ VkSurfaceFormatKHR vkSurfaceFormatKHR;
 VkFormat depthFormat;
 VkPresentModeKHR vkPresentModeKHR = VK_PRESENT_MODE_FIFO_KHR;
 VkExtent2D Extent;
-VkImage *swapchainImages = nullptr;
-VkImageView *swapchainImageViews = nullptr;
-VkImage *renderImages = nullptr;
-VkImageView *renderImageViews = nullptr;
-VkDeviceMemory renderImagesMemory;
-VkImage *colorImages = nullptr;
-VkImageView *colorImageViews = nullptr;
-VkDeviceMemory colorImagesMemory;
+VkSampler global_sampler;
+VkSampleCountFlagBits global_sample_count;
+
+// pkvk_shared.descr_set_layout.single_sampler
+// 	the pke default, works for:
+// 	2025-01-28 - present
+// 	2025-01-28 - standard 3d
+struct PKVK_Shared {
+	struct PKVK_Shared_Command_Pool {
+		VkCommandPool transfer;
+		VkCommandPool graphics;
+	} command_pool;
+	struct PKVK_Shared_Command_Buffer {
+		VkCommandBuffer transfer;
+		VkCommandBuffer graphics;
+	} command_buffer;
+	struct PKVK_Shared_Queue {
+		VkQueue transfer;
+		VkQueue graphics;
+	} queue;
+} pkvk_shared;
+
+struct PKVK_Present {
+	VkDescriptorSetLayout descriptor_set_layout;
+	VkPipelineLayout pipeline_layout;
+	VkPipeline pipeline;
+	VkRenderPass render_pass;
+	VkDescriptorPool descriptor_pool;
+	VkDescriptorSet *descriptor_sets;
+	VkCommandBuffer *command_buffers;
+	VkSemaphore *semaphores_image_available;
+	VkSemaphore *semaphores_render_finished;
+	VkFence *fences_in_flight;
+	VkImage *images;
+	VkImageView *image_views;
+	VkFramebuffer *framebuffers;
+} pkvk_present;
+
+// TODO consider creating a depth pre-pass
+// 2025-01-29 JCB
+// 	I know this is a popular thing to do, but I want to avoid it until we
+// 	actually need it.
+// 	Unsure how we would want to handle 2d - we could either intentionally
+// 	go for painter's method, or maybe there's a good way to declare depth
+// 	in 2d that I am not thinking of at the moment.
 VkImage *depthImages = nullptr;
 VkImageView *depthImageViews = nullptr;
 VkDeviceMemory depthImagesMemory;
-VkImage *d2OverlayImages = nullptr;
-VkImageView *d2OverlayImageViews = nullptr;
-VkDeviceMemory d2OverlayImagesMemory;
-VkSampler presentSampler;
-VkSampleCountFlagBits renderSampleCount;
-VkRenderPass presentRenderPass;
-VkRenderPass renderRenderPass;
-VkRenderPass d2OverlayRenderPass;
-VkDescriptorSetLayout vkDescriptorSetLayout;
-VkDescriptorPool presentDescriptorPool;
-VkDescriptorSet *presentDescriptorSets;
-VkPipelineLayout pipelineLayout;
-VkPipeline graphicsPipeline;
-VkFramebuffer *swapchainFramebuffers = nullptr;
-VkFramebuffer *renderImageFramebuffers = nullptr;
-VkFramebuffer *d2OverlayImageFramebuffers = nullptr;
-VkCommandPool transferCommandPool;
-VkCommandBuffer transferCommandBuffer;
-VkCommandPool graphicsCommandPool;
-VkCommandBuffer graphicsCommandBuffer;
-VkCommandBuffer *presentCommandBuffers;
-VkSemaphore *presentImageAvailableSemaphores;
-VkSemaphore *presentRenderFinishedSemaphores;
-VkFence *presentInFlightFences;
+
+struct PKVK_3D {
+	VkRenderPass render_pass;
+	VkFramebuffer *framebuffers = nullptr;
+	VkDeviceMemory images_memory;
+	VkImageView *image_views = nullptr;
+	VkImage *render_images = nullptr;
+	VkImage *images_color_resolve = nullptr;
+	VkImageView *image_views_color_resolve = nullptr;
+	VkDeviceMemory images_memory_color_resolve;
+} pkvk_3d;
+
+struct PKVK_2D {
+	VkRenderPass render_pass;
+	VkFramebuffer *framebuffers = nullptr;
+	VkImage *images = nullptr;
+	VkImageView *image_views = nullptr;
+	VkDeviceMemory images_memory;
+	VkImage *images_color_resolve = nullptr;
+	VkImageView *image_views_color_resolve = nullptr;
+	VkDeviceMemory images_memory_color_resolve;
+} pkvk_2d;
+
 UniformBufferObject UBO{
 	.model = glm::mat4(1),
 	.view = glm::lookAt(glm::vec3(0), glm::vec3(2, 2, 0), glm::vec3(0, 1, 0)),
@@ -179,7 +213,27 @@ VkFormat FindSupportedFormat(long candidateCount, const VkFormat *candidates, Vk
 	return VkFormat(0);
 }
 
-void BeginTransferBuffer(VkDeviceSize requestedMemorySize, VkBuffer &buffer, VkDeviceMemory &deviceMemory, void *&deviceData) {
+VkCommandBuffer GetCommandBuffer_Graphics() {
+	return pkvk_shared.command_buffer.graphics;
+}
+
+VkCommandBuffer GetCommandBuffer_Transfer() {
+	return pkvk_shared.command_buffer.transfer;
+}
+
+void PKVK_BeginBuffer(unsigned int family_index, VkDeviceSize requestedMemorySize, PKVK_TmpBufferDetails &tmpBufferDetails) {
+	if (family_index == graphicsFamilyIndex) {
+		tmpBufferDetails.queue = pkvk_shared.queue.graphics;
+		tmpBufferDetails.cmdBuffer = pkvk_shared.command_buffer.graphics;
+	} else if (family_index == transferFamilyIndex) {
+		tmpBufferDetails.queue = pkvk_shared.queue.transfer;
+		tmpBufferDetails.cmdBuffer = pkvk_shared.command_buffer.transfer;
+	} else {
+		throw "Unhandled queue family";
+	}
+
+	if (requestedMemorySize == 0) return;
+
 	VkBufferCreateInfo transferBufferCI;
 	transferBufferCI.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
 	transferBufferCI.pNext = nullptr;
@@ -188,31 +242,32 @@ void BeginTransferBuffer(VkDeviceSize requestedMemorySize, VkBuffer &buffer, VkD
 	transferBufferCI.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
 	transferBufferCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 	transferBufferCI.queueFamilyIndexCount = 1;
-	transferBufferCI.pQueueFamilyIndices = &transferFamilyIndex;
-	VkResult vkResult = vkCreateBuffer(vkDevice, &transferBufferCI, vkAllocator, &buffer);
+	transferBufferCI.pQueueFamilyIndices = &family_index;
+	VkResult vkResult = vkCreateBuffer(vkDevice, &transferBufferCI, vkAllocator, &tmpBufferDetails.buffer);
 	assert(vkResult == VK_SUCCESS);
 
 	VkMemoryRequirements memoryRequirements;
-	vkGetBufferMemoryRequirements(vkDevice, buffer, &memoryRequirements);
+	vkGetBufferMemoryRequirements(vkDevice, tmpBufferDetails.buffer, &memoryRequirements);
 
 	VkMemoryAllocateInfo transferMemAllocInfo;
 	transferMemAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
 	transferMemAllocInfo.pNext = nullptr;
 	transferMemAllocInfo.allocationSize = memoryRequirements.size;
 	transferMemAllocInfo.memoryTypeIndex = FindMemoryTypeIndex(memoryRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
-	vkResult = vkAllocateMemory(vkDevice, &transferMemAllocInfo, vkAllocator, &deviceMemory);
+	vkResult = vkAllocateMemory(vkDevice, &transferMemAllocInfo, vkAllocator, &tmpBufferDetails.deviceMemory);
 	assert(vkResult == VK_SUCCESS);
 
-	vkResult = vkBindBufferMemory(vkDevice, buffer, deviceMemory, 0);
+	vkResult = vkBindBufferMemory(vkDevice, tmpBufferDetails.buffer, tmpBufferDetails.deviceMemory, 0);
 	assert(vkResult == VK_SUCCESS);
-	vkResult = vkMapMemory(vkDevice, deviceMemory, 0, transferMemAllocInfo.allocationSize, 0, &deviceData);
+	vkResult = vkMapMemory(vkDevice, tmpBufferDetails.deviceMemory, 0, transferMemAllocInfo.allocationSize, 0, &tmpBufferDetails.deviceData);
 	assert(vkResult == VK_SUCCESS);
 }
 
-void EndTransferBuffer(VkBuffer &buffer, VkDeviceMemory &deviceMemory) {
-	vkUnmapMemory(vkDevice, deviceMemory);
-	vkDestroyBuffer(vkDevice, buffer, vkAllocator);
-	vkFreeMemory(vkDevice, deviceMemory, vkAllocator);
+void PKVK_EndBuffer(PKVK_TmpBufferDetails &tmpBufferDetails) {
+	if (tmpBufferDetails.deviceMemory != VK_NULL_HANDLE) vkUnmapMemory(vkDevice, tmpBufferDetails.deviceMemory);
+	if (tmpBufferDetails.buffer != VK_NULL_HANDLE) vkDestroyBuffer(vkDevice, tmpBufferDetails.buffer, vkAllocator);
+	if (tmpBufferDetails.deviceMemory != VK_NULL_HANDLE) vkFreeMemory(vkDevice, tmpBufferDetails.deviceMemory, vkAllocator);
+	tmpBufferDetails = {};
 }
 
 unsigned int FindQueueFamilyIndex(VkPhysicalDevice device, char hasPresentSupport = -1, VkQueueFlagBits includeBits = (VkQueueFlagBits)0U, VkQueueFlagBits excludeBits = (VkQueueFlagBits)0U) {
@@ -603,9 +658,9 @@ void InitVulkan() {
 
 	// queues
 	{
-		vkGetDeviceQueue(vkDevice, graphicsFamilyIndex, 0, &graphicsQueue);
+		vkGetDeviceQueue(vkDevice, graphicsFamilyIndex, 0, &pkvk_shared.queue.graphics);
 		vkGetDeviceQueue(vkDevice, presentFamilyIndex, 0, &presentQueue);
-		vkGetDeviceQueue(vkDevice, transferFamilyIndex, 0, &transferQueue);
+		vkGetDeviceQueue(vkDevice, transferFamilyIndex, 0, &pkvk_shared.queue.transfer);
 	}
 
 	// surface formats
@@ -623,17 +678,17 @@ void InitVulkan() {
 		VkSampleCountFlags counts = vkPhysicalDeviceProperties.limits.framebufferColorSampleCounts & vkPhysicalDeviceProperties.limits.framebufferDepthSampleCounts;
 
 		if (counts & VK_SAMPLE_COUNT_64_BIT) {
-			renderSampleCount = VK_SAMPLE_COUNT_64_BIT;
+			global_sample_count = VK_SAMPLE_COUNT_64_BIT;
 		} else if (counts & VK_SAMPLE_COUNT_32_BIT) {
-			renderSampleCount = VK_SAMPLE_COUNT_32_BIT;
+			global_sample_count = VK_SAMPLE_COUNT_32_BIT;
 		} else if (counts & VK_SAMPLE_COUNT_16_BIT) {
-			renderSampleCount = VK_SAMPLE_COUNT_16_BIT;
+			global_sample_count = VK_SAMPLE_COUNT_16_BIT;
 		} else if (counts & VK_SAMPLE_COUNT_8_BIT) {
-			renderSampleCount = VK_SAMPLE_COUNT_8_BIT;
+			global_sample_count = VK_SAMPLE_COUNT_8_BIT;
 		} else if (counts & VK_SAMPLE_COUNT_4_BIT) {
-			renderSampleCount = VK_SAMPLE_COUNT_4_BIT;
+			global_sample_count = VK_SAMPLE_COUNT_4_BIT;
 		} else if (counts & VK_SAMPLE_COUNT_2_BIT) {
-			renderSampleCount = VK_SAMPLE_COUNT_2_BIT;
+			global_sample_count = VK_SAMPLE_COUNT_2_BIT;
 		}
 	}
 
@@ -658,7 +713,7 @@ void InitVulkan() {
 	samplerCreateInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
 	samplerCreateInfo.unnormalizedCoordinates = {};
 
-	vkResult = vkCreateSampler(vkDevice, &samplerCreateInfo, vkAllocator, &presentSampler);
+	vkResult = vkCreateSampler(vkDevice, &samplerCreateInfo, vkAllocator, &global_sampler);
 	assert(vkResult == VK_SUCCESS);
 }
 
@@ -838,26 +893,28 @@ void CreateSwapchain() {
 	};
 	vkImageViewCreateInfo.subresourceRange = vkImageSubresourceRange;
 
-	assert(swapchainImages == nullptr || swapchainImages == CAFE_BABE(VkImage));
-	assert(swapchainImageViews == nullptr || swapchainImageViews == CAFE_BABE(VkImageView));
-	assert(renderImages == nullptr || renderImages == CAFE_BABE(VkImage));
-	assert(renderImageViews == nullptr || renderImageViews == CAFE_BABE(VkImageView));
-	assert(colorImages == nullptr || colorImages == CAFE_BABE(VkImage));
-	assert(colorImageViews == nullptr || colorImageViews == CAFE_BABE(VkImageView));
+	assert(pkvk_present.images == nullptr || pkvk_present.images == CAFE_BABE(VkImage));
+	assert(pkvk_present.image_views == nullptr || pkvk_present.image_views == CAFE_BABE(VkImageView));
+	assert(pkvk_3d.render_images == nullptr || pkvk_3d.render_images == CAFE_BABE(VkImage));
+	assert(pkvk_3d.image_views == nullptr || pkvk_3d.image_views == CAFE_BABE(VkImageView));
+	assert(pkvk_3d.images_color_resolve == nullptr || pkvk_3d.images_color_resolve == CAFE_BABE(VkImage));
+	assert(pkvk_3d.image_views_color_resolve == nullptr || pkvk_3d.image_views_color_resolve == CAFE_BABE(VkImageView));
 	assert(depthImages == nullptr || depthImages == CAFE_BABE(VkImage));
 	assert(depthImageViews == nullptr || depthImageViews == CAFE_BABE(VkImageView));
-	assert(d2OverlayImages == nullptr || d2OverlayImages == CAFE_BABE(VkImage));
-	assert(d2OverlayImageViews == nullptr || d2OverlayImageViews == CAFE_BABE(VkImageView));
+	assert(pkvk_2d.images == nullptr || pkvk_2d.images == CAFE_BABE(VkImage));
+	assert(pkvk_2d.image_views == nullptr || pkvk_2d.image_views == CAFE_BABE(VkImageView));
+	assert(pkvk_2d.images_color_resolve == nullptr || pkvk_2d.images_color_resolve == CAFE_BABE(VkImage));
+	assert(pkvk_2d.image_views_color_resolve == nullptr || pkvk_2d.image_views_color_resolve == CAFE_BABE(VkImageView));
 
 	vkResult = vkGetSwapchainImagesKHR(vkDevice, vkSwapchainKHR, &swapchainLength, nullptr);
 	assert(vkResult == VK_SUCCESS);
-	swapchainImages = pk_new<VkImage>(swapchainLength);
-	vkResult = vkGetSwapchainImagesKHR(vkDevice, vkSwapchainKHR, &swapchainLength, swapchainImages);
+	pkvk_present.images = pk_new<VkImage>(swapchainLength);
+	vkResult = vkGetSwapchainImagesKHR(vkDevice, vkSwapchainKHR, &swapchainLength, pkvk_present.images);
 	assert(vkResult == VK_SUCCESS);
-	swapchainImageViews = pk_new<VkImageView>(swapchainLength);
+	pkvk_present.image_views = pk_new<VkImageView>(swapchainLength);
 	for (long i = 0; i < swapchainLength; ++i) {
-		vkImageViewCreateInfo.image = swapchainImages[i];
-		vkResult = vkCreateImageView(vkDevice, &vkImageViewCreateInfo, vkAllocator, &swapchainImageViews[i]);
+		vkImageViewCreateInfo.image = pkvk_present.images[i];
+		vkResult = vkCreateImageView(vkDevice, &vkImageViewCreateInfo, vkAllocator, &pkvk_present.image_views[i]);
 		assert(vkResult == VK_SUCCESS);
 	}
 
@@ -873,7 +930,7 @@ void CreateSwapchain() {
 	renderTargetImageCI.extent.depth = 1;
 	renderTargetImageCI.mipLevels = 1;
 	renderTargetImageCI.arrayLayers = 1;
-	renderTargetImageCI.samples = VK_SAMPLE_COUNT_1_BIT;
+	renderTargetImageCI.samples = global_sample_count;
 	renderTargetImageCI.tiling = VK_IMAGE_TILING_OPTIMAL;
 	renderTargetImageCI.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT |
 		VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
@@ -882,30 +939,40 @@ void CreateSwapchain() {
 	renderTargetImageCI.pQueueFamilyIndices = nullptr;
 	renderTargetImageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
-	// render images
-	renderImages = pk_new<VkImage>(swapchainLength);
-	renderImageViews = pk_new<VkImageView>(swapchainLength);
-	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, renderImages, renderImageViews, &renderImagesMemory);
+	// 3d color (fragment) images
+	pkvk_3d.render_images = pk_new<VkImage>(swapchainLength);
+	pkvk_3d.image_views = pk_new<VkImageView>(swapchainLength);
+	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, pkvk_3d.render_images, pkvk_3d.image_views, &pkvk_3d.images_memory);
 
-	// color images
-	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 color (fragment) images
+	pkvk_2d.images = pk_new<VkImage>(swapchainLength);
+	pkvk_2d.image_views = pk_new<VkImageView>(swapchainLength);
+	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, pkvk_2d.images, pkvk_2d.image_views, &pkvk_2d.images_memory);
 
-	// 2d overlay images
-	d2OverlayImages = pk_new<VkImage>(swapchainLength);
-	d2OverlayImageViews = pk_new<VkImageView>(swapchainLength);
-	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, d2OverlayImages, d2OverlayImageViews, &d2OverlayImagesMemory);
+	// resolve settings
+	renderTargetImageCI.samples = VK_SAMPLE_COUNT_1_BIT;
+	renderTargetImageCI.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
 
-	// depth images
-	depthImages = pk_new<VkImage>(swapchainLength);
-	depthImageViews = pk_new<VkImageView>(swapchainLength);
+	// 3d color (resolve)
+	pkvk_3d.images_color_resolve = pk_new<VkImage>(swapchainLength);
+	pkvk_3d.image_views_color_resolve = pk_new<VkImageView>(swapchainLength);
+	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);
+	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
+	renderTargetImageCI.samples = global_sample_count;
 	renderTargetImageCI.format = depthFormat;
-	vkImageViewCreateInfo.format = depthFormat;
 	renderTargetImageCI.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+	vkImageViewCreateInfo.format = depthFormat;
 	vkImageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+
+	// depth images
+	depthImages = pk_new<VkImage>(swapchainLength);
+	depthImageViews = pk_new<VkImageView>(swapchainLength);
 	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, depthImages, depthImageViews, &depthImagesMemory);
 }
 
@@ -922,11 +989,11 @@ void UpdatePresentDescriptorSets() {
 		writeDescriptorSets[i].pBufferInfo = nullptr;
 		writeDescriptorSets[i].pTexelBufferView = nullptr;
 		descriptorImageInfo[i].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-		descriptorImageInfo[i].sampler = presentSampler;
+		descriptorImageInfo[i].sampler = global_sampler;
 
-		descriptorImageInfo[i].imageView = renderImageViews[i];
+		descriptorImageInfo[i].imageView = pkvk_3d.image_views_color_resolve[i];
 		writeDescriptorSets[i].pImageInfo = &descriptorImageInfo[i];
-		writeDescriptorSets[i].dstSet = presentDescriptorSets[i];
+		writeDescriptorSets[i].dstSet = pkvk_present.descriptor_sets[i];
 	}
 
 	vkUpdateDescriptorSets(vkDevice, swapchainLength, writeDescriptorSets, 0, nullptr);
@@ -979,20 +1046,43 @@ void UpdateCamera() {
 }
 
 void CreateRenderPass() {
-	VkAttachmentDescription colorAttachment;
-	colorAttachment.flags = {};
-	colorAttachment.format = vkSurfaceFormatKHR.format;
-	colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
-	colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
-	colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-	colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-	colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-	colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-	colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
-
-	VkAttachmentReference colorAttachmentRef;
-	colorAttachmentRef.attachment = 0;
-	colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+	/* 2025-01-29 JCB
+	 * I refactored this so that VkAttachmentDescription was an array and that
+	 *  wasn't totally necessary. It does have the advantage of 1:1-ing with the
+	 *  VkAttachmentReference, but it means you have to just know what each index
+	 *  is. Here's a legend since the code is no longer self-documenting.
+	 *  0: render target (fragment)
+	 *  1: color resolve (multisampling)
+	 *  2: depth
+	 * See also: CreateFramebuffers(): the same ordering can be observed.
+	 */
+	VkAttachmentDescription attachment_descriptions[3];
+	memset(attachment_descriptions, 0, sizeof(VkAttachmentDescription) * 3);
+	VkAttachmentReference attachment_refs[3];;
+	memset(attachment_refs, 0, sizeof(VkAttachmentReference) * 3);
+	VkSubpassDependency subpass_dependencies[2];
+	memset(subpass_dependencies, 0, sizeof(VkSubpassDependency) * 2);
+
+	for (long i = 0; i < 3; ++i) {
+		attachment_refs[i].attachment = i;
+	}
+	for (long i = 0; i < 2; ++i) {
+		subpass_dependencies[i].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
+	}
+
+	// color (fragment)
+	attachment_descriptions[0].flags = {};
+	attachment_descriptions[0].format = vkSurfaceFormatKHR.format;
+	attachment_descriptions[0].samples = VK_SAMPLE_COUNT_1_BIT;
+	attachment_descriptions[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+	attachment_descriptions[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+	attachment_descriptions[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+	attachment_descriptions[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+	attachment_descriptions[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+	attachment_descriptions[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+
+	// color (fragment)
+	attachment_refs[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
 	VkSubpassDescription subpass;
 	subpass.flags = {};
@@ -1000,135 +1090,102 @@ void CreateRenderPass() {
 	subpass.inputAttachmentCount = 0;
 	subpass.pInputAttachments = nullptr;
 	subpass.colorAttachmentCount = 1;
-	subpass.pColorAttachments = &colorAttachmentRef;
+	subpass.pColorAttachments = &attachment_refs[0];
 	subpass.pResolveAttachments = nullptr;
 	subpass.pDepthStencilAttachment = nullptr;
 	subpass.preserveAttachmentCount = 0;
 	subpass.pPreserveAttachments = nullptr;
 
-	VkSubpassDependency subpassDependencies[2];
-	for (long i = 0; i < 2; ++i) {
-		subpassDependencies[i].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
-	}
-
-	subpassDependencies[0].srcSubpass = VK_SUBPASS_EXTERNAL;
-	subpassDependencies[0].dstSubpass = 0U;
-	subpassDependencies[0].srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
-	subpassDependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-	subpassDependencies[0].srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
-	subpassDependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+	subpass_dependencies[0].srcSubpass = VK_SUBPASS_EXTERNAL;
+	subpass_dependencies[0].dstSubpass = 0U;
+	subpass_dependencies[0].srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+	subpass_dependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+	subpass_dependencies[0].srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
+	subpass_dependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 
-	subpassDependencies[1].srcSubpass = 0U;
-	subpassDependencies[1].dstSubpass = VK_SUBPASS_EXTERNAL;
-	subpassDependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-	subpassDependencies[1].dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
-	subpassDependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-	subpassDependencies[1].dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
+	subpass_dependencies[1].srcSubpass = 0U;
+	subpass_dependencies[1].dstSubpass = VK_SUBPASS_EXTERNAL;
+	subpass_dependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+	subpass_dependencies[1].dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+	subpass_dependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+	subpass_dependencies[1].dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
 
 	VkRenderPassCreateInfo renderPassInfo;
 	renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
 	renderPassInfo.pNext = nullptr;
 	renderPassInfo.flags = {};
 	renderPassInfo.attachmentCount = 1;
-	renderPassInfo.pAttachments = &colorAttachment;
+	renderPassInfo.pAttachments = &attachment_descriptions[0];
 	renderPassInfo.subpassCount = 1;
 	renderPassInfo.pSubpasses = &subpass;
 	renderPassInfo.dependencyCount = 2;
-	renderPassInfo.pDependencies = subpassDependencies;
+	renderPassInfo.pDependencies = subpass_dependencies;
 
-	if (vkCreateRenderPass(vkDevice, &renderPassInfo, vkAllocator, &presentRenderPass) != VK_SUCCESS) {
+	if (vkCreateRenderPass(vkDevice, &renderPassInfo, vkAllocator, &pkvk_present.render_pass) != VK_SUCCESS) {
 		throw "failed to create present render pass!";
 	}
 
-	colorAttachment.samples = renderSampleCount;
-	colorAttachment.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+	// color resolve
+	attachment_refs[1].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+	subpass.pResolveAttachments = &attachment_refs[1];
 
-	VkAttachmentDescription colorAttachmentResolve{colorAttachment};
-	colorAttachmentResolve.samples = VK_SAMPLE_COUNT_1_BIT;
-	colorAttachmentResolve.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-	colorAttachmentResolve.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-	colorAttachmentResolve.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+	// color
+	attachment_descriptions[0].samples = global_sample_count;
+	attachment_descriptions[0].finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+	// color resolve
+	attachment_descriptions[1] = attachment_descriptions[0];
+	attachment_descriptions[1].samples = VK_SAMPLE_COUNT_1_BIT;
+	attachment_descriptions[1].loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+	attachment_descriptions[1].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+	attachment_descriptions[1].finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
-	VkAttachmentReference colorAttachmentReseolveRef;
-	colorAttachmentReseolveRef.attachment = 1;
-	colorAttachmentReseolveRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+	subpass_dependencies[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+	subpass_dependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+	subpass_dependencies[0].srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
+	subpass_dependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 
-	subpass.pColorAttachments = &colorAttachmentRef;
-	subpass.pResolveAttachments = &colorAttachmentReseolveRef;
-
-	subpassDependencies[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-	subpassDependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-	subpassDependencies[0].srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
-	subpassDependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-
-	subpassDependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-	subpassDependencies[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-	subpassDependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-	subpassDependencies[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-
-	VkAttachmentDescription d2o_attachments[2] = {
-		colorAttachment, colorAttachmentResolve
-	};
+	subpass_dependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+	subpass_dependencies[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+	subpass_dependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+	subpass_dependencies[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
 
 	renderPassInfo.attachmentCount = 2;
-	renderPassInfo.pAttachments = d2o_attachments;
-	renderPassInfo.dependencyCount = 2;
-	renderPassInfo.pDependencies = subpassDependencies;
 
-	if (vkCreateRenderPass(vkDevice, &renderPassInfo, vkAllocator, &d2OverlayRenderPass) != VK_SUCCESS) {
+	if (vkCreateRenderPass(vkDevice, &renderPassInfo, vkAllocator, &pkvk_2d.render_pass) != VK_SUCCESS) {
 		throw "failed to create render pass!";
 	}
 
-	colorAttachment.samples = renderSampleCount;
-	colorAttachment.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-
-	VkAttachmentDescription depthAttachment;
-	depthAttachment.flags = 0;
-	depthAttachment.format = depthFormat;
-	depthAttachment.samples = renderSampleCount;
-	depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
-	depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-	depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-	depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-	depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-	depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-
-	colorAttachmentResolve.samples = VK_SAMPLE_COUNT_1_BIT;
-	colorAttachmentResolve.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-	colorAttachmentResolve.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-	colorAttachmentResolve.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-
-	VkAttachmentReference depthAttachmentRef;
-	depthAttachmentRef.attachment = 1;
-	depthAttachmentRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-
-	colorAttachmentReseolveRef.attachment = 2;
-	colorAttachmentReseolveRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-
-	subpass.pColorAttachments = &colorAttachmentRef;
-	subpass.pResolveAttachments = &colorAttachmentReseolveRef;
-	subpass.pDepthStencilAttachment = &depthAttachmentRef;
-
-	subpassDependencies[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-	subpassDependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-	subpassDependencies[0].srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
-	subpassDependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-
-	subpassDependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-	subpassDependencies[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-	subpassDependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-	subpassDependencies[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-
-	VkAttachmentDescription attachments[3] = {
-		colorAttachment, depthAttachment, colorAttachmentResolve
-	};
+	// color
+	attachment_descriptions[0].samples = global_sample_count;
+	attachment_descriptions[0].finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+	// depth
+	attachment_descriptions[2] = attachment_descriptions[0];
+	attachment_descriptions[2].format = depthFormat;
+	attachment_descriptions[2].samples = global_sample_count;
+	attachment_descriptions[2].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+	attachment_descriptions[2].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+	attachment_descriptions[2].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+	attachment_descriptions[2].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
+	attachment_descriptions[2].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+	attachment_descriptions[2].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+
+	// depth
+	attachment_refs[2].layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+	subpass.pDepthStencilAttachment = &attachment_refs[2];
+
+	subpass_dependencies[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+	subpass_dependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+	subpass_dependencies[0].srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
+	subpass_dependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+
+	subpass_dependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+	subpass_dependencies[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+	subpass_dependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+	subpass_dependencies[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
 
 	renderPassInfo.attachmentCount = 3;
-	renderPassInfo.pAttachments = attachments;
-	renderPassInfo.dependencyCount = 2;
-	renderPassInfo.pDependencies = subpassDependencies;
 
-	if (vkCreateRenderPass(vkDevice, &renderPassInfo, vkAllocator, &renderRenderPass) != VK_SUCCESS) {
+	if (vkCreateRenderPass(vkDevice, &renderPassInfo, vkAllocator, &pkvk_3d.render_pass) != VK_SUCCESS) {
 		throw "failed to create render pass!";
 	}
 }
@@ -1282,7 +1339,7 @@ void CreatePresentPipeline() {
 	descriptorSetLayoutCreateInfo.bindingCount = 1;
 	descriptorSetLayoutCreateInfo.pBindings = &imageSamplerLayoutBinding;
 
-	auto vkResult = vkCreateDescriptorSetLayout(vkDevice, &descriptorSetLayoutCreateInfo, vkAllocator, &vkDescriptorSetLayout);
+	auto vkResult = vkCreateDescriptorSetLayout(vkDevice, &descriptorSetLayoutCreateInfo, vkAllocator, &pkvk_present.descriptor_set_layout);
 	if (vkResult != VK_SUCCESS) {
 		throw "failed to create descriptor set layout";
 	}
@@ -1299,22 +1356,22 @@ void CreatePresentPipeline() {
 	descriptorPoolCreateInfo.poolSizeCount = 1;
 	descriptorPoolCreateInfo.pPoolSizes = &vkDescriptorPoolSize;
 
-	vkResult = vkCreateDescriptorPool(vkDevice, &descriptorPoolCreateInfo, vkAllocator, &presentDescriptorPool);
+	vkResult = vkCreateDescriptorPool(vkDevice, &descriptorPoolCreateInfo, vkAllocator, &pkvk_present.descriptor_pool);
 	assert(vkResult == VK_SUCCESS);
 
 	VkDescriptorSetLayout *setLayouts = pk_new<VkDescriptorSetLayout>(swapchainLength);
 	for (long i = 0; i < swapchainLength; ++i) {
-		setLayouts[i] = vkDescriptorSetLayout;
+		setLayouts[i] = pkvk_present.descriptor_set_layout;
 	}
 	VkDescriptorSetAllocateInfo allocInfo;
 	allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
 	allocInfo.pNext = nullptr;
-	allocInfo.descriptorPool = presentDescriptorPool;
+	allocInfo.descriptorPool = pkvk_present.descriptor_pool;
 	allocInfo.descriptorSetCount = swapchainLength;
 	allocInfo.pSetLayouts = setLayouts;
 
-	presentDescriptorSets = pk_new<VkDescriptorSet>(swapchainLength, MemBkt_Vulkan);
-	vkResult = vkAllocateDescriptorSets(vkDevice, &allocInfo, presentDescriptorSets);
+	pkvk_present.descriptor_sets = pk_new<VkDescriptorSet>(swapchainLength, MemBkt_Vulkan);
+	vkResult = vkAllocateDescriptorSets(vkDevice, &allocInfo, pkvk_present.descriptor_sets);
 	pk_delete<VkDescriptorSetLayout>(setLayouts, swapchainLength);
 	// setLayouts = CAFE_BABE(VkDescriptorSetLayout);
 	if (vkResult != VK_SUCCESS) {
@@ -1326,11 +1383,11 @@ void CreatePresentPipeline() {
 	pipelineLayoutInfo.pNext = nullptr;
 	pipelineLayoutInfo.flags = {};
 	pipelineLayoutInfo.setLayoutCount = 1;
-	pipelineLayoutInfo.pSetLayouts = &vkDescriptorSetLayout;
+	pipelineLayoutInfo.pSetLayouts = &pkvk_present.descriptor_set_layout;
 	pipelineLayoutInfo.pushConstantRangeCount = 0;
 	pipelineLayoutInfo.pPushConstantRanges = nullptr;
 
-	vkResult = vkCreatePipelineLayout(vkDevice, &pipelineLayoutInfo, vkAllocator, &pipelineLayout);
+	vkResult = vkCreatePipelineLayout(vkDevice, &pipelineLayoutInfo, vkAllocator, &pkvk_present.pipeline_layout);
 	if (vkResult != VK_SUCCESS) {
 		throw "failed to create pipeline layout";
 	}
@@ -1352,8 +1409,8 @@ void CreatePresentPipeline() {
 	pipelineInfo.pColorBlendState = &colorBlending;
 	pipelineInfo.pDynamicState = &dynamicState;
 
-	pipelineInfo.layout = pipelineLayout;
-	pipelineInfo.renderPass = presentRenderPass;
+	pipelineInfo.layout = pkvk_present.pipeline_layout;
+	pipelineInfo.renderPass = pkvk_present.render_pass;
 	pipelineInfo.subpass = 0;
 	pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
 	pipelineInfo.basePipelineIndex = {};
@@ -1367,7 +1424,7 @@ void CreatePresentPipeline() {
 	shaderStages[0].module = vertShader;
 	shaderStages[1].module = fragShader;
 
-	vkResult = vkCreateGraphicsPipelines(vkDevice, VK_NULL_HANDLE, 1, &pipelineInfo, vkAllocator, &graphicsPipeline);
+	vkResult = vkCreateGraphicsPipelines(vkDevice, VK_NULL_HANDLE, 1, &pipelineInfo, vkAllocator, &pkvk_present.pipeline);
 	if (vkResult != VK_SUCCESS) {
 		throw "failed to create graphics pipeline.";
 	}
@@ -1379,18 +1436,18 @@ void CreatePresentPipeline() {
 }
 
 void CreateFramebuffers() {
-	assert(swapchainFramebuffers == nullptr || swapchainFramebuffers == CAFE_BABE(VkFramebuffer));
-	assert(renderImageFramebuffers == nullptr || renderImageFramebuffers == CAFE_BABE(VkFramebuffer));
-	assert(d2OverlayImageFramebuffers == nullptr || d2OverlayImageFramebuffers == CAFE_BABE(VkFramebuffer));
-	swapchainFramebuffers = pk_new<VkFramebuffer>(swapchainLength);
-	renderImageFramebuffers = pk_new<VkFramebuffer>(swapchainLength);
-	d2OverlayImageFramebuffers = pk_new<VkFramebuffer>(swapchainLength);
+	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);
 
 	VkFramebufferCreateInfo framebufferInfo;
 	framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
 	framebufferInfo.pNext = nullptr;
 	framebufferInfo.flags = {};
-	framebufferInfo.renderPass = presentRenderPass;
+	framebufferInfo.renderPass = pkvk_present.render_pass;
 	framebufferInfo.attachmentCount = 1;
 	framebufferInfo.pAttachments = nullptr;
 	framebufferInfo.width = Extent.width;
@@ -1399,39 +1456,39 @@ void CreateFramebuffers() {
 
 	for (long i = 0; i < swapchainLength; ++i) {
 		VkImageView attachments[] = {
-			swapchainImageViews[i]
+			pkvk_present.image_views[i]
 		};
 		framebufferInfo.pAttachments = attachments;
-		auto result = vkCreateFramebuffer(vkDevice, &framebufferInfo, vkAllocator, &swapchainFramebuffers[i]);
+		auto result = vkCreateFramebuffer(vkDevice, &framebufferInfo, vkAllocator, &pkvk_present.framebuffers[i]);
 		if (result != VK_SUCCESS) {
 			throw "failed to create present framebuffer";
 		}
 	}
 
 	framebufferInfo.attachmentCount = 2;
-	framebufferInfo.renderPass = d2OverlayRenderPass;
+	framebufferInfo.renderPass = pkvk_2d.render_pass;
 	for (long i = 0; i < swapchainLength; ++i) {
 		VkImageView attachments[] = {
-			colorImageViews[i],
-			renderImageViews[i],
+			pkvk_2d.image_views[i],
+			pkvk_2d.image_views_color_resolve[i],
 		};
 		framebufferInfo.pAttachments = attachments;
-		auto result = vkCreateFramebuffer(vkDevice, &framebufferInfo, vkAllocator, &d2OverlayImageFramebuffers[i]);
+		auto result = vkCreateFramebuffer(vkDevice, &framebufferInfo, vkAllocator, &pkvk_2d.framebuffers[i]);
 		if (result != VK_SUCCESS) {
 			throw "failed to create 2d overlay framebuffer";
 		}
 	}
 
 	framebufferInfo.attachmentCount = 3;
-	framebufferInfo.renderPass = renderRenderPass;
+	framebufferInfo.renderPass = pkvk_3d.render_pass;
 	for (long i = 0; i < swapchainLength; ++i) {
 		VkImageView attachments[] = {
-			colorImageViews[i],
+			pkvk_3d.image_views[i],
+			pkvk_3d.image_views_color_resolve[i],
 			depthImageViews[i],
-			renderImageViews[i],
 		};
 		framebufferInfo.pAttachments = attachments;
-		auto result = vkCreateFramebuffer(vkDevice, &framebufferInfo, vkAllocator, &renderImageFramebuffers[i]);
+		auto result = vkCreateFramebuffer(vkDevice, &framebufferInfo, vkAllocator, &pkvk_3d.framebuffers[i]);
 		if (result != VK_SUCCESS) {
 			throw "failed to create render framebuffer";
 		}
@@ -1445,14 +1502,14 @@ void CreateCommandPool() {
 	poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
 	poolInfo.queueFamilyIndex = graphicsFamilyIndex;
 
-	auto result = vkCreateCommandPool(vkDevice, &poolInfo, vkAllocator, &graphicsCommandPool);
+	auto result = vkCreateCommandPool(vkDevice, &poolInfo, vkAllocator, &pkvk_shared.command_pool.graphics);
 	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);
+	result = vkCreateCommandPool(vkDevice, &poolInfo, vkAllocator, &pkvk_shared.command_pool.transfer);
 	if (result != VK_SUCCESS) {
 		throw "failed to create transfer command pool";
 	}
@@ -1462,24 +1519,24 @@ void CreateCommandBuffer() {
 	VkCommandBufferAllocateInfo allocInfo;
 	allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
 	allocInfo.pNext = nullptr;
-	allocInfo.commandPool = graphicsCommandPool;
+	allocInfo.commandPool = pkvk_shared.command_pool.graphics;
 	allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
 	allocInfo.commandBufferCount = swapchainLength;
 
-	presentCommandBuffers = pk_new<VkCommandBuffer>(swapchainLength, MemBkt_Vulkan);
-	auto result = vkAllocateCommandBuffers(vkDevice, &allocInfo, presentCommandBuffers);
+	pkvk_present.command_buffers = pk_new<VkCommandBuffer>(swapchainLength, MemBkt_Vulkan);
+	auto result = vkAllocateCommandBuffers(vkDevice, &allocInfo, pkvk_present.command_buffers);
 	if (result != VK_SUCCESS) {
 		throw "failed to allocate command buffer";
 	}
 
 	allocInfo.commandBufferCount = 1;
-	result = vkAllocateCommandBuffers(vkDevice, &allocInfo, &graphicsCommandBuffer);
+	result = vkAllocateCommandBuffers(vkDevice, &allocInfo, &pkvk_shared.command_buffer.graphics);
 	if (result != VK_SUCCESS) {
 		throw "failed to allocate command buffer";
 	}
 
-	allocInfo.commandPool = transferCommandPool;
-	result = vkAllocateCommandBuffers(vkDevice, &allocInfo, &transferCommandBuffer);
+	allocInfo.commandPool = pkvk_shared.command_pool.transfer;
+	result = vkAllocateCommandBuffers(vkDevice, &allocInfo, &pkvk_shared.command_buffer.transfer);
 	if (result != VK_SUCCESS) {
 		throw "failed to allocate command buffer";
 	}
@@ -1538,13 +1595,13 @@ void CreateSyncObjects() {
 	fenceInfo.pNext = nullptr;
 	fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
 
-	presentImageAvailableSemaphores = pk_new<VkSemaphore>(swapchainLength, MemBkt_Vulkan);
-	presentRenderFinishedSemaphores = pk_new<VkSemaphore>(swapchainLength, MemBkt_Vulkan);
-	presentInFlightFences = pk_new<VkFence>(swapchainLength, MemBkt_Vulkan);
+	pkvk_present.semaphores_image_available = pk_new<VkSemaphore>(swapchainLength, MemBkt_Vulkan);
+	pkvk_present.semaphores_render_finished = pk_new<VkSemaphore>(swapchainLength, MemBkt_Vulkan);
+	pkvk_present.fences_in_flight = 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]);
+		auto result1 = vkCreateSemaphore(vkDevice, &semaphoreInfo, vkAllocator, &pkvk_present.semaphores_image_available[i]);
+		auto result2 = vkCreateSemaphore(vkDevice, &semaphoreInfo, vkAllocator, &pkvk_present.semaphores_render_finished[i]);
+		auto result3 = vkCreateFence(vkDevice, &fenceInfo, vkAllocator, &pkvk_present.fences_in_flight[i]);
 		auto result = result1 == result2 && result2 == result3 && result3 == VK_SUCCESS;
 		if (!result) {
 			throw "failed to create sync objects";
@@ -1553,6 +1610,7 @@ void CreateSyncObjects() {
 }
 
 void CreateGraphicsPipelines() {
+	PKVK_TmpBufferDetails tmpBufferDetails{};
 	// layouts & sampler
 	{
 		VkDescriptorSetLayoutBinding vkDescriptorSetLayoutBindings[2];
@@ -1578,6 +1636,7 @@ void CreateGraphicsPipelines() {
 
 		// no UBO on glyph
 		vkDescriptorSetLayoutBindings[0] = vkDescriptorSetLayoutBindings[1];
+		vkDescriptorSetLayoutBindings[0].binding = 0;
 		vkDescriptorSetLayoutCreateInfo.bindingCount = 1;
 		vkCreateDescriptorSetLayout(vkDevice, &vkDescriptorSetLayoutCreateInfo, vkAllocator, &pkePipelines.descr_layouts.named.glyph);
 
@@ -1739,7 +1798,7 @@ void CreateGraphicsPipelines() {
 		vkPipelineMultisampleStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
 		vkPipelineMultisampleStateCreateInfo.pNext = nullptr;
 		vkPipelineMultisampleStateCreateInfo.flags = 0;
-		vkPipelineMultisampleStateCreateInfo.rasterizationSamples = renderSampleCount;
+		vkPipelineMultisampleStateCreateInfo.rasterizationSamples = global_sample_count;
 		vkPipelineMultisampleStateCreateInfo.sampleShadingEnable = VK_FALSE;
 		vkPipelineMultisampleStateCreateInfo.minSampleShading = 0.0f;
 		vkPipelineMultisampleStateCreateInfo.pSampleMask = nullptr;
@@ -1832,7 +1891,7 @@ void CreateGraphicsPipelines() {
 			vkGraphicsPipelineCreateInfo[i].pColorBlendState = &vkPipelineColorBlendStateCreateInfo;
 			vkGraphicsPipelineCreateInfo[i].pDynamicState = &vkPipelineDynamicStateCreateInfo;
 			vkGraphicsPipelineCreateInfo[i].layout = pkePipelines.pipe_layouts.named.texture;
-			vkGraphicsPipelineCreateInfo[i].renderPass = renderRenderPass;
+			vkGraphicsPipelineCreateInfo[i].renderPass = pkvk_3d.render_pass;
 			vkGraphicsPipelineCreateInfo[i].subpass = 0;
 			vkGraphicsPipelineCreateInfo[i].basePipelineHandle = VK_NULL_HANDLE;
 			vkGraphicsPipelineCreateInfo[i].basePipelineIndex = {};
@@ -1917,11 +1976,8 @@ void CreateGraphicsPipelines() {
 		result = vkCreateImageView(vkDevice, &dbgImageViewCI, vkAllocator, &pkeDebugHitbox.vkImageView);
 		assert(result == VK_SUCCESS);
 
-		VkBuffer transferImageBuffer;
-		VkDeviceMemory transferImageMemory;
-		void *deviceData;
-		BeginTransferBuffer(4 * 4, transferImageBuffer, transferImageMemory, deviceData);
-		memcpy(deviceData, PKE_MISSING_TEXTURE_DATA, 4 * 4);
+		PKVK_BeginBuffer(transferFamilyIndex, 4 * 4, tmpBufferDetails);
+		memcpy(tmpBufferDetails.deviceData, PKE_MISSING_TEXTURE_DATA, 4 * 4);
 		{
 			VkImageMemoryBarrier vkImageMemoryBarrier;
 			vkImageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -1947,9 +2003,9 @@ void CreateGraphicsPipelines() {
 			vkCommandBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 			vkCommandBufferBeginInfo.pInheritanceInfo = nullptr;
 
-			vkBeginCommandBuffer(transferCommandBuffer, &vkCommandBufferBeginInfo);
+			vkBeginCommandBuffer(pkvk_shared.command_buffer.transfer, &vkCommandBufferBeginInfo);
 
-			vkCmdPipelineBarrier(transferCommandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &vkImageMemoryBarrier);
+			vkCmdPipelineBarrier(pkvk_shared.command_buffer.transfer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &vkImageMemoryBarrier);
 
 			VkBufferImageCopy vkBufferImageCopy;
 			vkBufferImageCopy.bufferOffset = 0;
@@ -1971,9 +2027,9 @@ void CreateGraphicsPipelines() {
 				.height = 2,
 				.depth = 1,
 			};
-			vkCmdCopyBufferToImage(transferCommandBuffer, transferImageBuffer, pkeDebugHitbox.vkImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &vkBufferImageCopy);
+			vkCmdCopyBufferToImage(pkvk_shared.command_buffer.transfer, tmpBufferDetails.buffer, pkeDebugHitbox.vkImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &vkBufferImageCopy);
 
-			vkEndCommandBuffer(transferCommandBuffer);
+			vkEndCommandBuffer(pkvk_shared.command_buffer.transfer);
 
 			VkSubmitInfo submitInfo;
 			submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
@@ -1982,14 +2038,14 @@ void CreateGraphicsPipelines() {
 			submitInfo.pWaitSemaphores = nullptr;
 			submitInfo.pWaitDstStageMask = nullptr;
 			submitInfo.commandBufferCount = 1;
-			submitInfo.pCommandBuffers = &transferCommandBuffer;
+			submitInfo.pCommandBuffers = &pkvk_shared.command_buffer.transfer;
 			submitInfo.signalSemaphoreCount = 0;
 			submitInfo.pSignalSemaphores = nullptr;
-			vkQueueSubmit(transferQueue, 1, &submitInfo, nullptr);
-			vkQueueWaitIdle(transferQueue);
-			vkResetCommandBuffer(transferCommandBuffer, 0);
+			vkQueueSubmit(tmpBufferDetails.queue, 1, &submitInfo, nullptr);
+			vkQueueWaitIdle(tmpBufferDetails.queue);
+			vkResetCommandBuffer(pkvk_shared.command_buffer.transfer, 0);
 		}
-		EndTransferBuffer(transferImageBuffer, transferImageMemory);
+		PKVK_EndBuffer(tmpBufferDetails);
 		{
 			VkImageMemoryBarrier vkImageMemoryBarrier;
 			vkImageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -2015,11 +2071,11 @@ void CreateGraphicsPipelines() {
 			vkCommandBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 			vkCommandBufferBeginInfo.pInheritanceInfo = nullptr;
 
-			vkBeginCommandBuffer(graphicsCommandBuffer, &vkCommandBufferBeginInfo);
+			vkBeginCommandBuffer(pkvk_shared.command_buffer.graphics, &vkCommandBufferBeginInfo);
 
-			vkCmdPipelineBarrier(graphicsCommandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &vkImageMemoryBarrier);
+			vkCmdPipelineBarrier(pkvk_shared.command_buffer.graphics, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &vkImageMemoryBarrier);
 
-			vkEndCommandBuffer(graphicsCommandBuffer);
+			vkEndCommandBuffer(pkvk_shared.command_buffer.graphics);
 
 			VkSubmitInfo submitInfo;
 			submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
@@ -2028,11 +2084,11 @@ void CreateGraphicsPipelines() {
 			submitInfo.pWaitSemaphores = nullptr;
 			submitInfo.pWaitDstStageMask = nullptr;
 			submitInfo.commandBufferCount = 1;
-			submitInfo.pCommandBuffers = &graphicsCommandBuffer;
+			submitInfo.pCommandBuffers = &pkvk_shared.command_buffer.graphics;
 			submitInfo.signalSemaphoreCount = 0;
 			submitInfo.pSignalSemaphores = nullptr;
-			vkQueueSubmit(graphicsQueue, 1, &submitInfo, nullptr);
-			vkQueueWaitIdle(graphicsQueue);
+			vkQueueSubmit(pkvk_shared.queue.graphics, 1, &submitInfo, nullptr);
+			vkQueueWaitIdle(pkvk_shared.queue.graphics);
 		}
 	}
 
@@ -2176,28 +2232,25 @@ void CreateGraphicsPipelines() {
 
 		// create transfer items && transfer
 		{
-			VkDeviceMemory transferDeviceMemory;
-			VkBuffer transferBuffer;
-			void *data;
-			BeginTransferBuffer(combinedMemReqs.size, transferBuffer, transferDeviceMemory, data);
-			memset(data, '\0', combinedMemReqs.size);
+			PKVK_BeginBuffer(transferFamilyIndex, combinedMemReqs.size, tmpBufferDetails);
+			memset(tmpBufferDetails.deviceData, '\0', combinedMemReqs.size);
 
 			char *dstPtr = nullptr;
 			char *srcPtr = nullptr;
 
-			dstPtr = static_cast<char *>(data) + offsetVert;
+			dstPtr = static_cast<char *>(tmpBufferDetails.deviceData) + offsetVert;
 			srcPtr = reinterpret_cast<char *>(pkeIntrinsicsCube.vert);
 			memcpy(dstPtr, srcPtr, sizeVert);
 
-			dstPtr = static_cast<char *>(data) + offsetNorm;
+			dstPtr = static_cast<char *>(tmpBufferDetails.deviceData) + offsetNorm;
 			srcPtr = reinterpret_cast<char *>(pkeIntrinsicsCube.norm);
 			memcpy(dstPtr, srcPtr, sizeNorm);
 
-			dstPtr = static_cast<char *>(data) + offsetUV;
+			dstPtr = static_cast<char *>(tmpBufferDetails.deviceData) + offsetUV;
 			srcPtr = reinterpret_cast<char *>(pkeIntrinsicsCube.uv);
 			memcpy(dstPtr, srcPtr, sizeUV);
 
-			dstPtr = static_cast<char *>(data) + offsetIndex;
+			dstPtr = static_cast<char *>(tmpBufferDetails.deviceData) + offsetIndex;
 			srcPtr = reinterpret_cast<char *>(pkeIntrinsicsCube.index);
 			memcpy(dstPtr, srcPtr, sizeIndex);
 
@@ -2208,7 +2261,7 @@ void CreateGraphicsPipelines() {
 			// TODO consider single-use?
 			vkCommandBufferBeginInfo.flags = 0;
 			vkCommandBufferBeginInfo.pInheritanceInfo = nullptr;
-			vkBeginCommandBuffer(transferCommandBuffer, &vkCommandBufferBeginInfo);
+			vkBeginCommandBuffer(pkvk_shared.command_buffer.transfer, &vkCommandBufferBeginInfo);
 			VkBufferCopy bufferCopys[4];
 			for (long i = 0; i < 4; ++i) {
 				bufferCopys[i].dstOffset = 0;
@@ -2216,25 +2269,25 @@ void CreateGraphicsPipelines() {
 			index = 0;
 			bufferCopys[index].srcOffset = offsetVert;
 			bufferCopys[index].size = sizeVert;
-			vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, pkeDebugHitbox.vertexBuffer, 1, &bufferCopys[index]);
+			vkCmdCopyBuffer(pkvk_shared.command_buffer.transfer, tmpBufferDetails.buffer, pkeDebugHitbox.vertexBuffer, 1, &bufferCopys[index]);
 			index+=1;
 
 			bufferCopys[index].srcOffset = offsetNorm;
 			bufferCopys[index].size = sizeNorm;
-			vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, pkeDebugHitbox.normalsBuffer, 1, &bufferCopys[index]);
+			vkCmdCopyBuffer(pkvk_shared.command_buffer.transfer, tmpBufferDetails.buffer, pkeDebugHitbox.normalsBuffer, 1, &bufferCopys[index]);
 			index+=1;
 
 			bufferCopys[index].srcOffset = offsetUV;
 			bufferCopys[index].size = sizeUV;
-			vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, pkeDebugHitbox.uvBuffer, 1, &bufferCopys[index]);
+			vkCmdCopyBuffer(pkvk_shared.command_buffer.transfer, tmpBufferDetails.buffer, pkeDebugHitbox.uvBuffer, 1, &bufferCopys[index]);
 			index+=1;
 
 			bufferCopys[index].srcOffset = offsetIndex;
 			bufferCopys[index].size = sizeIndex;
-			vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, pkeDebugHitbox.indexBuffer, 1, &bufferCopys[index]);
+			vkCmdCopyBuffer(pkvk_shared.command_buffer.transfer, tmpBufferDetails.buffer, pkeDebugHitbox.indexBuffer, 1, &bufferCopys[index]);
 			// index+=1;
 
-			vkEndCommandBuffer(transferCommandBuffer);
+			vkEndCommandBuffer(pkvk_shared.command_buffer.transfer);
 
 			VkSubmitInfo submitInfo;
 			submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
@@ -2243,13 +2296,13 @@ void CreateGraphicsPipelines() {
 			submitInfo.pWaitSemaphores = nullptr;
 			submitInfo.pWaitDstStageMask = nullptr;
 			submitInfo.commandBufferCount = 1;
-			submitInfo.pCommandBuffers = &transferCommandBuffer;
+			submitInfo.pCommandBuffers = &pkvk_shared.command_buffer.transfer;
 			submitInfo.signalSemaphoreCount = 0;
 			submitInfo.pSignalSemaphores = nullptr;
-			vkQueueSubmit(transferQueue, 1, &submitInfo, nullptr);
-			vkQueueWaitIdle(transferQueue);
+			vkQueueSubmit(tmpBufferDetails.queue, 1, &submitInfo, nullptr);
+			vkQueueWaitIdle(tmpBufferDetails.queue);
 
-			EndTransferBuffer(transferBuffer, transferDeviceMemory);
+			PKVK_EndBuffer(tmpBufferDetails);
 		}
 	}
 }
@@ -2382,9 +2435,9 @@ void CreateImGui() {
 	initInfo.MinImageCount = swapchainLength;
 	initInfo.PhysicalDevice = vkPhysicalDevice;
 	initInfo.PipelineCache = {};
-	initInfo.Queue = graphicsQueue;
+	initInfo.Queue = pkvk_shared.queue.graphics;
 	initInfo.QueueFamily = graphicsFamilyIndex;
-	initInfo.RenderPass = presentRenderPass;
+	initInfo.RenderPass = pkvk_present.render_pass;
 	initInfo.Subpass = 0;
 	initInfo.UseDynamicRendering = false;
 
@@ -2397,12 +2450,12 @@ void CreateImGui() {
 		// begInfo.pNext = nullptr;
 		// begInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 		// begInfo.pInheritanceInfo = {};
-		// vkBeginCommandBuffer(presentCommandBuffers[0], &begInfo);
+		// vkBeginCommandBuffer(pkvk_present.command_buffers[0], &begInfo);
 
 		// ImGui_ImplVulkan_CreateFontsTexture();
-		// ImGui_ImplVulkan_CreateFontsTexture(presentCommandBuffers[0]);
+		// ImGui_ImplVulkan_CreateFontsTexture(pkvk_present.command_buffers[0]);
 
-		// vkEndCommandBuffer(presentCommandBuffers[0]);
+		// vkEndCommandBuffer(pkvk_present.command_buffers[0]);
 
 		// VkSubmitInfo submitInfo;
 		// submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
@@ -2411,7 +2464,7 @@ void CreateImGui() {
 		// submitInfo.pWaitSemaphores = nullptr;
 		// submitInfo.pWaitDstStageMask = nullptr;
 		// submitInfo.commandBufferCount = 1;
-		// submitInfo.pCommandBuffers = presentCommandBuffers;
+		// submitInfo.pCommandBuffers = pkvk_present.command_buffers;
 		// submitInfo.signalSemaphoreCount = 0;
 		// submitInfo.pSignalSemaphores = nullptr;
 		// vkQueueSubmit(graphicsQueue, 1, &submitInfo, nullptr);
@@ -2437,21 +2490,19 @@ void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
 
 	// 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;
-	clearDepth.stencil = 0;
-	VkClearValue clearValues[2] = {
-		VkClearValue { .color = clearColorBlack },
-		VkClearValue { .depthStencil = clearDepth },
-	};
+	VkClearValue clearValues[3];
+	clearValues[0].color = clearColorBlack;
+	clearValues[1].color = clearColorBlack;
+	clearValues[2].depthStencil.depth = 1.0;
+	clearValues[2].depthStencil.stencil = 0;
 
 	VkRenderPassBeginInfo renderPassInfo;
 	renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
-	renderPassInfo.renderPass = renderRenderPass;
-	renderPassInfo.framebuffer = renderImageFramebuffers[imageIndex];
+	renderPassInfo.renderPass = pkvk_3d.render_pass;
+	renderPassInfo.framebuffer = pkvk_3d.framebuffers[imageIndex];
 	renderPassInfo.renderArea.offset = {0, 0};
 	renderPassInfo.renderArea.extent = Extent;
-	renderPassInfo.clearValueCount = 2;
+	renderPassInfo.clearValueCount = 3;
 	renderPassInfo.pClearValues = clearValues;
 	renderPassInfo.pNext = VK_NULL_HANDLE;
 
@@ -2532,8 +2583,8 @@ void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
 
 	// 2d overlay pass
 	/*
-	renderPassInfo.renderPass = d2OverlayRenderPass;
-	renderPassInfo.framebuffer = d2OverlayImageFramebuffers[imageIndex];
+	renderPassInfo.renderPass = pkvk_2d.render_pass;
+	renderPassInfo.framebuffer = pkvk_2d.framebuffers[imageIndex];
 	renderPassInfo.clearValueCount = 1;
 	clearValues[0].color = clearColorTransparent;
 
@@ -2563,14 +2614,14 @@ void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
 	*/
 
 	// present pass
-	renderPassInfo.renderPass = presentRenderPass;
-	renderPassInfo.framebuffer = swapchainFramebuffers[imageIndex];
+	renderPassInfo.renderPass = pkvk_present.render_pass;
+	renderPassInfo.framebuffer = pkvk_present.framebuffers[imageIndex];
 	renderPassInfo.clearValueCount = 1;
 	clearValues[0].color = clearColorBlack;
 
 	vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
-	vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &presentDescriptorSets[imageIndex], 0, nullptr);
-	vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
+	vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pkvk_present.pipeline_layout, 0, 1, &pkvk_present.descriptor_sets[imageIndex], 0, nullptr);
+	vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pkvk_present.pipeline);
 
 	vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
 	vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
@@ -2612,70 +2663,91 @@ void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
 }
 
 void DestroySwapchain() {
-	if (d2OverlayImageFramebuffers != nullptr && d2OverlayImageFramebuffers != CAFE_BABE(VkFramebuffer)) {
+	if (pkvk_2d.framebuffers != nullptr && pkvk_2d.framebuffers != CAFE_BABE(VkFramebuffer)) {
 		for (long i = 0; i < swapchainLength; ++i) {
-			vkDestroyFramebuffer(vkDevice, d2OverlayImageFramebuffers[i], vkAllocator);
+			vkDestroyFramebuffer(vkDevice, pkvk_2d.framebuffers[i], vkAllocator);
 		}
-		pk_delete<VkFramebuffer>(d2OverlayImageFramebuffers, swapchainLength);
-		d2OverlayImageFramebuffers = CAFE_BABE(VkFramebuffer);
+		pk_delete<VkFramebuffer>(pkvk_2d.framebuffers, swapchainLength);
+		pkvk_2d.framebuffers = CAFE_BABE(VkFramebuffer);
 	}
-	if (renderImageFramebuffers != nullptr && renderImageFramebuffers != CAFE_BABE(VkFramebuffer)) {
+	if (pkvk_3d.framebuffers != nullptr && pkvk_3d.framebuffers != CAFE_BABE(VkFramebuffer)) {
 		for (long i = 0; i < swapchainLength; ++i) {
-			vkDestroyFramebuffer(vkDevice, renderImageFramebuffers[i], vkAllocator);
+			vkDestroyFramebuffer(vkDevice, pkvk_3d.framebuffers[i], vkAllocator);
 		}
-		pk_delete<VkFramebuffer>(renderImageFramebuffers, swapchainLength);
-		renderImageFramebuffers = CAFE_BABE(VkFramebuffer);
+		pk_delete<VkFramebuffer>(pkvk_3d.framebuffers, swapchainLength);
+		pkvk_3d.framebuffers = CAFE_BABE(VkFramebuffer);
 	}
-	if (swapchainFramebuffers != nullptr && swapchainFramebuffers != CAFE_BABE(VkFramebuffer)) {
+	if (pkvk_present.framebuffers != nullptr && pkvk_present.framebuffers != CAFE_BABE(VkFramebuffer)) {
 		for (long i = 0; i < swapchainLength; ++i) {
-			vkDestroyFramebuffer(vkDevice, swapchainFramebuffers[i], vkAllocator);
+			vkDestroyFramebuffer(vkDevice, pkvk_present.framebuffers[i], vkAllocator);
 		}
-		pk_delete<VkFramebuffer>(swapchainFramebuffers, swapchainLength);
-		swapchainFramebuffers = CAFE_BABE(VkFramebuffer);
+		pk_delete<VkFramebuffer>(pkvk_present.framebuffers, swapchainLength);
+		pkvk_present.framebuffers = CAFE_BABE(VkFramebuffer);
 	}
-	if (renderImageViews!= nullptr && renderImageViews != CAFE_BABE(VkImageView)) {
+	if (depthImageViews != nullptr && depthImageViews != CAFE_BABE(VkImageView)) {
 		for (long i = 0; i < swapchainLength; ++i) {
 			vkDestroyImageView(vkDevice, depthImageViews[i], vkAllocator);
 			vkDestroyImage(vkDevice, depthImages[i], vkAllocator);
-
-			vkDestroyImageView(vkDevice, d2OverlayImageViews[i], vkAllocator);
-			vkDestroyImage(vkDevice, d2OverlayImages[i], vkAllocator);
-
-			vkDestroyImageView(vkDevice, colorImageViews[i], vkAllocator);
-			vkDestroyImage(vkDevice, colorImages[i], vkAllocator);
-
-			vkDestroyImageView(vkDevice, renderImageViews[i], vkAllocator);
-			vkDestroyImage(vkDevice, renderImages[i], vkAllocator);
 		}
 		pk_delete<VkImageView>(depthImageViews, swapchainLength);
 		depthImageViews = CAFE_BABE(VkImageView);
 		pk_delete<VkImage>(depthImages, swapchainLength);
 		depthImages = CAFE_BABE(VkImage);
-		pk_delete<VkImageView>(d2OverlayImageViews, swapchainLength);
-		d2OverlayImageViews = CAFE_BABE(VkImageView);
-		pk_delete<VkImage>(d2OverlayImages, swapchainLength);
-		d2OverlayImages = CAFE_BABE(VkImage);
-		pk_delete<VkImageView>(colorImageViews, swapchainLength);
-		colorImageViews = CAFE_BABE(VkImageView);
-		pk_delete<VkImage>(colorImages, swapchainLength);
-		colorImages = CAFE_BABE(VkImage);
-		pk_delete<VkImageView>(renderImageViews, swapchainLength);
-		renderImageViews = CAFE_BABE(VkImageView);
-		pk_delete<VkImage>(renderImages, swapchainLength);
-		renderImages = CAFE_BABE(VkImage);
-		vkFreeMemory(vkDevice, d2OverlayImagesMemory, vkAllocator);
 		vkFreeMemory(vkDevice, depthImagesMemory, vkAllocator);
-		vkFreeMemory(vkDevice, colorImagesMemory, vkAllocator);
-		vkFreeMemory(vkDevice, renderImagesMemory, vkAllocator);
 	}
-	if (swapchainImageViews!= nullptr && swapchainImageViews != CAFE_BABE(VkImageView)) {
+	if (pkvk_2d.image_views != nullptr && pkvk_2d.image_views != CAFE_BABE(VkImageView)) {
+		for (long i = 0; i < swapchainLength; ++i) {
+			vkDestroyImageView(vkDevice, pkvk_2d.image_views[i], vkAllocator);
+			vkDestroyImage(vkDevice, pkvk_2d.images[i], vkAllocator);
+		}
+		pk_delete<VkImageView>(pkvk_2d.image_views, swapchainLength);
+		pkvk_2d.image_views = CAFE_BABE(VkImageView);
+		pk_delete<VkImage>(pkvk_2d.images, swapchainLength);
+		pkvk_2d.images = CAFE_BABE(VkImage);
+		vkFreeMemory(vkDevice, pkvk_2d.images_memory, vkAllocator);
+	}
+	if (pkvk_2d.image_views_color_resolve != nullptr && pkvk_2d.image_views_color_resolve != CAFE_BABE(VkImageView)) {
+		for (long i = 0; i < swapchainLength; ++i) {
+			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);
+		pkvk_2d.image_views_color_resolve = CAFE_BABE(VkImageView);
+		pk_delete<VkImage>(pkvk_2d.images_color_resolve, swapchainLength);
+		pkvk_2d.images_color_resolve = CAFE_BABE(VkImage);
+		vkFreeMemory(vkDevice, pkvk_2d.images_memory_color_resolve, vkAllocator);
+	}
+	if (pkvk_3d.image_views_color_resolve != nullptr && pkvk_3d.image_views_color_resolve != CAFE_BABE(VkImageView)) {
+		for (long i = 0; i < swapchainLength; ++i) {
+			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);
+		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);
+		pkvk_3d.images_color_resolve = CAFE_BABE(VkImage);
+	}
+	if (pkvk_3d.image_views != nullptr && pkvk_3d.image_views != CAFE_BABE(VkImageView)) {
+		for (long i = 0; i < swapchainLength; ++i) {
+			vkDestroyImageView(vkDevice, pkvk_3d.image_views[i], vkAllocator);
+			vkDestroyImage(vkDevice, pkvk_3d.render_images[i], vkAllocator);
+		}
+		pk_delete<VkImageView>(pkvk_3d.image_views, swapchainLength);
+		pkvk_3d.image_views = CAFE_BABE(VkImageView);
+		pk_delete<VkImage>(pkvk_3d.render_images, swapchainLength);
+		pkvk_3d.render_images = CAFE_BABE(VkImage);
+		vkFreeMemory(vkDevice, pkvk_3d.images_memory, vkAllocator);
+	}
+	if (pkvk_present.image_views!= nullptr && pkvk_present.image_views != CAFE_BABE(VkImageView)) {
 		for (long i = 0; i < swapchainLength; ++i) {
-			vkDestroyImageView(vkDevice, swapchainImageViews[i], vkAllocator);
+			vkDestroyImageView(vkDevice, pkvk_present.image_views[i], vkAllocator);
 		}
-		pk_delete<VkImageView>(swapchainImageViews, swapchainLength);
-		swapchainImageViews = CAFE_BABE(VkImageView);
-		pk_delete<VkImage>(swapchainImages, swapchainLength);
-		swapchainImages = CAFE_BABE(VkImage);
+		pk_delete<VkImageView>(pkvk_present.image_views, swapchainLength);
+		pkvk_present.image_views = CAFE_BABE(VkImageView);
+		pk_delete<VkImage>(pkvk_present.images, swapchainLength);
+		pkvk_present.images = CAFE_BABE(VkImage);
+		// no memory free for present because they are managed by the swapchain
 	}
 	vkDestroySwapchainKHR(vkDevice, vkSwapchainKHR, vkAllocator);
 }
@@ -2791,35 +2863,35 @@ void DestroyWindow() {
 
 	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);
+		vkDestroySemaphore(vkDevice, pkvk_present.semaphores_image_available[i], vkAllocator);
+		vkDestroySemaphore(vkDevice, pkvk_present.semaphores_render_finished[i], vkAllocator);
+		vkDestroyFence(vkDevice, pkvk_present.fences_in_flight[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);
+	pk_delete<VkSemaphore>(pkvk_present.semaphores_image_available, swapchainLength, MemBkt_Vulkan);
+	pkvk_present.semaphores_image_available = CAFE_BABE(VkSemaphore);
+	pk_delete<VkSemaphore>(pkvk_present.semaphores_render_finished, swapchainLength, MemBkt_Vulkan);
+	pkvk_present.semaphores_render_finished = CAFE_BABE(VkSemaphore);
+	pk_delete<VkFence>(pkvk_present.fences_in_flight, swapchainLength, MemBkt_Vulkan);
+	pkvk_present.fences_in_flight = 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, swapchainLength, presentDescriptorSets);
-	pk_delete<VkDescriptorSet>(presentDescriptorSets, swapchainLength, MemBkt_Vulkan);
-	presentDescriptorSets = CAFE_BABE(VkDescriptorSet);
-	vkDestroyDescriptorPool(vkDevice, presentDescriptorPool, vkAllocator);
+	vkDestroyCommandPool(vkDevice, pkvk_shared.command_pool.graphics, vkAllocator);
+	vkDestroyCommandPool(vkDevice, pkvk_shared.command_pool.transfer, vkAllocator);
+	vkDestroyPipeline(vkDevice, pkvk_present.pipeline, vkAllocator);
+	vkDestroyPipelineLayout(vkDevice, pkvk_present.pipeline_layout, vkAllocator);
+	vkFreeDescriptorSets(vkDevice, pkvk_present.descriptor_pool, swapchainLength, pkvk_present.descriptor_sets);
+	pk_delete<VkDescriptorSet>(pkvk_present.descriptor_sets, swapchainLength, MemBkt_Vulkan);
+	pkvk_present.descriptor_sets = CAFE_BABE(VkDescriptorSet);
+	vkDestroyDescriptorPool(vkDevice, pkvk_present.descriptor_pool, vkAllocator);
 	vkDestroyDescriptorPool(vkDevice, imGuiDescriptorPool, vkAllocator);
-	vkDestroyDescriptorSetLayout(vkDevice, vkDescriptorSetLayout, vkAllocator);
-	vkDestroyRenderPass(vkDevice, d2OverlayRenderPass, vkAllocator);
-	vkDestroyRenderPass(vkDevice, renderRenderPass, vkAllocator);
-	vkDestroyRenderPass(vkDevice, presentRenderPass, vkAllocator);
+	vkDestroyDescriptorSetLayout(vkDevice, pkvk_present.descriptor_set_layout, vkAllocator);
+	vkDestroyRenderPass(vkDevice, pkvk_2d.render_pass, vkAllocator);
+	vkDestroyRenderPass(vkDevice, pkvk_3d.render_pass, vkAllocator);
+	vkDestroyRenderPass(vkDevice, pkvk_present.render_pass, vkAllocator);
 	vkDestroySurfaceKHR(vkInstance, vkSurfaceKHR, vkAllocator);
-	vkDestroySampler(vkDevice, presentSampler, vkAllocator);
+	vkDestroySampler(vkDevice, global_sampler, vkAllocator);
 	vkDestroyDevice(vkDevice, vkAllocator);
 	if (VULKAN_DEBUG_REPORT) {
 		auto vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(vkInstance, "vkDestroyDebugReportCallbackEXT");
@@ -2889,10 +2961,10 @@ void CalculateCombinedMemReqs(uint64_t memReqsCount, VkMemoryRequirements *memRe
 }
 
 void Render() {
-	vkWaitForFences(vkDevice, 1, &presentInFlightFences[CURRENT_FRAME], VK_TRUE, UINT64_MAX);
+	vkWaitForFences(vkDevice, 1, &pkvk_present.fences_in_flight[CURRENT_FRAME], VK_TRUE, UINT64_MAX);
 
 	uint32_t imageIndex;
-	auto result = vkAcquireNextImageKHR(vkDevice, vkSwapchainKHR, UINT64_MAX, presentImageAvailableSemaphores[CURRENT_FRAME], VK_NULL_HANDLE, &imageIndex);
+	auto result = vkAcquireNextImageKHR(vkDevice, vkSwapchainKHR, UINT64_MAX, pkvk_present.semaphores_image_available[CURRENT_FRAME], VK_NULL_HANDLE, &imageIndex);
 
 	if (result == VK_ERROR_OUT_OF_DATE_KHR) {
 		RecreateSwapchain();
@@ -2910,13 +2982,13 @@ void Render() {
 		vkUnmapMemory(vkDevice, uniformBufferMemory);
 	}
 
-	vkResetFences(vkDevice, 1, &presentInFlightFences[CURRENT_FRAME]);
+	vkResetFences(vkDevice, 1, &pkvk_present.fences_in_flight[CURRENT_FRAME]);
 
-	vkResetCommandBuffer(presentCommandBuffers[CURRENT_FRAME], 0);
-	RecordCommandBuffer(presentCommandBuffers[CURRENT_FRAME], imageIndex);
+	vkResetCommandBuffer(pkvk_present.command_buffers[CURRENT_FRAME], 0);
+	RecordCommandBuffer(pkvk_present.command_buffers[CURRENT_FRAME], imageIndex);
 
-	VkSemaphore waitSemaphores[] = {presentImageAvailableSemaphores[CURRENT_FRAME]};
-	VkSemaphore signalSemaphores[] = {presentRenderFinishedSemaphores[CURRENT_FRAME]};
+	VkSemaphore waitSemaphores[] = {pkvk_present.semaphores_image_available[CURRENT_FRAME]};
+	VkSemaphore signalSemaphores[] = {pkvk_present.semaphores_render_finished[CURRENT_FRAME]};
 	VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
 
 	VkSubmitInfo submitInfo;
@@ -2926,11 +2998,11 @@ void Render() {
 	submitInfo.pWaitSemaphores = waitSemaphores;
 	submitInfo.pWaitDstStageMask = waitStages;
 	submitInfo.commandBufferCount = 1;
-	submitInfo.pCommandBuffers = &presentCommandBuffers[CURRENT_FRAME];
+	submitInfo.pCommandBuffers = &pkvk_present.command_buffers[CURRENT_FRAME];
 	submitInfo.signalSemaphoreCount = 1;
 	submitInfo.pSignalSemaphores = signalSemaphores;
 
-	result = vkQueueSubmit(graphicsQueue, 1, &submitInfo, presentInFlightFences[CURRENT_FRAME]);
+	result = vkQueueSubmit(pkvk_shared.queue.graphics, 1, &submitInfo, pkvk_present.fences_in_flight[CURRENT_FRAME]);
 	if (result != VK_SUCCESS) {
 		throw "failed to submit queue";
 	}