@woosh/meep-engine 3.12.0 → 3.13.1

package/src/shade/device/timing/ShadeGPUContextProfiler.js

@@ -0,0 +1,182 @@
+import { assert } from "../../../core/assert.js";
+import { ShadeGPUComputePassEncoder } from "../pass/ShadeGPUComputePassEncoder.js";
+import { ShadeGPURenderPassEncoder } from "../pass/ShadeGPURenderPassEncoder.js";
+import { GPUTimerArray } from "./GPUTimerArray.js";
+
+/**
+ * Everything one {@link ShadeGPUCommandContext} needs in order to be profiled: its timer array, the
+ * recorder its timings go to, and which query set it is within the frame.
+ *
+ * **It opens the passes itself.** Two values are needed at two different instants — the
+ * `timestampWrites` before the encoder exists, the {@link GPUProfileWork} after — and any shape that
+ * hands both back to the caller has to carry them across that gap. The predecessor carried them in a
+ * private field on the command context, consumed by whatever ran next, which is the kind of coupling
+ * that breaks the moment a line is inserted between the two halves. Handing the profiler the encoder
+ * collapses the gap: both values are produced and consumed inside one method and there is nothing to
+ * carry.
+ *
+ * Off by default and constructed only by `enable_profiling`, so a context that is not being profiled
+ * holds one null field and allocates no query set.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ShadeGPUContextProfiler {
+
+    /**
+     * @type {GPUTimerArray}
+     */
+    #timers;
+
+    /**
+     * @type {GPUFrameRecorder}
+     */
+    #recorder;
+
+    /**
+     * Which query set this context is, within its frame. Carried into every span it records —
+     * timestamps from two query sets are not specified to share a clock domain, and a frame has one
+     * set per context.
+     *
+     * @type {number}
+     */
+    #query_set_id;
+
+    /**
+     * @type {Promise<void>}
+     */
+    #absorbed;
+
+    /**
+     * @type {function}
+     */
+    #absorbed_resolve;
+
+    /**
+     * @param {GPUDevice} device
+     * @param {GPUFrameRecorder} recorder
+     * @param {number} query_set_id this context's index within the frame
+     */
+    constructor(device, recorder, query_set_id) {
+        assert.defined(device, 'device');
+        assert.defined(recorder, 'recorder');
+        assert.isNonNegativeInteger(query_set_id, 'query_set_id');
+
+        this.#timers = new GPUTimerArray(device);
+        this.#recorder = recorder;
+        this.#query_set_id = query_set_id;
+
+        this.#absorbed = new Promise(resolve => {
+            this.#absorbed_resolve = resolve;
+        });
+    }
+
+    /**
+     * Resolves after this context's timings have been read back and handed to the recorder.
+     *
+     * @returns {Promise<void>}
+     */
+    get absorbed() {
+        return this.#absorbed;
+    }
+
+    /**
+     * @param {GPUCommandEncoder} encoder
+     * @param {GPUComputePassDescriptor} [descriptor]
+     * @returns {ShadeGPUComputePassEncoder}
+     */
+    begin_compute_pass(encoder, descriptor) {
+        const writes = this.#timers.getComputeWrites(descriptor?.label);
+
+        if (writes === undefined) {
+            return new ShadeGPUComputePassEncoder(encoder.beginComputePass(descriptor), null);
+        }
+
+        const gpu_pass = encoder.beginComputePass(this.#timed(descriptor, writes));
+
+        return new ShadeGPUComputePassEncoder(gpu_pass, this.#note_slot(writes));
+    }
+
+    /**
+     * @param {GPUCommandEncoder} encoder
+     * @param {GPURenderPassDescriptor} descriptor
+     * @returns {ShadeGPURenderPassEncoder}
+     */
+    begin_render_pass(encoder, descriptor) {
+        const writes = this.#timers.getRenderWrites(descriptor?.label);
+
+        if (writes === undefined) {
+            return new ShadeGPURenderPassEncoder(encoder.beginRenderPass(descriptor), null);
+        }
+
+        const gpu_pass = encoder.beginRenderPass(this.#timed(descriptor, writes));
+
+        return new ShadeGPURenderPassEncoder(gpu_pass, this.#note_slot(writes));
+    }
+
+    /**
+     * The descriptor a timed pass should be begun with.
+     *
+     * A copy, never a write-through. Several call sites reuse one descriptor across passes, and
+     * stamping `timestampWrites` onto it left the next pass carrying the previous pass's query
+     * indices. `{...undefined}` is `{}`, which is also how the no-descriptor form of
+     * `beginComputePass` stays legal.
+     *
+     * @param {GPUComputePassDescriptor|GPURenderPassDescriptor} [descriptor]
+     * @param {GPUComputePassTimestampWrites|GPURenderPassTimestampWrites} writes
+     * @returns {GPUComputePassDescriptor|GPURenderPassDescriptor}
+     */
+    #timed(descriptor, writes) {
+        return { ...descriptor, timestampWrites: writes };
+    }
+
+    /**
+     * Tell the recorder which graph pass owns the slot just claimed.
+     *
+     * The one moment the join can be made. The recorder knows which frame graph pass is executing
+     * right now; the slot is what the timings will come back keyed by. Neither fact is recoverable
+     * later — see {@link GPUFrameRecorder}.
+     *
+     * @param {GPUComputePassTimestampWrites|GPURenderPassTimestampWrites} writes
+     * @returns {GPUProfileWork|null} null below {@link GPUProfileLevel.WORKLOAD}
+     */
+    #note_slot(writes) {
+        return this.#recorder.note_pass_slot(
+            this.#query_set_id,
+            writes.beginningOfPassWriteIndex / 2
+        );
+    }
+
+    /**
+     * @param {GPUCommandEncoder} encoder
+     * @returns {void}
+     */
+    resolve(encoder) {
+        this.#timers.resolve(encoder);
+    }
+
+    /**
+     * Read the timings back and hand them to the recorder. Resolves {@link absorbed} either way.
+     *
+     * @returns {void}
+     */
+    absorb() {
+        const timers = this.#timers;
+
+        timers
+            .download_results()
+            .then(() => {
+                this.#recorder.absorb(timers, this.#query_set_id);
+            })
+            .finally(() => {
+                timers.destroy();
+
+                /*
+                 In `finally` so a failed readback still releases whoever is waiting on the frame. A
+                 profile session that hangs because one download rejected is worse than one missing a
+                 frame.
+                */
+                this.#absorbed_resolve();
+            });
+    }
+}

