pke: pkvk_texture_upload takes array of textures

3 files changed, 206 insertions, 164 deletions

diff --git a/src/font.cpp b/src/font.cpp
index 26004e3..6d47fa9 100644
--- a/src/font.cpp
+++ b/src/font.cpp
@@ -4,7 +4,6 @@
 #include "pk.h"
 #include "window.hpp"
 #include "static-plane.hpp"
-#include "vendor-stb-image-include.h"
 #include "game-settings.hpp"
 #include "ecs.hpp"
 #include "../embed/embedded-fonts.h"
@@ -586,13 +585,8 @@ FontTypeIndex FontType_RegisterFont(pk_cstr title, AssetHandle fontTextureHandle
 	ft->n_glyphs = glyphs->size / sizeof(FontGlyphChar);
 	ft->glyphs = (FontGlyphChar*)glyphs->ptr;
 
-	int txtr_x, txtr_y, txtr_chan;
-	stbi_uc *txtr_bytes = stbi_load_from_memory((unsigned char*)fontTexture->ptr, fontTexture->size, &txtr_x, &txtr_y, &txtr_chan, 4);
-	assert(txtr_bytes != nullptr);
-	assert(txtr_chan == 4);
-	uint32_t imageSizeBytes = txtr_x * txtr_y * txtr_chan;
-	ft->atlas_size.x = (float)txtr_x;
-	ft->atlas_size.y = (float)txtr_y;
+	ft->atlas_size.x = (float)fontTexture->details.texture.width;
+	ft->atlas_size.y = (float)fontTexture->details.texture.height;
 
 	ECS_CreateEntity(ft);
 
@@ -647,20 +641,16 @@ FontTypeIndex FontType_RegisterFont(pk_cstr title, AssetHandle fontTextureHandle
 		// texture
 
 		pkvk_texture_upload_data txtr_data{};
-		txtr_data.bytes = txtr_bytes;
-		txtr_data.n_bytes = imageSizeBytes;
-		txtr_data.width = (uint32_t)txtr_x;
-		txtr_data.height = (uint32_t)txtr_y;
+		txtr_data.texture_assets[0] = fontTexture;
+		txtr_data.n_textures = 1;
 
 		pkvk_texture_upload_data_out txtr_out{};
 		pkvk_texture_upload(&txtr_data, &txtr_out);
 
-		ft->gr.textureImage = txtr_out.image;
-		ft->gr.textureImageView = txtr_out.image_view;
+		ft->gr.textureImage = txtr_out.images[0];
+		ft->gr.textureImageView = txtr_out.image_views[0];
 		ft->gr.deviceMemoryTexture = txtr_out.device_memory;
 
-		free(txtr_bytes);
-
 		/* 
 		 * Vulkan descriptor sets
 		 */
@@ -709,8 +699,6 @@ FontTypeIndex FontType_RegisterFont(pk_cstr title, AssetHandle fontTextureHandle
 
 		vkUpdateDescriptorSets(vkDevice, (uint32_t)1, &writeDescriptorSet, 0, nullptr);
 
-	} else {
-		free(txtr_bytes);
 	}
 
 	AM_Release(fontTextureHandle);
diff --git a/src/window.cpp b/src/window.cpp
index 7a86b26..fa28e34 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -17,6 +17,7 @@
 #include "static-cube.hpp"
 #include "static-missing-texture.hpp"
 #include "static-ui.hpp"
+#include "vendor-stb-image-include.h"
 #include "window-types.hpp"
 
 #include "glm/ext/matrix_transform.hpp"
@@ -441,48 +442,120 @@ void pkvk_buffer_create(pkvk_buffer_create_data *data, pkvk_buffer_create_data_o
 }
 
 void pkvk_texture_upload(pkvk_texture_upload_data *data, pkvk_texture_upload_data_out *out) {
-	VkResult vkResult;
-	VkMemoryRequirements image_memory_requirements;
+	uint8_t i;
+	int txtr_x, txtr_y, txtr_chan;
+	VkResult vkResult{};
+	VkImage tmpImage{};
 	PKVK_TmpBufferDetails tmpBufferDetails{};
+	VkImageViewCreateInfo vkImageViewCreateInfo{};
+	VkImageCreateInfo imageCreateInfo{};
+	VkMemoryRequirements combined_mem_reqs{};
+
+	VkBufferImageCopy2 vkBufferImageCopies[PKVK_TEXTURE_UPLOAD_ARR_MAX_LENGTH];
+	VkCopyBufferToImageInfo2 copy_buffer_to_image_2s[PKVK_TEXTURE_UPLOAD_ARR_MAX_LENGTH];
+	VkImageMemoryBarrier vkImageMemoryBarriers[PKVK_TEXTURE_UPLOAD_ARR_MAX_LENGTH];
+	VkMemoryRequirements image_memory_requirements[PKVK_TEXTURE_UPLOAD_ARR_MAX_LENGTH];
+	VkDeviceSize offsets[PKVK_TEXTURE_UPLOAD_ARR_MAX_LENGTH];
+	VkDeviceSize size = 0;
+	VkDeviceSize offset = 0;
+
+	memset(&offsets, 0, sizeof(offsets));
+
+	vkImageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+	vkImageViewCreateInfo.pNext = VK_NULL_HANDLE;
+	vkImageViewCreateInfo.flags = 0;
+	vkImageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+	vkImageViewCreateInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
+	vkImageViewCreateInfo.components = VkComponentMapping {
+		.r = VK_COMPONENT_SWIZZLE_IDENTITY,
+		.g = VK_COMPONENT_SWIZZLE_IDENTITY,
+		.b = VK_COMPONENT_SWIZZLE_IDENTITY,
+		.a = VK_COMPONENT_SWIZZLE_IDENTITY,
+	};
+	vkImageViewCreateInfo.subresourceRange = VkImageSubresourceRange {
+		.aspectMask = VkImageAspectFlagBits::VK_IMAGE_ASPECT_COLOR_BIT,
+		.baseMipLevel = 0u,
+		// TODO MipMap
+		.levelCount = 1u,
+		.baseArrayLayer = 0u,
+		.layerCount = 1u,
+	};
+
+	imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+	imageCreateInfo.pNext = VK_NULL_HANDLE;
+	imageCreateInfo.flags = 0;
+	imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
+	imageCreateInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
+	imageCreateInfo.extent.depth = 1;
+	imageCreateInfo.mipLevels = 1;
+	imageCreateInfo.arrayLayers = 1;
+	imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+	imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+	imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
+	imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+	imageCreateInfo.queueFamilyIndexCount = 0;
+	imageCreateInfo.pQueueFamilyIndices = VK_NULL_HANDLE;
+	imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+
+	for (i = 0; i < data->n_textures; ++i) {
+		vkImageMemoryBarriers[i].sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+		vkImageMemoryBarriers[i].pNext = VK_NULL_HANDLE;
+		vkImageMemoryBarriers[i].srcAccessMask = {};
+		vkImageMemoryBarriers[i].dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+		vkImageMemoryBarriers[i].oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+		vkImageMemoryBarriers[i].newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+		vkImageMemoryBarriers[i].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+		vkImageMemoryBarriers[i].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+		vkImageMemoryBarriers[i].subresourceRange = vkImageViewCreateInfo.subresourceRange;
+
+		vkBufferImageCopies[i].sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2;
+		vkBufferImageCopies[i].pNext = VK_NULL_HANDLE;
+		vkBufferImageCopies[i].bufferOffset = 0;
+		vkBufferImageCopies[i].bufferRowLength = 0;
+		vkBufferImageCopies[i].bufferImageHeight = 0;
+		vkBufferImageCopies[i].imageSubresource = VkImageSubresourceLayers {
+			.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+			.mipLevel = 0,
+			.baseArrayLayer = 0,
+			.layerCount = 1,
+		};
+		vkBufferImageCopies[i].imageOffset = VkOffset3D {
+			.x = 0,
+			.y = 0,
+			.z = 0,
+		};
+		vkBufferImageCopies[i].imageExtent = VkExtent3D {
+			.width = 0,
+			.height = 0,
+			.depth = 1,
+		};
+
+		copy_buffer_to_image_2s[i].sType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2;
+		copy_buffer_to_image_2s[i].pNext = VK_NULL_HANDLE;
+		copy_buffer_to_image_2s[i].srcBuffer = VK_NULL_HANDLE;
+		copy_buffer_to_image_2s[i].dstImage = VK_NULL_HANDLE;
+		copy_buffer_to_image_2s[i].dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+		copy_buffer_to_image_2s[i].regionCount = 1;
+		copy_buffer_to_image_2s[i].pRegions = &vkBufferImageCopies[i];
+	}
 
 	/*
 	 * get memory requirements
 	 */
 
-	VkImageCreateInfo imageCreateInfo{};
-	VkImageSubresourceRange vkImageSubresourceRange;
-	{
-		imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
-		imageCreateInfo.pNext = nullptr;
-		imageCreateInfo.flags = 0;
-		imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
-		imageCreateInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
-		imageCreateInfo.extent.width = data->width;
-		imageCreateInfo.extent.height = data->height;
-		imageCreateInfo.extent.depth = 1;
-		imageCreateInfo.mipLevels = 1;
-		imageCreateInfo.arrayLayers = 1;
-		imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
-		imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
-		imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
-		imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-		imageCreateInfo.queueFamilyIndexCount = 0;
-		imageCreateInfo.pQueueFamilyIndices = nullptr;
-		imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-
-		vkImageSubresourceRange.aspectMask = VkImageAspectFlagBits::VK_IMAGE_ASPECT_COLOR_BIT;
-		vkImageSubresourceRange.baseMipLevel = 0u;
-		vkImageSubresourceRange.levelCount = 1u;
-		vkImageSubresourceRange.baseArrayLayer = 0u;
-		vkImageSubresourceRange.layerCount = 1u;
-
-		VkImage tmpImage;
+	for (i = 0; i < data->n_textures; ++i) {
+		assert(data->texture_assets[i]->type == PKE_ASSET_TYPE_TEXTURE);
+
+		imageCreateInfo.extent.width = data->texture_assets[i]->details.texture.width;
+		imageCreateInfo.extent.height = data->texture_assets[i]->details.texture.height;
 		vkResult = vkCreateImage(vkDevice, &imageCreateInfo, vkAllocator, &tmpImage);
 		assert(vkResult == VK_SUCCESS);
-		vkGetImageMemoryRequirements(vkDevice, tmpImage, &image_memory_requirements);
+		vkGetImageMemoryRequirements(vkDevice, tmpImage, &image_memory_requirements[i]);
 		vkDestroyImage(vkDevice, tmpImage, vkAllocator);
 	}
 
+	CalculateCombinedMemReqs((uint64_t)data->n_textures, image_memory_requirements, combined_mem_reqs);
+
 	/*
 	 * memory allocation
 	 */
@@ -490,138 +563,119 @@ void pkvk_texture_upload(pkvk_texture_upload_data *data, pkvk_texture_upload_dat
 	VkMemoryAllocateInfo vkMemoryAllocateInfo;
 	vkMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
 	vkMemoryAllocateInfo.pNext = nullptr;
-
-	// texture
-	vkMemoryAllocateInfo.allocationSize = image_memory_requirements.size;
-	vkMemoryAllocateInfo.memoryTypeIndex = FindMemoryTypeIndex(image_memory_requirements.memoryTypeBits, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
+	vkMemoryAllocateInfo.allocationSize = combined_mem_reqs.size;
+	vkMemoryAllocateInfo.memoryTypeIndex = FindMemoryTypeIndex(combined_mem_reqs.memoryTypeBits, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
 	if (vkMemoryAllocateInfo.memoryTypeIndex == 0) {
-		vkMemoryAllocateInfo.memoryTypeIndex = FindMemoryTypeIndex(image_memory_requirements.memoryTypeBits, 0);
+		vkMemoryAllocateInfo.memoryTypeIndex = FindMemoryTypeIndex(combined_mem_reqs.memoryTypeBits, 0);
 	}
 	vkAllocateMemory(vkDevice, &vkMemoryAllocateInfo, vkAllocator, &out->device_memory);
 
 	/*
-	 * transition layout & copy to buffer
+	 * buffer setup
 	 */
 
-	PKVK_BeginBuffer(transferFamilyIndex, image_memory_requirements.size, tmpBufferDetails);
-	memcpy(tmpBufferDetails.deviceData, data->bytes, data->n_bytes);
-	{
-		VkDeviceSize paddedImageSize = image_memory_requirements.size + (image_memory_requirements.alignment - (image_memory_requirements.size % image_memory_requirements.alignment));
-		assert(paddedImageSize % image_memory_requirements.alignment == 0);
-
-		VkImageViewCreateInfo vkImageViewCreateInfo;
-		vkImageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
-		vkImageViewCreateInfo.pNext = nullptr;
-		vkImageViewCreateInfo.flags = 0;
-		vkImageViewCreateInfo.image = out->image;
-		vkImageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
-		vkImageViewCreateInfo.format = imageCreateInfo.format;
-		vkImageViewCreateInfo.components = VkComponentMapping {
-			.r = VK_COMPONENT_SWIZZLE_IDENTITY,
-			.g = VK_COMPONENT_SWIZZLE_IDENTITY,
-			.b = VK_COMPONENT_SWIZZLE_IDENTITY,
-			.a = VK_COMPONENT_SWIZZLE_IDENTITY,
-		};
-		vkImageViewCreateInfo.subresourceRange = vkImageSubresourceRange;
+	char *temp_buffer = (char *)malloc(combined_mem_reqs.size);
+
+	// copy data to temp buffer
+	// 2025-08-06 - JCB - PERF TODO actually test performance
+	//  It's possible that copying these to a temporary buffer is a performance loss.
+	//  The idea here is to separate this number-crunching from the buffer recording.
+	//  If this texture upload function ends up being a bottleneck here's a few suggestions:
+	//  - split stbi work to separate threads (likely biggest impact)
+	//  - reduce # of data-copies (copy straight to the vulkan buffer instead of intermediary)
+	for (i = 0; i < data->n_textures; ++i) {
+
+		/* run texture data through stbi, putting it in the VkFormat we desire, & copy */
+		stbi_uc *txtr_bytes = stbi_load_from_memory((unsigned char*)data->texture_assets[i]->ptr, data->texture_assets[i]->size, &txtr_x, &txtr_y, &txtr_chan, 4);
+		assert(txtr_bytes != nullptr);
+		assert(txtr_chan == 4);
+
+		size = txtr_x * txtr_y * txtr_chan;
+		memcpy(temp_buffer + offset, txtr_bytes, size);
 
-		vkResult = vkCreateImage(vkDevice, &imageCreateInfo, vkAllocator, &out->image);
+		free(txtr_bytes);
+
+		// create image
+
+		imageCreateInfo.extent.width = data->texture_assets[i]->details.texture.width;
+		imageCreateInfo.extent.height = data->texture_assets[i]->details.texture.height;
+		vkResult = vkCreateImage(vkDevice, &imageCreateInfo, vkAllocator, &out->images[i]);
 		assert(vkResult == VK_SUCCESS);
-		vkResult = vkBindImageMemory(vkDevice, out->image, out->device_memory, 0);
+		vkResult = vkBindImageMemory(vkDevice, out->images[i], out->device_memory, offset);
 		assert(vkResult == VK_SUCCESS);
 
-		vkImageViewCreateInfo.image = out->image;
-		vkResult = vkCreateImageView(vkDevice, &vkImageViewCreateInfo, vkAllocator, &out->image_view);
+		// create image view
+
+		vkImageViewCreateInfo.image = out->images[i];
+		vkResult = vkCreateImageView(vkDevice, &vkImageViewCreateInfo, vkAllocator, &out->image_views[i]);
 		assert(vkResult == VK_SUCCESS);
 
-		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 = out->image;
-		vkImageMemoryBarrier.subresourceRange = VkImageSubresourceRange {
-			.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-			.baseMipLevel = 0,
-			// TODO MipMap
-			.levelCount = 1,
-			.baseArrayLayer = 0,
-			.layerCount = 1,
-		};
+		// set up image copy parameters
+		vkBufferImageCopies[i].bufferOffset = offset;
+		vkBufferImageCopies[i].bufferRowLength = data->texture_assets[i]->details.texture.width;
+		vkBufferImageCopies[i].bufferImageHeight = data->texture_assets[i]->details.texture.height;
+		vkBufferImageCopies[i].imageExtent.width = data->texture_assets[i]->details.texture.width;
+		vkBufferImageCopies[i].imageExtent.height = data->texture_assets[i]->details.texture.height;
+		vkImageMemoryBarriers[i].image = out->images[i];
 
-		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;
+		offset += size;
+		offset += (combined_mem_reqs.alignment - (size % combined_mem_reqs.alignment)) % combined_mem_reqs.alignment;
+	}
 
-		vkBeginCommandBuffer(tmpBufferDetails.cmdBuffer, &vkCommandBufferBeginInfo);
+	/*
+	 * transition layout & copy to buffer
+	 */
 
-		vkCmdPipelineBarrier(tmpBufferDetails.cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &vkImageMemoryBarrier);
+	PKVK_BeginBuffer(transferFamilyIndex, combined_mem_reqs.size, tmpBufferDetails);
 
-		VkBufferImageCopy vkBufferImageCopy;
-		vkBufferImageCopy.bufferOffset = 0;
-		vkBufferImageCopy.bufferRowLength = data->width;
-		vkBufferImageCopy.bufferImageHeight = data->height;
-		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 = data->width,
-			.height = data->height,
-			.depth = 1,
-		};
-		vkCmdCopyBufferToImage(tmpBufferDetails.cmdBuffer, tmpBufferDetails.buffer, out->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &vkBufferImageCopy);
+	// copy data to vulkan buffer
+	memcpy(tmpBufferDetails.deviceData, temp_buffer, combined_mem_reqs.size);
+	free(temp_buffer);
 
-		vkEndCommandBuffer(tmpBufferDetails.cmdBuffer);
+	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(tmpBufferDetails.cmdBuffer, &vkCommandBufferBeginInfo);
 
-		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 = &tmpBufferDetails.cmdBuffer;
-		submitInfo.signalSemaphoreCount = 0;
-		submitInfo.pSignalSemaphores = nullptr;
-		vkQueueSubmit(tmpBufferDetails.queue, 1, &submitInfo, nullptr);
-		vkQueueWaitIdle(tmpBufferDetails.queue);
-		vkResetCommandBuffer(tmpBufferDetails.cmdBuffer, 0);
+	vkCmdPipelineBarrier(tmpBufferDetails.cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, (uint32_t)data->n_textures, vkImageMemoryBarriers);
+
+	for (i = 0; i < data->n_textures; ++i) {
+		copy_buffer_to_image_2s[i].dstImage = out->images[i];
+		copy_buffer_to_image_2s[i].srcBuffer = tmpBufferDetails.buffer;
+		vkCmdCopyBufferToImage2(tmpBufferDetails.cmdBuffer, &copy_buffer_to_image_2s[i]);
 	}
+
+	vkEndCommandBuffer(tmpBufferDetails.cmdBuffer);
+
+	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 = &tmpBufferDetails.cmdBuffer;
+	submitInfo.signalSemaphoreCount = 0;
+	submitInfo.pSignalSemaphores = nullptr;
+	vkQueueSubmit(tmpBufferDetails.queue, 1, &submitInfo, nullptr);
+	vkQueueWaitIdle(tmpBufferDetails.queue);
+	vkResetCommandBuffer(tmpBufferDetails.cmdBuffer, 0);
+
 	PKVK_EndBuffer(tmpBufferDetails);
+
+	// update command buffer data
+	for (i = 0; i < data->n_textures; ++i) {
+		vkImageMemoryBarriers[i].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+		vkImageMemoryBarriers[i].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+		vkImageMemoryBarriers[i].oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+		vkImageMemoryBarriers[i].newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+	}
+
 	tmpBufferDetails = {};
 	PKVK_BeginBuffer(graphicsFamilyIndex, 0, tmpBufferDetails);
 	{
-		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 = out->image;
-		vkImageMemoryBarrier.subresourceRange = VkImageSubresourceRange {
-			.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-			.baseMipLevel = 0,
-			// TODO MipMap
-			.levelCount = 1,
-			.baseArrayLayer = 0,
-			.layerCount = 1,
-		};
 
 		VkCommandBufferBeginInfo vkCommandBufferBeginInfo;
 		vkCommandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
@@ -631,7 +685,7 @@ void pkvk_texture_upload(pkvk_texture_upload_data *data, pkvk_texture_upload_dat
 
 		vkBeginCommandBuffer(tmpBufferDetails.cmdBuffer, &vkCommandBufferBeginInfo);
 
-		vkCmdPipelineBarrier(tmpBufferDetails.cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &vkImageMemoryBarrier);
+		vkCmdPipelineBarrier(tmpBufferDetails.cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, (uint32_t)data->n_textures, vkImageMemoryBarriers);
 
 		vkEndCommandBuffer(tmpBufferDetails.cmdBuffer);
 
diff --git a/src/window.hpp b/src/window.hpp
index a07d29a..1df25b7 100644
--- a/src/window.hpp
+++ b/src/window.hpp
@@ -137,15 +137,15 @@ struct pkvk_buffer_create_data_out {
 // DOES NOT upload instance data
 void pkvk_buffer_create(pkvk_buffer_create_data *data, pkvk_buffer_create_data_out *out);
 
+#define PKVK_TEXTURE_UPLOAD_ARR_MAX_LENGTH 8
+
 struct pkvk_texture_upload_data {
-	void *bytes;
-	uint32_t n_bytes;
-	uint32_t width;
-	uint32_t height;
+	const Asset *texture_assets[PKVK_TEXTURE_UPLOAD_ARR_MAX_LENGTH];
+	uint8_t      n_textures;
 };
 struct pkvk_texture_upload_data_out {
-	VkImage image;
-	VkImageView image_view;
+	VkImage        images[PKVK_TEXTURE_UPLOAD_ARR_MAX_LENGTH];
+	VkImageView    image_views[PKVK_TEXTURE_UPLOAD_ARR_MAX_LENGTH];
 	VkDeviceMemory device_memory;
 };
 void pkvk_texture_upload(pkvk_texture_upload_data *data, pkvk_texture_upload_data_out *out);