From 18b548b8bbdf5415cbd28f8d37c2c0ce51f39b8b Mon Sep 17 00:00:00 2001 From: Kevin Trogant Date: Wed, 7 Feb 2024 17:02:23 +0100 Subject: [PATCH] Fixed broken framegraph resource copy - Missed a relptr set --- src/runtime/resource_manager.c | 130 ++++++++++++++++++++++++++++----- 1 file changed, 113 insertions(+), 17 deletions(-) diff --git a/src/runtime/resource_manager.c b/src/runtime/resource_manager.c index 3301e07..01920ce 100644 --- a/src/runtime/resource_manager.c +++ b/src/runtime/resource_manager.c @@ -131,30 +131,50 @@ static void CopyResourceData(const rt_resource *resource, void *dest) { const rt_framegraph_info *info = resource->data; rt_framegraph_info *dest_info = dest; memcpy(dest_info, info, sizeof(*info)); + memcpy(dest_info + 1, rtResolveConstRelptr(&info->render_targets), info->render_target_count * sizeof(rt_render_target_info)); rtSetRelptr(&dest_info->render_targets, (void *)(dest_info + 1)); + char *passes_begin = (char *)(dest_info + 1) + info->render_target_count * sizeof(rt_render_target_info); - memcpy(passes_begin, - rtResolveConstRelptr(&info->render_passes), - info->render_pass_count * sizeof(rt_render_pass_info)); - char *read_write_dest = passes_begin + info->render_pass_count * sizeof(rt_render_pass_info); + char *read_write_dest = + passes_begin + info->render_pass_count * sizeof(rt_render_pass_info); rt_render_pass_info *passes_dest = (rt_render_pass_info *)passes_begin; const rt_render_pass_info *passes = (const rt_render_pass_info *)rtResolveConstRelptr(&info->render_passes); + + memcpy(passes_dest, passes, info->render_pass_count * sizeof(rt_render_pass_info)); + rtSetRelptr(&dest_info->render_passes, passes_dest); + for (uint32_t i = 0; i < info->render_pass_count; ++i) { - rtSetRelptr(&passes_dest[i].read_render_targets, read_write_dest); - memcpy(read_write_dest, - rtResolveConstRelptr(&passes[i].read_render_targets), - sizeof(rt_render_target_read) * passes[i].read_render_target_count); - read_write_dest += sizeof(rt_render_target_read) * passes[i].read_render_target_count; - rtSetRelptr(&passes_dest[i].write_render_targets, read_write_dest); - memcpy(read_write_dest, - rtResolveConstRelptr(&passes[i].write_render_targets), - sizeof(rt_render_target_write) * passes[i].write_render_target_count); - read_write_dest += sizeof(rt_render_target_write) * passes[i].write_render_target_count; + if (passes[i].read_render_target_count > 0) { + const rt_render_target_read *reads = + rtResolveConstRelptr(&passes[i].read_render_targets); + rt_render_target_read *reads_dest = (rt_render_target_read *)read_write_dest; + rtSetRelptr(&passes_dest[i].read_render_targets, reads_dest); + memcpy(reads_dest, + reads, + sizeof(rt_render_target_read) * passes[i].read_render_target_count); + read_write_dest += + sizeof(rt_render_target_read) * passes[i].read_render_target_count; + } else { + rtSetRelptr(&passes_dest[i].read_render_targets, NULL); + } + if (passes[i].write_render_target_count > 0) { + const rt_render_target_write *writes = + rtResolveConstRelptr(&passes[i].write_render_targets); + rt_render_target_write *write_dest = (rt_render_target_write *)read_write_dest; + rtSetRelptr(&passes_dest[i].write_render_targets, write_dest); + memcpy(write_dest, + writes, + sizeof(rt_render_target_write) * passes[i].write_render_target_count); + read_write_dest += + sizeof(rt_render_target_write) * passes[i].write_render_target_count; + } else { + rtSetRelptr(&passes_dest[i].write_render_targets, NULL); + } } } break; default: @@ -797,7 +817,6 @@ RT_DLLEXPORT rt_resource_id rtGetResourceID(const char *name) { return id; } - RT_DLLEXPORT rt_result rtCreateResources(uint32_t count, const char **names, const rt_resource *resources, @@ -814,7 +833,7 @@ RT_DLLEXPORT rt_result rtCreateResources(uint32_t count, rtLockWrite(&_namespace.lock); for (uint32_t i = 0; i < count; ++i) { rt_resource_id id = rtGetResourceID(names[i]); - bool inserted = false; + bool inserted = false; for (size_t j = 0; j < ns_size; ++j) { size_t at = (id + j) % ns_size; if (_namespace.ids[at] == RT_INVALID_RESOURCE_ID) { @@ -901,7 +920,7 @@ out: } RT_DLLEXPORT void rDebugLogResource(rt_resource_id id, const rt_resource *resource) { - static const char *type_str[RT_RESOURCE_TYPE_count] = {"Shader", "Pipeline"}; + static const char *type_str[RT_RESOURCE_TYPE_count] = {"Shader", "Pipeline", "Framegraph"}; rtLog("RESMGR", "Resource %llx:", id); rtLog("RESMGR", " type: %s", @@ -971,6 +990,83 @@ RT_DLLEXPORT void rDebugLogResource(rt_resource_id id, const rt_resource *resour (shader->stage < RT_SHADER_STAGE_count) ? stage_str[shader->stage] : ""); rtLog("RESMGR", " bytecode: %zu bytes", shader->bytecode_length); } break; + case RT_RESOURCE_FRAMEGRAPH: { + static const char *format_str[RT_PIXEL_FORMAT_count] = { + "", + + "R8G8B8A8_UNORM", + "B8G8R8A8_UNORM", + "R8G8B8A8_SRGB", + "B8G8R8A8_SRGB", + "R8G8B8_UNORM", + "B8G8R8_UNORM", + "R8G8B8_SRGB", + "B8G8R8_SRGB", + "DEPTH24_STENCIL8", + "DEPTH32", + + "SWAPCHAIN", + }; + static const char *read_mode_str[RT_RENDER_TARGET_READ_count] = {"SAMPLED", + "INPUT_ATTACHMENT"}; + + const rt_framegraph_info *framegraph = resource->data; + rtLog("RESMGR", " framegraph data:"); + rtLog("RESMGR", " render targets:"); + const rt_render_target_info *render_targets = + rtResolveConstRelptr(&framegraph->render_targets); + for (uint32_t i = 0; i < framegraph->render_target_count; ++i) { + rtLog("RESMGR", " - %x", render_targets[i].id); + if (render_targets[i].width != RT_RENDER_TARGET_SIZE_SWAPCHAIN) + rtLog("RESMGR", + " size: %u x %u", + render_targets[i].width, + render_targets[i].height); + else + rtLog("RESMGR", " size: SWAPCHAIN SIZE"); + rtLog("RESMGR", " samples: %u", render_targets[i].sample_count); + rtLog("RESMGR", + " format: %s", + (render_targets[i].format < RT_PIXEL_FORMAT_count) + ? format_str[render_targets[i].format] + : ""); + } + rtLog("RESMGR", " passes:"); + const rt_render_pass_info *render_passes = rtResolveConstRelptr(&framegraph->render_passes); + for (uint32_t i = 0; i < framegraph->render_pass_count; ++i) { + rtLog("RESMGR", " - %x", render_passes[i].id); + rtLog("RESMGR", " reads:"); + const rt_render_target_read *reads = + rtResolveConstRelptr(&render_passes[i].read_render_targets); + for (uint32_t j = 0; j < render_passes[i].read_render_target_count; ++j) { + rtLog("RESMGR", " - %x", reads[j].render_target); + rtLog("RESMGR", + " mode: %s", + (reads[j].mode < RT_RENDER_TARGET_READ_count) ? read_mode_str[reads[j].mode] + : ""); + } + rtLog("RESMGR", " writes:"); + const rt_render_target_write *writes = + rtResolveConstRelptr(&render_passes[i].write_render_targets); + for (uint32_t j = 0; j < render_passes[i].write_render_target_count; ++j) { + rtLog("RESMGR", " - %x", writes[j].render_target); + rtLog("RESMGR", + " clear: %s", + (writes[j].flags & RT_RENDER_TARGET_WRITE_CLEAR) ? "YES" : "NO"); + rtLog("RESMGR", + " discard: %s", + (writes[j].flags & RT_RENDER_TARGET_WRITE_DISCARD) ? "YES" : "NO"); + rtLog("RESMGR", + " clear_value: {rgba: {%f %f %f %f}, ds: {%f %u}}", + writes[j].clear.color.r, + writes[j].clear.color.g, + writes[j].clear.color.b, + writes[j].clear.color.a, + writes[j].clear.depth_stencil.depth, + writes[j].clear.depth_stencil.stencil); + } + } + } break; default: rtLog("RESMGR", " unknown data at: %llx", (uintptr_t)resource->data); }