package/src/shade/device/timing/profile/GPUProfileSession.d.ts

@@ -20,10 +20,10 @@
  * application that never mentions the profiler does not carry any of it. The feature ships without
  * a build flag, a strip-plugin interaction, or a dead branch anyone has to keep honest.
  *
- * Two leaf helpers under this directory *are* linked unconditionally, because
- * {@link ShadeGPUCommandContext} needs them while encoding: `make_profiling_pass_encoder` and
- * `parse_workgroup_size`. They import `assert` and nothing else, and neither knows what a capture
- * is. What remains in the engine beyond those is a nullable field and the null checks around it.
+ * Nothing under this directory is linked unconditionally. The pass encoders count dispatches into a
+ * {@link GPUProfileWork} when handed one, but they hold it as a bag of counters and never name the
+ * type; the workgroup size they record comes off {@link ComputePipelineDescriptor}, which reads it
+ * as its code is set. What remains in the engine is a nullable field and the null checks around it.
  *
  * Recording is an **open-ended forward stream**: `frame_limit` defaults to `Infinity` and
  * everything captured is kept. There is no ring buffer. Uncapped means a per-frame cost is also a

package/src/shade/device/timing/profile/GPUProfileSession.js

@@ -43,10 +43,10 @@ const DEFAULT_BYTE_BUDGET = 512 * 1024 * 1024;
  * application that never mentions the profiler does not carry any of it. The feature ships without
  * a build flag, a strip-plugin interaction, or a dead branch anyone has to keep honest.
  *
