asset loading set up and cleaned up, working on fixing synchronization

src/game.c

@@ -74,7 +74,7 @@ gRunCycle(gGameCtx *ctx, pGameInput *inputs, u32 i_count)
 
 	u64 index = vFrameIndex();
 	
-	//rDescHandle yoder = rGetAsset("models/yoda");
+	rDescHandle yoder = rGetAsset("models/yoda");
 	
 	rViewportSize(&ctx->pc.res);
 	ctx->pc.time = (f32)pCPUTimerRead();
@@ -92,9 +92,9 @@ gRunCycle(gGameCtx *ctx, pGameInput *inputs, u32 i_count)
 	//rBufferBindGUIVertex();
 	//rBufferBindGUIIndex();
 
-	//rBufferBindMesh(&ctx->pc, yoder);
+	rBufferBindMesh(&ctx->pc, yoder);
 
-	//rDrawMesh(yoder);
+	rDrawMesh(yoder);
 
 	rFrameFinish();
 

src/renderer_vulkan.c

@@ -33,6 +33,137 @@ b32 v_rdoc_captured = false;
 
 
 
+// ::Vulkan::Wrappers::Start::
+
+static inline b32 
+vResetCommandBuffer(VkCommandBuffer cmd)
+{
+	// TODO: Handle device OOM case
+	VkResult result = vkResetCommandBuffer(cmd, 0);
+	if (result != VK_SUCCESS)
+		Printfln("vkResetCommandBuffer failure: %s", vVkResultStr(result));
+
+	return result == VK_SUCCESS;
+}
+
+static inline b32
+vResetFence(VkDevice device, VkFence fence)
+{
+	// TODO: Handle OOM case
+	VkFence f = fence;
+	VkResult result = vkResetFences(device, 1, &f);
+	if (result != VK_SUCCESS)
+		Printfln("vkResetFences failure: %s", vVkResultStr(result));
+
+	return result == VK_SUCCESS;
+}
+
+static inline b32
+vBeginCommandBuffer(VkCommandBuffer cmd)
+{
+	// TODO: handle host/device OOM cases
+	VkCommandBufferBeginInfo buf_info = {
+		.sType = STYPE(COMMAND_BUFFER_BEGIN_INFO),
+		.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+	};
+
+	VkResult result = vkBeginCommandBuffer(cmd, &buf_info);
+	if (result != VK_SUCCESS)
+		Printfln("vkBeginCommandBuffer failure: %s", vVkResultStr(result));
+
+	return result == VK_SUCCESS;
+}
+
+static inline b32 
+vEndCommandBuffer(VkCommandBuffer cmd)
+{
+	// TODO: handle host/device OOM cases
+	VkResult result = vkEndCommandBuffer(cmd);
+	if (result != VK_SUCCESS)
+	{
+		Printfln("vkEndCommandBuffer imm failure: %s", vVkResultStr(result));
+	}
+
+	return result == VK_SUCCESS;
+}
+
+static inline b32
+vQueueSubmit2Imm(VkCommandBuffer cmd, VkQueue queue, VkFence fence, VkSemaphore semaphore)
+{
+	// TODO: handle host/device OOM cases
+	// handle device list case
+	VkCommandBufferSubmitInfo cmd_submit_info = {
+		.sType = STYPE(COMMAND_BUFFER_SUBMIT_INFO),
+		.commandBuffer = cmd,
+	};
+
+	VkSemaphoreSubmitInfo sem_info = {
+		.sType = STYPE(SEMAPHORE_SUBMIT_INFO),
+		.semaphore = semaphore,
+		.stageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
+		.deviceIndex = 0, // hopefully it is just 0
+	};
+
+	VkSubmitInfo2 submit_info = {
+		.sType = STYPE(SUBMIT_INFO_2),
+		.commandBufferInfoCount = 1,
+		.pCommandBufferInfos = &cmd_submit_info,
+		.signalSemaphoreInfoCount = 1,
+		.pSignalSemaphoreInfos = &sem_info,
+	};
+
+	VkResult result = vkQueueSubmit2(queue, 1, &submit_info, fence);
+	if (result != VK_SUCCESS)
+	{
+		Printfln("vkQueueSubmit2 failure: %s", vVkResultStr(result));
+	}
+
+	return result == VK_SUCCESS;
+}
+
+static inline b32 
+vQueueSubmit2(VkCommandBuffer cmd, VkQueue queue, VkFence fence)
+{
+	// TODO: handle host/device OOM cases
+	// handle device list case
+	VkCommandBufferSubmitInfo cmd_submit_info = {
+		.sType = STYPE(COMMAND_BUFFER_SUBMIT_INFO),
+		.commandBuffer = cmd,
+	};
+
+	VkSubmitInfo2 submit_info = {
+		.sType = STYPE(SUBMIT_INFO_2),
+		.commandBufferInfoCount = 1,
+		.pCommandBufferInfos = &cmd_submit_info,
+	};
+
+	VkResult result = vkQueueSubmit2(queue, 1, &submit_info, fence);
+	if (result != VK_SUCCESS)
+	{
+		Printfln("vkQueueSubmit2 failure: %s", vVkResultStr(result));
+	}
+
+	return result == VK_SUCCESS;
+}
+
+static inline b32
+vWaitForFence(VkDevice device, VkFence fence, u64 timeout)
+{
+	// TODO: handle timeout case (probably externally)
+	VkFence f = fence;
+	VkResult result = vkWaitForFences(device, 1, &f, true, timeout);
+	if (result != VK_SUCCESS)
+	{
+		Printfln("vkWaitForFences failure: %s", vVkResultStr(result));
+	}
+
+	return result == VK_SUCCESS;
+}
+
+// ::Vulkan::Wrappers::End::
+
+
+
 // ::Vulkan::Util::Functions::Start::
 
 static inline u32 
