@forgeax/engine-render 0.1.32 → 0.1.34

package/src/record/gpu-draw-receipts.ts

@@ -0,0 +1,38 @@
+import { gpuDrivenDrawKey, gpuDrivenSourceDrawItemIndex } from '../extract/gpu-driven';
+import type { RenderableSnapshot } from '../render-system-extract';
+import { worldEntityKey } from './frame-snapshot';
+
+/** Internal receipt for one concrete CPU/GPU presentation draw unit. */
+export interface RenderableDrawReceipt {
+  readonly lane: 'cpu' | 'gpu';
+  readonly ready: boolean;
+}
+
+/** Emit receipts only for draw items claimed by the GPU raster owner. */
+export function emitGpuDrivenDrawReceipts<
+  T extends {
+    readonly source: Pick<
+      RenderableSnapshot,
+      'worldId' | 'entityKey' | 'material' | 'materials' | 'gpuDrivenDraws'
+    >;
+  },
+>(
+  entry: T,
+  drawKeys: ReadonlySet<string>,
+  onRenderableDraw: (entry: T, submeshIndex: number, receipt: RenderableDrawReceipt) => void,
+): void {
+  for (const [compactIndex, draw] of (entry.source.gpuDrivenDraws ?? []).entries()) {
+    const material = entry.source.materials[draw.materialSlot] ?? entry.source.material;
+    const sourceDrawItemIndex = gpuDrivenSourceDrawItemIndex(draw, compactIndex);
+    const key = gpuDrivenDrawKey(
+      worldEntityKey(entry.source.worldId, entry.source.entityKey),
+      material.materialHandle ?? -1,
+      sourceDrawItemIndex,
+    );
+    if (!drawKeys.has(key)) continue;
+    onRenderableDraw(entry, draw.drawItemIndex ?? compactIndex, {
+      lane: 'gpu',
+      ready: true,
+    });
+  }
+}

package/src/record/gpu-timing.ts

@@ -19,6 +19,18 @@ const PASS_NAMES = [
   'volume-integrate',
   'volume-temporal',
   'volume-composite',
+  'cloud-layer-density-cache',
+  'cloud-layer-shadow',
+  'cloud-layer-composite',
+  'cloud-layer-depth',
+  'cloud-layer-history',
+] as const;
+const CLOUD_PASS_NAMES = [
+  'cloud-layer-density-cache',
+  'cloud-layer-shadow',
+  'cloud-layer-composite',
+  'cloud-layer-depth',
+  'cloud-layer-history',
 ] as const;
 
 type TimedPassKind = 'raster' | 'compute';
@@ -45,6 +57,11 @@ export type VolumeTimingObservation =
       /** Time from the first graph pass marker to the final graph marker. */
       readonly frameMs: number;
       readonly passes: readonly { readonly name: string; readonly milliseconds: number }[];
+      /** Cloud producer timings captured by the same physical timestamp lane. */
+      readonly cloud?: {
+        readonly totalMs: number;
+        readonly passes: readonly { readonly name: string; readonly milliseconds: number }[];
+      };
     }
   | {
       readonly status: 'unavailable';
@@ -258,13 +275,23 @@ export class GpuTimingCapture {
         const volumeDecoded = decoded.filter(({ name }) =>
           PASS_NAMES.includes(name as (typeof PASS_NAMES)[number]),
         );
-        const passes = volumeDecoded.map(({ name, begin, end }) => ({
+        const cloudDecoded = volumeDecoded.filter(({ name }) =>
+          CLOUD_PASS_NAMES.includes(name as (typeof CLOUD_PASS_NAMES)[number]),
+        );
+        const volumeOnlyDecoded = volumeDecoded.filter(
+          ({ name }) => !CLOUD_PASS_NAMES.includes(name as (typeof CLOUD_PASS_NAMES)[number]),
+        );
+        const passes = volumeOnlyDecoded.map(({ name, begin, end }) => ({
+          name,
+          milliseconds: (Number(end - begin) * this.#periodNanoseconds) / 1_000_000,
+        }));
+        const cloudPasses = cloudDecoded.map(({ name, begin, end }) => ({
           name,
           milliseconds: (Number(end - begin) * this.#periodNanoseconds) / 1_000_000,
         }));
         const frameMs = (Number(frameEnd - frameBegin) * this.#periodNanoseconds) / 1_000_000;
-        const firstBegin = volumeDecoded[0]?.begin;
-        const lastEnd = volumeDecoded[volumeDecoded.length - 1]?.end;
+        const firstBegin = volumeOnlyDecoded[0]?.begin;
+        const lastEnd = volumeOnlyDecoded[volumeOnlyDecoded.length - 1]?.end;
         const totalMs =
           firstBegin === undefined || lastEnd === undefined
             ? 0
@@ -274,11 +301,27 @@ export class GpuTimingCapture {
         if (
           !Number.isFinite(frameMs) ||
           !Number.isFinite(totalMs) ||
-          passes.some((pass) => !Number.isFinite(pass.milliseconds))
+          passes.some((pass) => !Number.isFinite(pass.milliseconds)) ||
+          cloudPasses.some((pass) => !Number.isFinite(pass.milliseconds))
         ) {
           return unavailable('timestamp query returned a non-finite duration');
         }
-        return Object.freeze({ status: 'ready', unit: 'ms', totalMs, frameMs, passes });
+        const cloudFirstBegin = cloudDecoded[0]?.begin;
+        const cloudLastEnd = cloudDecoded[cloudDecoded.length - 1]?.end;
+        const cloudTotalMs =
+          cloudFirstBegin === undefined || cloudLastEnd === undefined
+            ? 0
+            : (Number(cloudLastEnd - cloudFirstBegin) * this.#periodNanoseconds) / 1_000_000;
+        return Object.freeze({
+          status: 'ready',
+          unit: 'ms',
+          totalMs,
+          frameMs,
+          passes,
+          ...(cloudPasses.length === 0
+            ? {}
+            : { cloud: Object.freeze({ totalMs: cloudTotalMs, passes: cloudPasses }) }),
+        });
       })
       .catch((cause: unknown) => {
         this.#dispose();