- * Two leaf helpers under this directory *are* linked unconditionally, because
- * {@link ShadeGPUCommandContext} needs them while encoding: `make_profiling_pass_encoder` and
- * `parse_workgroup_size`. They import `assert` and nothing else, and neither knows what a capture
- * is. What remains in the engine beyond those is a nullable field and the null checks around it.
+ * Nothing under this directory is linked unconditionally. The pass encoders count dispatches into a
+ * {@link GPUProfileWork} when handed one, but they hold it as a bag of counters and never name the
+ * type; the workgroup size they record comes off {@link ComputePipelineDescriptor}, which reads it
+ * as its code is set. What remains in the engine is a nullable field and the null checks around it.
  *
  * Recording is an **open-ended forward stream**: `frame_limit` defaults to `Infinity` and
  * everything captured is kept. There is no ring buffer. Uncapped means a per-frame cost is also a

package/src/shade/playground/skinned_blas_refit/shader_blas_audit_leaf_triangles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_blas_audit_leaf_triangles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/shader_blas_audit_leaf_triangles.js"],"names":[],"mappings":"AAqBA,2CAA4C;AA4D5C;;;;;;;;;;;;;;;;GAgBG;AACH,+CAFU,aAAa,CAMpB;8BAnG2B,wCAAwC"}
+{"version":3,"file":"shader_blas_audit_leaf_triangles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/shader_blas_audit_leaf_triangles.js"],"names":[],"mappings":"AAqBA,2CAA4C;AA8D5C;;;;;;;;;;;;;;;;GAgBG;AACH,+CAFU,aAAa,CAMpB;8BArG2B,wCAAwC"}

package/src/shade/playground/skinned_blas_refit/shader_blas_audit_leaf_triangles.js

@@ -22,8 +22,10 @@ import {
 export const BLAS_AUDIT_WORKGROUP_SIZE = 64;
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, 16 bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", BLAS_LEAF_BOUNDS_SETTINGS_STRUCT);
 resources.createGroup()
-    .addUniform("settings", BLAS_LEAF_BOUNDS_SETTINGS_STRUCT)
     .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), false)
     .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false)
     .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT), false)

package/src/shade/playground/skinned_blas_refit/shader_blas_audit_points.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_blas_audit_points.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/shader_blas_audit_points.js"],"names":[],"mappings":"AAkBA,4CAA6C;AAE7C;;GAEG;AACH,0CAFU,YAAY,CAOG;AA8CzB;;;;;;;;;;;;;GAaG;AACH,uCAFU,aAAa,CAMpB;6BA1F0B,4CAA4C;8BAE3C,wCAAwC"}
+{"version":3,"file":"shader_blas_audit_points.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/shader_blas_audit_points.js"],"names":[],"mappings":"AAkBA,4CAA6C;AAE7C;;GAEG;AACH,0CAFU,YAAY,CAOG;AAgDzB;;;;;;;;;;;;;GAaG;AACH,uCAFU,aAAa,CAMpB;6BA5F0B,4CAA4C;8BAE3C,wCAAwC"}

package/src/shade/playground/skinned_blas_refit/shader_blas_audit_points.js

@@ -29,8 +29,10 @@ export const BLAS_POINTS_SETTINGS_STRUCT = WebGPUStruct.from({
 }, "BlasPointsSettings");
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, 32 bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", BLAS_POINTS_SETTINGS_STRUCT);
 resources.createGroup()
-    .addUniform("settings", BLAS_POINTS_SETTINGS_STRUCT)
     // three f32 per point, in the geometry's own space
     .addStorageBuffer("targets", WebGPUArray.from(f32), false)
     .addStorageBuffer("blas_lookup", WebGPUArray.from(u32), false)

package/src/shade/playground/skinned_blas_refit/shader_blas_audit_visibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_blas_audit_visibility.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/shader_blas_audit_visibility.js"],"names":[],"mappings":"AAyBA,gDAAiD;AAEjD;;GAEG;AACH,8CAFU,YAAY,CASO;AA0E7B;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,aAAa,CAMpB;6BAlI0B,4CAA4C;8BAE3C,wCAAwC"}
+{"version":3,"file":"shader_blas_audit_visibility.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/shader_blas_audit_visibility.js"],"names":[],"mappings":"AAyBA,gDAAiD;AAEjD;;GAEG;AACH,8CAFU,YAAY,CASO;AA4E7B;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,aAAa,CAMpB;6BApI0B,4CAA4C;8BAE3C,wCAAwC"}