@@ -223,88 +354,31 @@ vRenderingBegin()
 static b32
 vImmSubmitBegin(VkDevice device, VkFence fence, VkCommandBuffer cmd)
 {
-	b32 success = true;
+	b32 success = vResetFence(device, fence);
 
-	VkFence f = fence;
+	if (success)
-	VkResult result = vkResetFences(device, 1, &f);
-	if (result != VK_SUCCESS)
 	{
-		Printfln("vkResetFences failure: %s", vVkResultStr(result));
+		success = vResetCommandBuffer(cmd);
-		success = false;
 	}
 
 	if (success)
 	{
-		result = vkResetCommandBuffer(cmd, 0);
+		success = vBeginCommandBuffer(cmd);
-		if (result != VK_SUCCESS)
-		{
-			Printfln("vkResetCommandBuffer failure: %s", vVkResultStr(result));
-			success = false;
-		}
-	}
-
-	if (success)
-	{
-		VkCommandBufferBeginInfo buf_info = {
-			.sType = STYPE(COMMAND_BUFFER_BEGIN_INFO),
-			.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
-		};
-
-		result = vkBeginCommandBuffer(cmd, &buf_info);
-		if (result != VK_SUCCESS)
-		{
-			Printfln("vkBeginCommandBuffer failure: %s", vVkResultStr(result));
-			success = false;
-		}
 	}
 
 	return success;
 }
 
 static b32 
-vImmSubmitFinish(VkDevice device, VkFence fence, VkCommandBuffer cmd, VkQueue queue)
+vImmSubmitFinish(VkDevice device, VkFence fence, VkCommandBuffer cmd, VkQueue queue, VkSemaphore semaphore)
 {
-	b32 success = true;
+	b32 success = vEndCommandBuffer(cmd);
-	VkFence f = fence;
-
-	VkResult result = vkEndCommandBuffer(cmd);
-	if (result != VK_SUCCESS)
-	{
-		Printfln("vkEndCommandBuffer imm failure: %s", vVkResultStr(result));
-		success = false;
-	}
 
 	if (success)
-	{
+		success = vQueueSubmit2Imm(cmd, queue, fence, semaphore);
-		VkCommandBufferSubmitInfo cmd_submit_info = {
-			.sType = STYPE(COMMAND_BUFFER_SUBMIT_INFO),
-			.commandBuffer = cmd,
-		};
-
-		VkSubmitInfo2 submit_info = {
-			.sType = STYPE(SUBMIT_INFO_2),
-			.commandBufferInfoCount = 1,
-			.pCommandBufferInfos = &cmd_submit_info,
-		};
-
-		result = vkQueueSubmit2(queue, 1, &submit_info, f);
-		if (result != VK_SUCCESS)
-		{
-			Printfln("vkQueueSubmit2 imm failure: %s", vVkResultStr(result));
-			success = false;
-		}
-	}
 
 	if (success)
-	{
+		success = vWaitForFence(device, fence, 9999999999);
-		result = vkWaitForFences(device, 1, &f, true, 9999999999);
-		Printfln("fence waited");
-		if (result != VK_SUCCESS)
-		{
-			Printfln("vkWaitForFences imm failure: %s", vVkResultStr(result));
-			success = false;
-		}
-	}
 
 	return success;
 }
