Fixed broken framegraph resource copy

- Missed a relptr set

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,
+        char *read_write_dest =
-               rtResolveConstRelptr(&info->render_passes),
+            passes_begin + info->render_pass_count * sizeof(rt_render_pass_info);
-               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);
+            if (passes[i].read_render_target_count > 0) {
-            memcpy(read_write_dest,
+                const rt_render_target_read *reads =
-                   rtResolveConstRelptr(&passes[i].read_render_targets),
+                    rtResolveConstRelptr(&passes[i].read_render_targets);
-                   sizeof(rt_render_target_read) * passes[i].read_render_target_count);
+                rt_render_target_read *reads_dest = (rt_render_target_read *)read_write_dest;
-            read_write_dest += sizeof(rt_render_target_read) * passes[i].read_render_target_count;
+                rtSetRelptr(&passes_dest[i].read_render_targets, reads_dest);
-            rtSetRelptr(&passes_dest[i].write_render_targets, read_write_dest);
+                memcpy(reads_dest,
-            memcpy(read_write_dest,
+                       reads,
-                   rtResolveConstRelptr(&passes[i].write_render_targets),
+                       sizeof(rt_render_target_read) * passes[i].read_render_target_count);
-                   sizeof(rt_render_target_write) * passes[i].write_render_target_count);
+                read_write_dest +=
-            read_write_dest += sizeof(rt_render_target_write) * passes[i].write_render_target_count;
+                    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] : "<INVALID>");
         rtLog("RESMGR", "    bytecode: %zu bytes", shader->bytecode_length);
     } break;
+    case RT_RESOURCE_FRAMEGRAPH: {
+        static const char *format_str[RT_PIXEL_FORMAT_count] = {
+            "<INVALID>",
+
+            "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]
+                      : "<INVALID>");
+        }
+        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]
+                                                                    : "<INVALID>");
+            }
+            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);
     }