sleepy-day/Gears-C
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Matthew 2025-06-05 00:27:54 +10:00
parent d4146466ce
commit 4d16442bdd
3 changed files with 425 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/game.c
View File

@ -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();

586
src/renderer_vulkan.c
View File

@ -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, &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];
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(&copy_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, &copy);
vImageTransitionLayout(cmd, view->image.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
b32 transfer_full = vTransferBufferCopy(transfer, &copy_target);
vImageCopy(cmd, transfer, &copy_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(&copy_target, mesh_addr, sizeof(vMesh));
addr_started = true;
}
if (addr_started && !addr_loaded)
{
b32 transfer_full = vTransferBufferCopy(transfer, &copy_target);
vBufferCopy(cmd, transfer, &copy_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(&copy_target, asset.model->vertices, asset.model->v_count * sizeof(Vertex));
mesh_started = true;
}
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;
}
}
if (mesh_loaded && !index_started)
{
vCopyTargetSet(&copy_target, asset.model->indices, asset.model->i_count * sizeof(u32));
index_started = true;
}
if (index_started && !index_loaded)
{
b32 transfer_full = vTransferBufferCopy(transfer, &copy_target);
vBufferCopy(cmd, transfer, &copy_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__

25
src/renderer_vulkan.h
View File

@ -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::