@@ -351,6 +425,8 @@ vImageViewInit(vImageView *view, u32 width, u32 height, u32 channels)
 {
 	b32 success = true;
 
+	view->image.layout = VK_IMAGE_LAYOUT_UNDEFINED;
+
 	VmaAllocationCreateInfo alloc_create_info = {
 		.usage = VMA_MEMORY_USAGE_GPU_ONLY,
 		.requiredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
@@ -389,6 +465,8 @@ vImageViewInit(vImageView *view, u32 width, u32 height, u32 channels)
 		success = false;
 	}
 
+	if (success)
+	{
 		VkImageViewCreateInfo view_info = {
 			.sType = STYPE(IMAGE_VIEW_CREATE_INFO),
 			.image = view->image.image,
@@ -407,6 +485,7 @@ vImageViewInit(vImageView *view, u32 width, u32 height, u32 channels)
 			Printfln("vImageViewInit error: vkCreateImageView failure: %s", vVkResultStr(result));
 			success = false;
 		}
+	}
 
 	return success;
 }
@@ -419,7 +498,7 @@ vImageViewInit(vImageView *view, u32 width, u32 height, u32 channels)
 
 // TODO: batch descriptor writes
 static u32 
-vDescPushImageDesc(vImageView *view)
+vDescWriteImage(vImageView *view)
 {
 	u32 index = vDescIndexPop(vDT_SAMPLED_IMAGE);
 
@@ -444,7 +523,7 @@ vDescPushImageDesc(vImageView *view)
 }
 
 static u32 
