@woosh/meep-engine 3.14.6 → 3.16.0

package/src/engine/graphics/render/frame_graph/FramePassNode.d.ts

@@ -25,6 +25,18 @@ export class FramePassNode<T> extends FrameGraphNode {
      * @type {number[]}
      */
     resource_creates: number[];
+    /**
+     * IDs of the resources this pass allocates before it runs, filled by {@link FrameGraph.compile}.
+     *
+     * A superset of {@link resource_creates}: it also carries any transient the graph was asked for
+     * outside of a pass — {@link FrameGraph.create_resource} rather than
+     * {@link FramePassBuilder.create} — whose first surviving user this pass is. Such an entry
+     * belongs to no pass's create list, so allocating only what a pass declares it creates left it
+     * unallocated and handed the pass `null`.
+     *
+     * @type {number[]}
+     */
+    resource_allocates: number[];
     /**
      * IDs of read resources
      * @type {number[]}

package/src/engine/graphics/render/frame_graph/FramePassNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FramePassNode.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/frame_graph/FramePassNode.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;;IAEI;;;;;OAKG;IACH,cAJW,CAAC,oEAMX;IAED;;;OAGG;IACH,kBAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,UAAU;IAEV;;;OAGG;IACH,kBAFU,MAAM,EAAE,CAEI;IAEtB;;;OAGG;IACH,gBAFU,MAAM,EAAE,CAEE;IAEpB;;;OAGG;IACH,iBAFU,MAAM,EAAE,CAEG;IAErB;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAMlB;IAED;;;;OAIG;IACH,UAHW,MAAM,GACL,OAAO,CAMlB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACL,OAAO,CAMlB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CASlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;OAGG;IACH,eAFY,OAAO,CAIlB;CACJ;+BApH8B,qBAAqB"}
+{"version":3,"file":"FramePassNode.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/frame_graph/FramePassNode.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;;IAEI;;;;;OAKG;IACH,cAJW,CAAC,oEAMX;IAED;;;OAGG;IACH,kBAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,UAAU;IAEV;;;OAGG;IACH,kBAFU,MAAM,EAAE,CAEI;IAEtB;;;;;;;;;;OAUG;IACH,oBAFU,MAAM,EAAE,CAEM;IAExB;;;OAGG;IACH,gBAFU,MAAM,EAAE,CAEE;IAEpB;;;OAGG;IACH,iBAFU,MAAM,EAAE,CAEG;IAErB;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAMlB;IAED;;;;OAIG;IACH,UAHW,MAAM,GACL,OAAO,CAMlB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACL,OAAO,CAMlB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CASlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;OAGG;IACH,eAFY,OAAO,CAIlB;CACJ;+BAjI8B,qBAAqB"}

package/src/engine/graphics/render/frame_graph/FramePassNode.js

@@ -34,6 +34,19 @@ export class FramePassNode extends FrameGraphNode {
      */
     resource_creates = [];
 
+    /**
+     * IDs of the resources this pass allocates before it runs, filled by {@link FrameGraph.compile}.
+     *
+     * A superset of {@link resource_creates}: it also carries any transient the graph was asked for
+     * outside of a pass — {@link FrameGraph.create_resource} rather than
+     * {@link FramePassBuilder.create} — whose first surviving user this pass is. Such an entry
+     * belongs to no pass's create list, so allocating only what a pass declares it creates left it
+     * unallocated and handed the pass `null`.
+     *
+     * @type {number[]}
+     */
+    resource_allocates = [];
+
     /**
      * IDs of read resources
      * @type {number[]}

package/src/engine/graphics/render/frame_graph/FramePassResources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FramePassResources.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/frame_graph/FramePassResources.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IACI;;;;OAIG;IACH,gBAAe;IACf;;;;OAIG;IACH,eAAc;IAEd;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;OAIG;IACH,mDAMC;IAED;;;;OAIG;IACH,WAHW,MAAM,KAehB;IAED;;;;OAIG;IACH,uBAHW,MAAM,OAehB;CACJ"}
+{"version":3,"file":"FramePassResources.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/frame_graph/FramePassResources.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IACI;;;;OAIG;IACH,gBAAe;IACf;;;;OAIG;IACH,eAAc;IAEd;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;OAIG;IACH,mDAMC;IAED;;;;OAIG;IACH,WAHW,MAAM,KAoBhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,OAehB;CACJ"}

package/src/engine/graphics/render/frame_graph/FramePassResources.js

@@ -62,6 +62,11 @@ export class FramePassResources {
 
         const entry = this.__graph.getResourceEntry(id);
 
+        // Declaring a reference is not the same as anything having allocated it. Without this, a
+        // pass is handed `null` and the failure surfaces later, inside a bind-group build, naming
+        // the consumer rather than the missing producer.
+        assert.notNull(entry.resource, `resource '${this.__graph.getResourceNode(id).name}' read by pass '${this.__pass.name}' holds nothing, no pass allocated it`);
+
         return entry.resource;
     }
 

package/src/engine/graphics/render/frame_graph/ResourceEntry.d.ts

@@ -30,7 +30,16 @@ export class ResourceEntry<T> {
      */
     imported: boolean;
     /**
-     * Node that created this resource
+     * The surviving pass that allocates this entry, assigned by {@link FrameGraph.compile}.
+     *
+     * Usually the pass that created it. For a transient the graph was asked for outside of a pass
+     * it is instead the first surviving pass that uses it, because nothing else is going to
+     * allocate it. Null for imports, and for anything only culled passes touch.
+     *
+     * Per-**entry**, so it names one pass for the whole version chain. The per-version answer, and
+     * the one every reader in the tree wants, is {@link ResourceNode.producer}, which is assigned
+     * at record time and is therefore populated for imports and for culled passes too.
+     *
      * @type {FramePassNode|null}
      */
     producer: FramePassNode | null;
@@ -46,6 +55,15 @@ export class ResourceEntry<T> {
     create(resources: RenderResourceManager): void;
     /**
      * De-allocated memory for the resource
+     *
+     * Clears {@link resource} on the way out. The pool hands the same object straight back out
+     * again, so an entry still naming a released resource is a handle to somebody else's resource:
+     * any sweep that asks "does this entry hold something" — the leak-on-throw cleanup in
+     * {@link FrameGraph.execute} does exactly that — would release it a second time, and
+     * `TransientResourcePool.release` would accept it, because the resource *is* bound, to its new
+     * owner. Nulling makes "released" a fact the entry states rather than one a caller has to
+     * remember.
+     *
      * @param {RenderResourceManager} resources
      */
     destroy(resources: RenderResourceManager): void;

package/src/engine/graphics/render/frame_graph/ResourceEntry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ResourceEntry.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/frame_graph/ResourceEntry.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IACI;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,qBAFU,wBAAsB,IAAI,CAET;IAE3B;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,UAFU,CAAC,GAAC,IAAI,CAEA;IAEhB;;;;OAIG;IACH,UAFU,OAAO,CAEA;IAEjB;;;OAGG;IACH,UAFU,gBAAc,IAAI,CAEZ;IAEhB;;;OAGG;IACH,MAFU,gBAAc,IAAI,CAEhB;IAEZ;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAED;;;OAGG;IACH,cAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,eAFY,OAAO,CAIlB;IAED,gBAQC;CACJ"}
+{"version":3,"file":"ResourceEntry.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/frame_graph/ResourceEntry.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IACI;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,qBAFU,wBAAsB,IAAI,CAET;IAE3B;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,UAFU,CAAC,GAAC,IAAI,CAEA;IAEhB;;;;OAIG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;;;;;;OAYG;IACH,UAFU,gBAAc,IAAI,CAEZ;IAEhB;;;OAGG;IACH,MAFU,gBAAc,IAAI,CAEhB;IAEZ;;;OAGG;IACH,+CAKC;IAED;;;;;;;;;;;;OAYG;IACH,gDAOC;IAED;;;OAGG;IACH,cAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,eAFY,OAAO,CAIlB;IAED,gBAQC;CACJ"}

package/src/engine/graphics/render/frame_graph/ResourceEntry.js

@@ -37,7 +37,16 @@ export class ResourceEntry {
     imported = false;
 
     /**
-     * Node that created this resource
+     * The surviving pass that allocates this entry, assigned by {@link FrameGraph.compile}.
+     *
+     * Usually the pass that created it. For a transient the graph was asked for outside of a pass
+     * it is instead the first surviving pass that uses it, because nothing else is going to
+     * allocate it. Null for imports, and for anything only culled passes touch.
+     *
+     * Per-**entry**, so it names one pass for the whole version chain. The per-version answer, and
+     * the one every reader in the tree wants, is {@link ResourceNode.producer}, which is assigned
+     * at record time and is therefore populated for imports and for culled passes too.
+     *
      * @type {FramePassNode|null}
      */
     producer = null;
@@ -54,18 +63,31 @@ export class ResourceEntry {
      */
     create(resources) {
         assert.ok(this.isTransient(), 'Only transient resources can be allocated');
+        assert.equal(this.resource, null, 'entry already holds a resource, allocating again would leak the one it has');
 
         this.resource = resources.get(this.resource_descriptor)
     }
 
     /**
      * De-allocated memory for the resource
+     *
+     * Clears {@link resource} on the way out. The pool hands the same object straight back out
+     * again, so an entry still naming a released resource is a handle to somebody else's resource:
+     * any sweep that asks "does this entry hold something" — the leak-on-throw cleanup in
+     * {@link FrameGraph.execute} does exactly that — would release it a second time, and
+     * `TransientResourcePool.release` would accept it, because the resource *is* bound, to its new
+     * owner. Nulling makes "released" a fact the entry states rather than one a caller has to
+     * remember.
+     *
      * @param {RenderResourceManager} resources
      */
     destroy(resources) {
         assert.ok(this.isTransient(), 'Only transient resources can be destroyed, that is resources that are created by the graph itself');
+        assert.notNull(this.resource, 'entry holds no resource, nothing allocated it — a transient created outside a pass is never allocated');
 
         resources.release(this.resource);
+
+        this.resource = null;
     }
 
     /**

package/src/engine/graphics/render/frame_graph/backend/void/VoidRenderContext.d.ts

@@ -4,8 +4,22 @@
  */
 export class VoidRenderContext extends IFrameGraphContext {
     static INSTANCE: VoidRenderContext;
-    createResource(descriptor: any): any;
+    /**
+     * A distinct token per call, never `null`.
+     *
+     * {@link RenderResourceManager} keys its live-descriptor table by resource *identity*, so a
+     * backend that answers every descriptor with one value cannot hold two transients at once —
+     * the second allocation collides with the first and throws before any pass runs. Returning a
+     * fresh object makes the void backend able to execute the graph shapes a lifetime test needs.
+     *
+     * @param {ResourceDescriptor} descriptor
+     * @returns {{void_resource: number}}
+     */
+    createResource(descriptor: ResourceDescriptor): {
+        void_resource: number;
+    };
     destroyResource(resource: any, descriptor: any): void;
+    #private;
 }
 import { IFrameGraphContext } from "../../IFrameGraphContext.js";
 //# sourceMappingURL=VoidRenderContext.d.ts.map

package/src/engine/graphics/render/frame_graph/backend/void/VoidRenderContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VoidRenderContext.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/frame_graph/backend/void/VoidRenderContext.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAQI,mCAA0C;IAP1C,qCAEC;IAED,sDACC;CAGJ;mCAfkC,6BAA6B"}
+{"version":3,"file":"VoidRenderContext.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/frame_graph/backend/void/VoidRenderContext.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAyBI,mCAA0C;IAlB1C;;;;;;;;;;OAUG;IACH,gDAFa;QAAC,aAAa,EAAE,MAAM,CAAA;KAAC,CAInC;IAED,sDACC;;CAGJ;mCAhCkC,6BAA6B"}

package/src/engine/graphics/render/frame_graph/backend/void/VoidRenderContext.js

@@ -1,16 +1,33 @@
-import { IFrameGraphContext } from "../../IFrameGraphContext.js";
-
-/**
- * Doesn't actually do anything, but works as a valid rendering context
- * Mainly useful for testing
- */
-export class VoidRenderContext extends IFrameGraphContext {
-    createResource(descriptor) {
-        return null;
-    }
-
-    destroyResource(resource, descriptor) {
-    }
-
-    static INSTANCE = new VoidRenderContext();
-}
+import { IFrameGraphContext } from "../../IFrameGraphContext.js";
+
+/**
+ * Doesn't actually do anything, but works as a valid rendering context
+ * Mainly useful for testing
+ */
+export class VoidRenderContext extends IFrameGraphContext {
+    /**
+     * Distinguishes the tokens handed out by {@link createResource}.
+     * @type {number}
+     */
+    #next_token_id = 0;
+
+    /**
+     * A distinct token per call, never `null`.
+     *
+     * {@link RenderResourceManager} keys its live-descriptor table by resource *identity*, so a
+     * backend that answers every descriptor with one value cannot hold two transients at once —
+     * the second allocation collides with the first and throws before any pass runs. Returning a
+     * fresh object makes the void backend able to execute the graph shapes a lifetime test needs.
+     *
+     * @param {ResourceDescriptor} descriptor
+     * @returns {{void_resource: number}}
+     */
+    createResource(descriptor) {
+        return { void_resource: this.#next_token_id++ };
+    }
+
+    destroyResource(resource, descriptor) {
+    }
+
+    static INSTANCE = new VoidRenderContext();
+}

package/src/engine/graphics/render/frame_graph/resource/RenderResourceManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderResourceManager.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/frame_graph/resource/RenderResourceManager.js"],"names":[],"mappings":"AAGA;IAqBI,uBAEC;IAUD;;;;OAIG;IACH,6CAiBC;IAED;;;OAGG;IACH,kCAYC;IAED;;;OAGG;IACH,gBAaC;;CACJ"}
+{"version":3,"file":"RenderResourceManager.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/frame_graph/resource/RenderResourceManager.js"],"names":[],"mappings":"AAGA;IAqBI,uBAEC;IAUD;;;;OAIG;IACH,6CAwBC;IAED;;;OAGG;IACH,kCAuBC;IAED;;;OAGG;IACH,gBAaC;;CACJ"}

package/src/engine/graphics/render/frame_graph/resource/RenderResourceManager.js

@@ -45,6 +45,13 @@ export class RenderResourceManager {
         if (resource === undefined) {
             // nothing in cache, create a new one
             resource = this.#ctx.createResource(descriptor);
+
+            if (resource === null || resource === undefined) {
+                // The live-descriptor table below is keyed by resource identity, so a backend
+                // answering with a single sentinel collides with itself on the second allocation
+                // and reports it as corruption. Name the backend instead.
+                throw new Error(`${this.#ctx.constructor.name}.createResource returned ${resource} for ${descriptor}, a backend must hand back a distinct resource per call`);
+            }
         }
 
         const existing_descriptor = this.#resource_descriptors.get(resource);
@@ -72,7 +79,18 @@ export class RenderResourceManager {
 
         this.#resource_descriptors.delete(resource);
 
-        this.#cache.add(descriptor, resource);
+        if (!this.#cache.add(descriptor, resource)) {
+            /*
+             The per-key bucket is full, and `add` refuses without firing `onRemoved` — unlike the
+             global-capacity eviction path, which does. The resource has already been dropped from
+             the live table above, so without this it is neither pooled, nor destroyed, nor tracked:
+             leaked, and leaked exactly under the pressure where leaking hurts most.
+
+             Destroyed here rather than made poolable: a pool deciding a GPU resource's fate is the
+             wrong shape. Its answer is "not mine"; the owner's answer is this.
+            */
+            this.#ctx.destroyResource(resource, descriptor);
+        }
 
     }
 

package/src/engine/graphics/sh3/path_tracer/populate_path_traced_scene_from_ecd.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import { Light } from "../../ecs/light/Light.js";
 import { LightType } from "../../ecs/light/LightType.js";
 import { ShadedGeometry } from "../../ecs/mesh-v2/ShadedGeometry.js";
@@ -25,11 +25,11 @@ export function populate_path_traced_scene_from_ecd(ecd, scene) {
     assert.defined(ecd, 'ecd');
     assert.defined(scene, 'scene');
 
-    ecd.traverseEntities([ShadedGeometry, Transform],
+    ecd.traverseEntities([ShadedGeometry, Transform64],
         /**
          *
          * @param {ShadedGeometry} sg
-         * @param {Transform} transform
+         * @param {Transform64} transform
          */
         (sg, transform) => {
 
@@ -38,11 +38,11 @@ export function populate_path_traced_scene_from_ecd(ecd, scene) {
         });
 
 
-    ecd.traverseEntities([Light, Transform],
+    ecd.traverseEntities([Light, Transform64],
         /**
          *
          * @param {Light} light
-         * @param {Transform} transform
+         * @param {Transform64} transform
          */
         (light, transform) => {
 
@@ -62,7 +62,7 @@ export function populate_path_traced_scene_from_ecd(ecd, scene) {
                 const l = new PointLight();
 
                 l.color.copy(light.color);
-                l.position.copy(transform.position);
+                l.position.set(transform.translation_x, transform.translation_y, transform.translation_z);
                 l.intensity.copy(light.intensity);
                 l.radius.copy(light.distance);
 

package/src/engine/graphics3/CameraSystem.d.ts

@@ -20,7 +20,7 @@ export class CameraSystem extends System<any> {
      * @param {GraphicsEngine} graphics
      */
     constructor(graphics: GraphicsEngine);
-    dependencies: (typeof Transform | typeof Camera)[];
+    dependencies: (typeof Transform64 | typeof Camera)[];
     startup(entityManager: any): Promise<void>;
     shutdown(entityManager: any): Promise<void>;
     /**
@@ -31,19 +31,19 @@ export class CameraSystem extends System<any> {
     get active_entity(): number;
     /**
      * @param {Camera} camera
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    link(camera: Camera, transform: Transform, entity: number): void;
+    link(camera: Camera, transform: Transform64, entity: number): void;
     /**
      * @param {Camera} camera
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    unlink(camera: Camera, transform: Transform, entity: number): void;
+    unlink(camera: Camera, transform: Transform64, entity: number): void;
     #private;
 }
 import { System } from "../ecs/System.js";
-import { Transform } from "../ecs/transform/Transform.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
 import { Camera } from "../graphics/ecs/camera/Camera.js";
 //# sourceMappingURL=CameraSystem.d.ts.map

package/src/engine/graphics3/CameraSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CameraSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/CameraSystem.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;GAgBG;AACH;IAoBI;;OAEG;IACH,sCAQC;IADG,mDAAuC;IAG3C,2CAEC;IAED,4CAIC;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;OAIG;IACH,aAJW,MAAM,aACN,SAAS,UACT,MAAM,QAUhB;IAED;;;;OAIG;IACH,eAJW,MAAM,aACN,SAAS,UACT,MAAM,QAIhB;;CAsEJ;uBAtKsB,kBAAkB;0BACf,+BAA+B;uBAClC,kCAAkC"}
+{"version":3,"file":"CameraSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/CameraSystem.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;GAgBG;AACH;IAoBI;;OAEG;IACH,sCAQC;IADG,qDAAyC;IAG7C,2CAEC;IAED,4CAIC;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;OAIG;IACH,aAJW,MAAM,aACN,WAAW,UACX,MAAM,QAUhB;IAED;;;;OAIG;IACH,eAJW,MAAM,aACN,WAAW,UACX,MAAM,QAIhB;;CAsEJ;uBAtKsB,kBAAkB;4BACb,iCAAiC;uBACtC,kCAAkC"}