From 4d16442bdd5e295cc20a9a0bad6ee95006269876 Mon Sep 17 00:00:00 2001 From: Matthew Date: Thu, 5 Jun 2025 00:27:54 +1000 Subject: [PATCH] asset loading set up and cleaned up, working on fixing synchronization --- src/game.c | 6 +- src/renderer_vulkan.c | 586 +++++++++++++++++++++++++++++------------- src/renderer_vulkan.h | 25 +- 3 files changed, 425 insertions(+), 192 deletions(-) diff --git a/src/game.c b/src/game.c index 31fdfd7..7c1e7d2 100644 --- a/src/game.c +++ b/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(); diff --git a/src/renderer_vulkan.c b/src/renderer_vulkan.c index 859aa57..2a2a650 100644 --- a/src/renderer_vulkan.c +++ b/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; - VkResult result = vkResetFences(device, 1, &f); - if (result != VK_SUCCESS) + if (success) { - Printfln("vkResetFences failure: %s", vVkResultStr(result)); - success = false; + success = vResetCommandBuffer(cmd); } if (success) { - result = vkResetCommandBuffer(cmd, 0); - 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; - } + success = vBeginCommandBuffer(cmd); } 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; - VkFence f = fence; - - VkResult result = vkEndCommandBuffer(cmd); - if (result != VK_SUCCESS) - { - Printfln("vkEndCommandBuffer imm failure: %s", vVkResultStr(result)); - success = false; - } + b32 success = vEndCommandBuffer(cmd); if (success) - { - 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; - } - } + success = vQueueSubmit2Imm(cmd, queue, fence, semaphore); if (success) - { - result = vkWaitForFences(device, 1, &f, true, 9999999999); - Printfln("fence waited"); - if (result != VK_SUCCESS) - { - Printfln("vkWaitForFences imm failure: %s", vVkResultStr(result)); - success = false; - } - } + success = vWaitForFence(device, fence, 9999999999); 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,23 +465,26 @@ vImageViewInit(vImageView *view, u32 width, u32 height, u32 channels) success = false; } - VkImageViewCreateInfo view_info = { - .sType = STYPE(IMAGE_VIEW_CREATE_INFO), - .image = view->image.image, - .viewType = VK_IMAGE_VIEW_TYPE_2D, - .format = VK_FORMAT_R8G8B8A8_SRGB, - .subresourceRange = { - .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, - .levelCount = 1, - .layerCount = 1, - }, - }; - - result = vkCreateImageView(v_Renderer.handles.device, &view_info, NULL, &view->view); - if (result != VK_SUCCESS) + if (success) { - Printfln("vImageViewInit error: vkCreateImageView failure: %s", vVkResultStr(result)); - success = false; + VkImageViewCreateInfo view_info = { + .sType = STYPE(IMAGE_VIEW_CREATE_INFO), + .image = view->image.image, + .viewType = VK_IMAGE_VIEW_TYPE_2D, + .format = VK_FORMAT_R8G8B8A8_SRGB, + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .levelCount = 1, + .layerCount = 1, + }, + }; + + result = vkCreateImageView(v_Renderer.handles.device, &view_info, NULL, &view->view); + if (result != VK_SUCCESS) + { + 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 -vBufferCopy() +static void +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, ©); +} + +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, ©); + + 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]; - Asset asset = apLoadWithHash(hash); - vImageView *view = vImageViewCreate(asset.texture_meta); - Assert(view != NULL, "Unable to create vImageView"); + static TexMeta *meta; + static u64 hash; + 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"); - VkBufferImageCopy copy = { - .bufferRowLength = asset.texture_meta.w, - .bufferImageHeight = asset.texture_meta.h, - .imageSubresource = { - .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, - .layerCount = 1, - }, - .imageExtent = { - .width = asset.texture_meta.w, - .height = asset.texture_meta.h, - .depth = 1, - }, - .bufferOffset = 0, - }; + vCopyTargetSet(©_target, asset.bytes, meta->w * meta->h * meta->ch); + asset_started = true; + } - MemCpy(transfer->data.ptr, asset.bytes, asset.len); + if (!imm_started) + { + Assert(vImmSubmitBegin(device, fence, cmd), "Unable to begin immediate submit"); + imm_started = true; + } - 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, ©); - vImageTransitionLayout(cmd, view->image.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + b32 transfer_full = vTransferBufferCopy(transfer, ©_target); + vImageCopy(cmd, transfer, ©_target, &view->image, meta); - 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->texture_meta = asset.texture_meta; - asset_data->texture = view; + 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 = vDescWriteImage(view); + asset_data->texture_meta = asset.texture_meta; + asset_data->texture = view; - apUnloadWithHash(hash); + apUnloadWithHash(hash); + + asset_started = false; + + i += 1; + asset_index += 1; + } } - for (u64 i = 0; i < MODEL_ASSET_MAX; i++, asset_index++) + asset_started = false; + + for (i = 0; i < MODEL_ASSET_MAX;) { - u64 hash = g_Model_Asset_Hashes[i]; - 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)); + + 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, + }; + + mesh_addr->vertices = vkGetBufferDeviceAddress(device, &addr_info); + + vCopyTargetSet(©_target, mesh_addr, sizeof(vMesh)); + + addr_started = true; + } + + if (addr_started && !addr_loaded) + { + b32 transfer_full = vTransferBufferCopy(transfer, ©_target); + vBufferCopy(cmd, transfer, ©_target, &buffer->mesh.uniform); + + if (!transfer_full) + { + addr_loaded = true; + } + else + { + Assert(vImmSubmitFinish(device, fence, cmd, queue, semaphores[asset_index]), "Unable to finish immediate submit"); + imm_started = false; + } + } + + if (addr_loaded && !mesh_started) + { + vCopyTargetSet(©_target, asset.model->vertices, asset.model->v_count * sizeof(Vertex)); + mesh_started = true; + } + + if (mesh_started && !mesh_loaded) + { + b32 transfer_full = vTransferBufferCopy(transfer, ©_target); + vBufferCopy(cmd, transfer, ©_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; + } + } + + if (mesh_loaded && !index_started) + { + vCopyTargetSet(©_target, asset.model->indices, asset.model->i_count * sizeof(u32)); + index_started = true; + } + + if (index_started && !index_loaded) + { + b32 transfer_full = vTransferBufferCopy(transfer, ©_target); + vBufferCopy(cmd, transfer, ©_target, &buffer->index); + if (!transfer_full) + { + index_loaded = true; + } + else + { + Assert(vImmSubmitFinish(device, fence, cmd, queue, semaphores[asset_index]), "Unable to finish immediate submit"); + imm_started = false; + } + } - 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"); + 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 = vDescWriteMesh(&buffer->mesh); + asset_data->model_meta = asset.model_meta; + asset_data->mesh = buffer; - VkBufferDeviceAddressInfo addr_info = { - .sType = STYPE(BUFFER_DEVICE_ADDRESS_INFO), - .buffer = buffer->mesh.mesh.buffer, - }; + apUnloadWithHash(hash); - vMesh mesh = { - .vertices = vkGetBufferDeviceAddress(device, &addr_info), - }; + asset_started = false; - VkBufferCopy uniform_copy = { - .srcOffset = 0, - .dstOffset = 0, - .size = sizeof(vMesh), - }; - - rawptr ptr = transfer->data.ptr; - - MemCpy(ptr, &mesh, sizeof(vMesh)); - - ptr = PtrAdd(ptr, sizeof(vMesh)); - u64 offset = sizeof(vMesh); - - u64 vertex_size = sizeof(Vertex) * asset.model->v_count; - VkBufferCopy mesh_copy = { - .srcOffset = offset, - .dstOffset = 0, - .size = vertex_size, - }; - - MemCpy(ptr, asset.model->vertices, vertex_size); - - ptr = PtrAdd(ptr, vertex_size); - offset += vertex_size; - - u64 index_size = sizeof(u32) * asset.model->i_count; - VkBufferCopy index_copy = { - .srcOffset = offset, - .dstOffset = 0, - .size = index_size, - }; - - offset += sizeof(Vertex) * asset.model->v_count; - MemCpy(ptr, asset.model->indices, index_size); - - vkCmdCopyBuffer(cmd, transfer->alloc.buffer, buffer->mesh.uniform.buffer, 1, &uniform_copy); - vkCmdCopyBuffer(cmd, transfer->alloc.buffer, buffer->mesh.mesh.buffer, 1, &mesh_copy); - vkCmdCopyBuffer(cmd, transfer->alloc.buffer, buffer->index.buffer, 1, &index_copy); - - 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->model_meta = asset.model_meta; - asset_data->mesh = buffer; - - apUnloadWithHash(hash); + 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__ diff --git a/src/renderer_vulkan.h b/src/renderer_vulkan.h index 9e5cf39..e216b72 100644 --- a/src/renderer_vulkan.h +++ b/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 vDescPushMeshDesc(vMeshBuffer *buffer); +static u32 vDescWriteImage(vImageView *view); +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::