create and destroy debug pipeline resources

4 files changed, 713 insertions, 129 deletions

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