-vDescPushMeshDesc(vMeshBuffer *buffer)
+vDescWriteMesh(vMeshBuffer *buffer)
 {
 	u32 index = vDescIndexPop(vDT_MESH);
 
@@ -622,25 +701,60 @@ vMapBuffer(VmaAllocation alloc)
 static b32
 vTransferBufferCopy(vMappedBuffer *transfer, vCopyTarget *target)
 {
-	u64 rem_data = target->data.len - target->offset;
+	u64 rem_data = target->data.len - target->ptr_offset;
 	u64 rem_tfer = transfer->data.len - transfer->offset;
 	u64 copy_len = Minu64(rem_data, rem_tfer);
 
-	rawptr data_ptr = PtrAdd(target->data.ptr, target->offset);
+	rawptr data_ptr = PtrAdd(target->data.ptr, target->ptr_offset);
 	rawptr tfer_ptr = PtrAdd(transfer->data.ptr, transfer->offset);
 
 	MemCpy(tfer_ptr, data_ptr, copy_len);
 
+	target->transfer_offset = transfer->offset;
+	target->transfer_len = copy_len; 
+
 	transfer->offset += copy_len;
-	target->offset += copy_len;
+	target->copy_offset = target->ptr_offset;
+	target->ptr_offset += copy_len;
 
 	return transfer->offset == transfer->data.len;
 }
 
-static b32
+static void
-vBufferCopy()
+vBufferCopy(VkCommandBuffer cmd, vMappedBuffer *transfer, vCopyTarget *target, vBuffer *buffer)
 {
+	VkBufferCopy copy = {
+		.srcOffset = target->transfer_offset,
+		.dstOffset = target->copy_offset,
+		.size = target->transfer_len,
+	};
 
+	vkCmdCopyBuffer(cmd, transfer->alloc.buffer, buffer->buffer, 1, &copy);
+}
+
+static void
+vImageCopy(VkCommandBuffer cmd, vMappedBuffer *transfer, vCopyTarget *target, vImage *image, TexMeta *meta)
+{
+	VkBufferImageCopy copy = {
+		.bufferRowLength = meta->w,
+		.bufferImageHeight = meta->h,
+		.imageSubresource = {
+			.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+			.layerCount = 1,
+		},
+		.imageExtent = {
+			.width = meta->w,
+			.height = meta->h,
+			.depth = 1,
+		},
+		.bufferOffset = target->transfer_offset,
+	};
+
+	vImageTransition(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+
+	vkCmdCopyBufferToImage(cmd, transfer->alloc.buffer, image->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
+
+	vImageTransition(cmd, image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 }
 
 // ::Vulkan::Transfers::End::
@@ -654,7 +768,10 @@ vCopyTargetSet(vCopyTarget *target, rawptr data, u64 len)
 {
 	target->data.ptr = data;
 	target->data.len = len;
-	target->offset = 0;
+	target->transfer_offset = 0;
+	target->transfer_len = 0;
+	target->copy_offset = 0;
+	target->ptr_offset = 0;
 }
 
 static b32 
@@ -1137,6 +1254,7 @@ vDeviceFunctionsInit()
 	INIT_DEV_FN(vkCreateSampler);
 	INIT_DEV_FN(vkDestroySampler);
 	INIT_DEV_FN(vkGetBufferDeviceAddress);
+	INIT_DEV_FN(vkWaitSemaphores);
 
 	return true;
 }
@@ -1511,7 +1629,6 @@ vDescriptorsInit()
 	{
 		for (u32 i = 0; i < vDT_MAX; i++)
 		{
-			// FREE MIGHT BE NULL
 			bindings[i].free = ArenaAlloc(v_Renderer.mem.perm_arena, sizeof(u32) * DESC_MAX_BINDINGS);
 
 			HashTableInit(&bindings[i].lookup_table, 6);
@@ -1762,117 +1879,216 @@ vAssetsInit()
 
 	InitArrayType(buf->assets, arena, vAsset, RENDERER_ASSET_MAX);
 
+	VkSemaphoreCreateInfo sem_info = { .sType = STYPE(SEMAPHORE_CREATE_INFO) };
+
+	VkSemaphore semaphores[RENDERER_ASSET_MAX];
+
+	for (u32 i = 0; i < RENDERER_ASSET_MAX; i += 1)
+	{
+		Assert(vkCreateSemaphore(device, &sem_info, NULL, &semaphores[i]) == VK_SUCCESS, "Unable to create semaphore");
+	}
+
 	Assert(vImmSubmitBegin(device, fence, cmd), "Unable to begin immediate submit");
 
+	vCopyTarget copy_target;
+
+	b32 imm_started = false;
+	b32 asset_started = false;
 	u64 asset_index = 0;
-	for (u64 i = 0; i < TEXTURE_ASSET_MAX; i++, asset_index++)
+	u64 i;
+	for (i = 0; i < TEXTURE_ASSET_MAX;)
 	{
-		u64 hash = g_Texture_Asset_Hashes[i];
+		static TexMeta *meta;
-		Asset asset = apLoadWithHash(hash);
+		static u64 hash;
-		vImageView *view = vImageViewCreate(asset.texture_meta);
+		static Asset asset;
+		static vImageView *view;
+
+		if (!asset_started)
+		{
+			meta = &asset.texture_meta;
+			hash = g_Texture_Asset_Hashes[i];
+			asset = apLoadWithHash(hash);
+			view = vImageViewCreate(asset.texture_meta);
 			Assert(view != NULL, "Unable to create vImageView");
 
+			vCopyTargetSet(&copy_target, asset.bytes, meta->w * meta->h * meta->ch);
+			asset_started = true;
+		}
 
-		VkBufferImageCopy copy = {
+		if (!imm_started)
-			.bufferRowLength = asset.texture_meta.w,
+		{
-			.bufferImageHeight = asset.texture_meta.h,
+			Assert(vImmSubmitBegin(device, fence, cmd), "Unable to begin immediate submit");
-			.imageSubresource = {
+			imm_started = true;
-				.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+		}
-				.layerCount = 1,
-			},
-			.imageExtent = {
-				.width = asset.texture_meta.w,
-				.height = asset.texture_meta.h,
-				.depth = 1,
-			},
-			.bufferOffset = 0,
-		};
 
-		MemCpy(transfer->data.ptr, asset.bytes, asset.len);
+		b32 transfer_full = vTransferBufferCopy(transfer, &copy_target);
-
+		vImageCopy(cmd, transfer, &copy_target, &view->image, meta);
-		vImageTransitionLayout(cmd, view->image.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
-		vkCmdCopyBufferToImage(cmd, transfer->alloc.buffer, view->image.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
-		vImageTransitionLayout(cmd, view->image.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 
+		if (transfer_full)
+		{
+			Assert(vImmSubmitFinish(device, fence, cmd, queue, semaphores[asset_index]), "Unable to finish immediate submit");
+			imm_started = false;
+		}
+		else
+		{
 			vAsset *asset_data = buf->assets.data + asset_index;
 			asset_data->hash = hash;
 			asset_data->handle.asset_index = asset_index;
-		asset_data->handle.desc_index = vDescPushImageDesc(view);
+			asset_data->handle.desc_index = vDescWriteImage(view);
 			asset_data->texture_meta = asset.texture_meta;
 			asset_data->texture = view;
 
 			apUnloadWithHash(hash);
+
+			asset_started = false;
+
+			i += 1;
+			asset_index += 1;
+		}
 	}
 
-	for (u64 i = 0; i < MODEL_ASSET_MAX; i++, asset_index++)
+	asset_started = false;
-	{
+
-		u64 hash = g_Model_Asset_Hashes[i];
+	for (i = 0; i < MODEL_ASSET_MAX;)
-		Asset asset = apLoadWithHash(hash);
+	{
+		static u64 hash;
+		static Asset asset;
+		static vMeshAsset *buffer;
+		static vMesh *mesh_addr;
+		static b32 addr_started, addr_loaded, mesh_started, mesh_loaded, index_started, index_loaded; 
+
+		if (!asset_started)
+		{
+			addr_started = false;
+			addr_loaded = false;
+			mesh_started = false;
+			mesh_loaded = false;
+			index_started = false;
+			index_loaded = false;
+
+			hash = g_Model_Asset_Hashes[i];
+			asset = apLoadWithHash(hash);
+			buffer = FLMemAlloc(sizeof(vMeshAsset));
+			mesh_addr = FLMemAlloc(sizeof(vMesh));
 
-		vMeshAsset *buffer = FLMemAlloc(sizeof(vMeshAsset));
 			Assert(vBufferCreate(&buffer->mesh.mesh, rRBT_ADDR | rRBT_STORAGE, sizeof(Vertex) * asset.model->v_count) == VK_SUCCESS, "Unable to create mesh buffer");
 			Assert(vBufferCreate(&buffer->mesh.uniform, rRBT_UNIFORM, sizeof(vMesh)) == VK_SUCCESS, "Unable to create uniform buffer");
 			Assert(vBufferCreate(&buffer->index, rRBT_INDEX, sizeof(u32) * asset.model->i_count) == VK_SUCCESS, "Unable to create index buffer");
 
+			asset_started = true;
+		}
+
+		if (!imm_started)
+		{
+			Assert(vImmSubmitBegin(device, fence, cmd), "Unable to start immediate submit");
+			imm_started = true;
+		}
+
+		if (!addr_started)
+		{
 			VkBufferDeviceAddressInfo addr_info = {
 				.sType = STYPE(BUFFER_DEVICE_ADDRESS_INFO),
 				.buffer = buffer->mesh.mesh.buffer,
 			};
 
-		vMesh mesh = {
+			mesh_addr->vertices = vkGetBufferDeviceAddress(device, &addr_info);
-			.vertices = vkGetBufferDeviceAddress(device, &addr_info),
-		};
 
-		VkBufferCopy uniform_copy = {
+			vCopyTargetSet(&copy_target, mesh_addr, sizeof(vMesh));
-			.srcOffset = 0,
-			.dstOffset = 0,
-			.size = sizeof(vMesh),
-		};
 
-		rawptr ptr = transfer->data.ptr;
+			addr_started = true;
+		}
 
-		MemCpy(ptr, &mesh, sizeof(vMesh));
+		if (addr_started && !addr_loaded)
+		{
+			b32 transfer_full = vTransferBufferCopy(transfer, &copy_target);
+			vBufferCopy(cmd, transfer, &copy_target, &buffer->mesh.uniform);
 
-		ptr = PtrAdd(ptr, sizeof(vMesh));
+			if (!transfer_full)
-		u64 offset = sizeof(vMesh);
+			{
+				addr_loaded = true;
+			}
+			else
+			{
+				Assert(vImmSubmitFinish(device, fence, cmd, queue, semaphores[asset_index]), "Unable to finish immediate submit");
+				imm_started = false;
+			}
+		}
 
-		u64 vertex_size = sizeof(Vertex) * asset.model->v_count;
+		if (addr_loaded && !mesh_started)
-		VkBufferCopy mesh_copy = {
+		{
-			.srcOffset = offset,
+			vCopyTargetSet(&copy_target, asset.model->vertices, asset.model->v_count * sizeof(Vertex));
-			.dstOffset = 0,
+			mesh_started = true;
-			.size = vertex_size,
+		}
-		};
 
-		MemCpy(ptr, asset.model->vertices, vertex_size);
+		if (mesh_started && !mesh_loaded)
+		{
+			b32 transfer_full = vTransferBufferCopy(transfer, &copy_target);
+			vBufferCopy(cmd, transfer, &copy_target, &buffer->mesh.mesh);
+			if (!transfer_full)
+			{
+				mesh_loaded = true;
+			}
+			else
+			{
+				Assert(vImmSubmitFinish(device, fence, cmd, queue, semaphores[asset_index]), "Unable to finish immediate submit");
+				imm_started = false;
+			}
+		}
 
-		ptr = PtrAdd(ptr, vertex_size);
+		if (mesh_loaded && !index_started)
-		offset += vertex_size;
+		{
+			vCopyTargetSet(&copy_target, asset.model->indices, asset.model->i_count * sizeof(u32));
+			index_started = true;
+		}
 
-		u64 index_size = sizeof(u32) * asset.model->i_count;
+		if (index_started && !index_loaded)
-		VkBufferCopy index_copy = {
+		{
-			.srcOffset = offset,
+			b32 transfer_full = vTransferBufferCopy(transfer, &copy_target);
-			.dstOffset = 0,
+			vBufferCopy(cmd, transfer, &copy_target, &buffer->index);
-			.size = index_size,
+			if (!transfer_full)
-		};
+			{
-
+				index_loaded = true;
-		offset += sizeof(Vertex) * asset.model->v_count;
+			}
-		MemCpy(ptr, asset.model->indices, index_size);
+			else
-
+			{
-		vkCmdCopyBuffer(cmd, transfer->alloc.buffer, buffer->mesh.uniform.buffer, 1, &uniform_copy);
+				Assert(vImmSubmitFinish(device, fence, cmd, queue, semaphores[asset_index]), "Unable to finish immediate submit");
-		vkCmdCopyBuffer(cmd, transfer->alloc.buffer, buffer->mesh.mesh.buffer, 1, &mesh_copy);
+				imm_started = false;
-		vkCmdCopyBuffer(cmd, transfer->alloc.buffer, buffer->index.buffer, 1, &index_copy);
+			}
+		}
 		
+		if (index_loaded)
+		{
 			vAsset *asset_data = buf->assets.data + asset_index;
 			asset_data->hash = hash;
 			asset_data->handle.asset_index = asset_index;
-		asset_data->handle.desc_index = vDescPushMeshDesc(&buffer->mesh);
+			asset_data->handle.desc_index = vDescWriteMesh(&buffer->mesh);
 			asset_data->model_meta = asset.model_meta;
 			asset_data->mesh = buffer;
 
 			apUnloadWithHash(hash);
+
+			asset_started = false;
+
+			i += 1;
+			asset_index += 1;
+		}
 	}
 
-	Assert(vImmSubmitFinish(device, fence, cmd, queue), "Unable to finish immediate submit");
+	if (imm_started)
+	{
+		Assert(vImmSubmitFinish(device, fence, cmd, queue, semaphores[asset_index]), "Unable to finish immediate submit");
+	}
+
+	u64 values[RENDERER_ASSET_MAX] = {1};
+
+	VkSemaphoreWaitInfo wait_info = {
+		.sType = STYPE(SEMAPHORE_WAIT_INFO),
+		.semaphoreCount = RENDERER_ASSET_MAX,
+		.pSemaphores = semaphores,
+		.pValues = values,
+	};
+
+	VkResult result = vkWaitSemaphores(device, &wait_info, 9999999999);
 
 	return true;
 }
@@ -1946,7 +2162,7 @@ vTransferUpload(vTransfer **transfers, u32 count)
 
 		if (ptr_pos == transfer->data.len)
 		{
-			vImmSubmitFinish(device, fence, buffer, queue);
+			//vImmSubmitFinish(device, fence, buffer, queue);
 			vkWaitForFences(device, 1, &fence, VK_TRUE, 999999999);
 			
 			ptr = transfer->data.ptr;
@@ -2075,7 +2291,9 @@ vTransferUpload(vTransfer **transfers, u32 count)
 	}
 
 	if (imm_started)
-		vImmSubmitFinish(device, fence, buffer, queue);
+	{
+		//vImmSubmitFinish(device, fence, buffer, queue);
+	}
 }
 
 #ifdef __linux__

src/renderer_vulkan.h

@@ -161,6 +161,7 @@ VK_DECLARE(vkCmdClearColorImage);
 VK_DECLARE(vkCreateSampler);
 VK_DECLARE(vkDestroySampler);
 VK_DECLARE(vkGetBufferDeviceAddress);
+VK_DECLARE(vkWaitSemaphores);
 
 #include "vma/vk_mem_alloc.h"
 
@@ -199,7 +200,10 @@ typedef struct vAssetInfo
 typedef struct vCopyTarget
 {
 	DataPtr data;
-	u64		  offset;
+	u64			copy_offset;
+	u64 		ptr_offset;
+	u64			transfer_offset;
+	u64			transfer_len;
 } vCopyTarget;
 
 typedef struct vDeviceQueues
@@ -530,6 +534,16 @@ static b32 vBuffersInit();
 static b32 vAssetsInit();
 static b32 vRenderDocInit();
 
+// ::Vulkan::Wrappers::Header::
+
+static inline b32 vResetCommandBuffer(VkCommandBuffer cmd);
+static inline b32 vResetFence(VkDevice device, VkFence fence);
+static inline b32 vBeginCommandBuffer(VkCommandBuffer cmd);
+static inline b32 vEndCommandBuffer(VkCommandBuffer cmd);
+static inline b32 vQueueSubmit2(VkCommandBuffer cmd, VkQueue queue, VkFence fence);
+static inline b32 vQueueSubmit2Imm(VkCommandBuffer cmd, VkQueue queue, VkFence fence, VkSemaphore semaphore);
+static inline b32 vWaitForFence(VkDevice device, VkFence fence, u64 timeout);
+
 // ::Vulkan::Util::Functions::Header::
 
 static inline VkCommandBuffer vFrameCmdBuf();
@@ -559,7 +573,7 @@ static void vLoader();
 // ::Vulkan::ImmediateSubmit::Functions::Header::
 
 static b32 vImmSubmitBegin(VkDevice device, VkFence fence, VkCommandBuffer cmd);
-static b32 vImmSubmitFinish(VkDevice device, VkFence fence, VkCommandBuffer cmd, VkQueue queue);
+static b32 vImmSubmitFinish(VkDevice device, VkFence fence, VkCommandBuffer cmd, VkQueue queue, VkSemaphore semaphore);
 
 // ::Vulkan::Rendering::Functions::Header::
 
@@ -584,8 +598,8 @@ static u32 vDescIndexPop(vDescType type);
 static rDescHandle vDescHandleSearch(vDescType type, u32 asset_id);
 static void vDescHandlePush(vDescType type, rDescHandle handle);
 static rDescHandle vDescHandlePop(vDescType type, u32 asset_id);
-static u32 vDescPushImageDesc(vImageView *view);
+static u32 vDescWriteImage(vImageView *view);
-static u32 vDescPushMeshDesc(vMeshBuffer *buffer);
+static u32 vDescWriteMesh(vMeshBuffer *buffer);
 
 // ::Vulkan::Assets::Functions::Header::
 
@@ -600,7 +614,8 @@ static rawptr vMapBuffer(VmaAllocation alloc);
 // ::Vulkan::Transfers::Header::
 
 static b32 vTransferBufferCopy(vMappedBuffer *transfer, vCopyTarget *target);
-static b32 vBufferCopy();
+static void vBufferCopy(VkCommandBuffer cmd, vMappedBuffer *transfer, vCopyTarget *target, vBuffer *buffer);
+static void vImageCopy(VkCommandBuffer cmd, vMappedBuffer *transfer, vCopyTarget *target, vImage *image, TexMeta *meta);
 
 // ::Vulkan::Misc::Header::