package/src/shade/playground/skinned_blas_refit/shader_blas_audit_visibility.js

@@ -38,8 +38,10 @@ export const BLAS_VISIBILITY_SETTINGS_STRUCT = WebGPUStruct.from({
 }, "BlasVisibilitySettings");
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, 32 bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", BLAS_VISIBILITY_SETTINGS_STRUCT);
 resources.createGroup()
-    .addUniform("settings", BLAS_VISIBILITY_SETTINGS_STRUCT)
     .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), false)
     .addStorageBuffer("blas_lookup", WebGPUArray.from(u32), false)
     .addStorageBuffer("blas_data", WebGPUArray.from(BVH2_NODE_STRUCT), false)

package/src/shade/playground/skinned_blas_refit/verify_leaf_triangles.js

@@ -106,12 +106,12 @@ export async function verify_leaf_triangles({
         encoder: cmd,
         thread_count_x: leaf_count,
         bindings: {
-            settings: cmd.allocateTransientValueBuffer(BLAS_LEAF_BOUNDS_SETTINGS_STRUCT, {
+            settings: {
                 leaf_count,
                 node_word_offset,
                 leaf_nodes_offset,
                 geometry_index,
-            }),
+            },
             leaf_nodes: blas.buffer_leaf_nodes,
             geometries: geometries.buffer_metadata,
             meshlet_metadata: meshlets.buffer_metadata,

package/src/shade/playground/skinned_blas_refit/verify_traversal_reachability.js

@@ -170,14 +170,14 @@ export async function verify_traversal_reachability({
         encoder: cmd,
         thread_count_x: leaf_count,
         bindings: {
-            settings: cmd.allocateTransientValueBuffer(BLAS_VISIBILITY_SETTINGS_STRUCT, {
+            settings: {
                 origin,
                 leaf_count,
                 node_word_offset,
                 leaf_nodes_offset,
                 geometry_index,
                 tmax: 1e12,
-            }),
+            },
             leaf_nodes: blas.buffer_leaf_nodes,
             blas_lookup: blas.buffer_metadata,
             blas_data: blas.buffer_data,

package/src/shade/renderer/Renderer.d.ts

@@ -198,11 +198,6 @@ export class Renderer {
      */
     onDeviceFailure: any;
     onFrameFinished: Signal;
-    /**
-     * First argument is frame index, second is table of debug data
-     * @type {Signal<number, Object[]>}
-     */
-    onFrameDebug: any;
     /**
      *
      * @param {number} v
@@ -296,7 +291,6 @@ export class Renderer {
      * @returns {number} how many extensions are registered on `phase`
      */
     extension_count(phase: FramePhase): number;
-    add_debug_frame(count?: number): void;
     /**
      *
      * @param {Scene} scene

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA4FA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,0CAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAkB1C,uCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,sCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;;;;;;;;;;OAYG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAE/B;;;OAGG;IACH,kBAA4B;IAiB5B;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,6BAcC;IA1BD;;;OAGG;IACH,0BAEC;IA4BD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,oBAAkB,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAGD,sCAIC;IAeD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IAmMD;;;;OAIG;IACH,0BAEC;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EA0NC;IAED;;OAEG;IACH,gBAGC;IAQD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;OAUG;IACH,qEAHW,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8EAJW,MAAM,UACN,iBAAiB,GACf,OAAO,CAi3BnB;;CACJ;6BA16E4B,yBAAyB;0CACZ,gCAAgC;2BApB/C,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAiC7C,uBAAuB;gCAtCnB,sBAAsB;mBArCnC,oCAAoC;oBACnC,4BAA4B;kCAuEd,gCAAgC;2BApDvC,2BAA2B;iCAkDrB,0CAA0C;4CApC/B,+DAA+D;yBA6BlF,yBAAyB;kCAMhB,wBAAwB;oBAvBtC,0BAA0B;uCAPP,sDAAsD"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA4FA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,0CAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAkB1C,uCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,sCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;;;;;;;;;;OAYG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAgB/B;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,6BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,oBAAkB,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IAmMD;;;;OAIG;IACH,0BAEC;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EA0NC;IAED;;OAEG;IACH,gBAGC;IAQD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;OAUG;IACH,qEAHW,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8EAJW,MAAM,UACN,iBAAiB,GACf,OAAO,CAu2BnB;;CACJ;6BA74E4B,yBAAyB;0CACZ,gCAAgC;2BApB/C,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAiC7C,uBAAuB;gCAtCnB,sBAAsB;mBArCnC,oCAAoC;oBACnC,4BAA4B;kCAuEd,gCAAgC;2BApDvC,2BAA2B;iCAkDrB,0CAA0C;4CApC/B,+DAA+D;yBA6BlF,yBAAyB;kCAMhB,wBAAwB;oBAvBtC,0BAA0B;uCAPP,sDAAsD"}

package/src/shade/renderer/Renderer.js

@@ -424,13 +424,6 @@ export class Renderer {
 
     onFrameFinished = new Signal();
 
-    /**
-     * First argument is frame index, second is table of debug data
-     * @type {Signal<number, Object[]>}
-     */
-    onFrameDebug = new Signal();
-
-
     /**
      * Fraction of the output resolution.
      * Controls {@link #internal_resolution}.
@@ -599,12 +592,6 @@ export class Renderer {
         this.#update_resolution();
     }
 
-    /**
-     * How many future frames should be debugged
-     * @type {number}
-     */
-    #debug_frame_count = 0;
-
     /**
      * The profile recording to feed, or null.
      *
@@ -668,12 +655,6 @@ export class Renderer {
     }
 
 
-    add_debug_frame(count = 1) {
-        assert.isNonNegativeInteger(count, 'count');
-
-        this.#debug_frame_count += count;
-    }
-
     /**
      *
      * @type {Map<Scene, GPULightProbeVolumeRenderer>}
@@ -1733,16 +1714,6 @@ export class Renderer {
             "Renderer/main-0"
         );
 
-        if (this.#debug_frame_count > 0) {
-            this.#debug_frame_count--;
-
-            const current_frame = this.#frame_count;
-
-            command_ctx.enable_debug_timers((table) => {
-                this.onFrameDebug.send2(current_frame, table);
-            });
-        }
-
         /**
          * The frame recorder for this frame, or null when nothing is profiling.
          * @type {GPUFrameRecorder|null}

package/src/shade/renderer/animation/GPUAnimationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AA6HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAyMI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA4ElB;IA8ED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAyDlB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAkChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA2ChB;IA0FD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kDAFW,MAAM,QAgChB;IA+FD,gBAYC;;CACJ;4BAttD2B,gCAAgC"}
+{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AA4HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAyMI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA4ElB;IA8ED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAyDlB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAkChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA2ChB;IA0FD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kDAFW,MAAM,QAgChB;IA8FD,gBAYC;;CACJ;4BArtD2B,gCAAgC"}

package/src/shade/renderer/animation/GPUAnimationManager.js

@@ -1,6 +1,5 @@
 import { assert } from "../../../core/assert.js";
 import { FrameGraph } from "../../../engine/graphics/render/frame_graph/FrameGraph.js";
-import { f32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { GPUDatabase } from "../buffer/table/GPUDatabase.js";
 import {
     graph_scene_update_transform_hierarchy
@@ -1663,12 +1662,11 @@ export class GPUAnimationManager {
             .get('animation_clips')
             .dispatch_group_count(ANIMATION_TICK_WORKGROUP_SIZE);
         if (tick_groups > 0) {
-            const dt_buffer = cmd_ctx.allocateTransientValueBuffer(f32, dt);
             shader_animation_tick.dispatch({
                 encoder: cmd_ctx,
                 group_count_x: tick_groups,
                 bindings: {
-                    dt: dt_buffer,
+                    dt,
                     animation_database: this.#database.buffer,
                 },
             });

package/src/shade/renderer/animation/shader_animation_tick.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_animation_tick.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/shader_animation_tick.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,gCAAiC;AAuFjC;;;;;;;;;;;;;;;;GAgBG;AACH,kDAIG;8BAzH2B,4BAA4B"}
+{"version":3,"file":"shader_animation_tick.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/shader_animation_tick.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,gCAAiC;AA0FjC;;;;;;;;;;;;;;;;GAgBG;AACH,kDAIG;8BA5H2B,4BAA4B"}