@woosh/meep-engine 3.21.0 → 3.22.0

package/src/shade/renderer/scene/GPUInstancesAccelerationStructure.js

@@ -8,6 +8,11 @@ import { bvh_buffer_size } from "../gpu_primitive/bvh/BVH_BUFFER_LAYOUT.js";
 import { graph_bvh_build_lbvh } from "../gpu_primitive/bvh/graph_bvh_build_lbvh.js";
 import { shader_bvh_extract_instance_leaves } from "./shader_bvh_extract_instance_leaves.js";
 
+/**
+ * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
+ * @typedef {import("./Mesh.js").Mesh} Mesh
+ */
+
 /**
  * `root = BVH_NULL_NODE` — an empty tree, in the four bytes every consumer already reads that way.
  * @type {Uint32Array}

package/src/shade/renderer/scene/GPUSceneContext.d.ts

@@ -150,6 +150,10 @@ export class GPUSceneContext {
     readonly isGPUSceneContext: boolean;
     #private;
 }
+export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;
+export type GPUGeometryManager = import("../geometry/GPUGeometryManager.js").GPUGeometryManager;
+export type GPUMaterialManager = import("../material/GPUMaterialManager.js").GPUMaterialManager;
+export type Node3D = import("./Node3D.js").Node3D;
 import { Brick4LightMap } from "../global_illumination/brick4/Brick4LightMap.js";
 import { Scene } from "./Scene.js";
 import { GPUSceneVolumetrics } from "../volumetrics/GPUSceneVolumetrics.js";

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AA4DA;;GAEG;AACH;IAkJI;;;;OAIG;IACH,8CAFW,KAAK,EAiCf;IApLD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,+BAAW;IAEX;;OAEG;IACH,8BAAU;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAmBD;;;;;;;;;;;;;;OAcG;IACH,YAFU,IAAI,MAAM,EAAE,MAAM,CAAC,CAEN;IAgEvB;;OAEG;IACH,6CAEC;IAeD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;;OAYG;IACH,uCAUC;IAED,+BAUC;IAkKD;;;;;;;;;;OAUG;IACH,2BAFa,MAAM,CAMlB;IAED;;;;;;;OAOG;IACH,gCAEC;IA+QD;;;;;;OAMG;IACH,cA4DC;IAED;;;OAGG;IACH,mCAuBC;IAED;;;;;;;;;;;;;OAaG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAIhB;IAED,gBAQC;IAIL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BAr4B8B,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;oCAPtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;uCATjD,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAmEA;;GAEG;AACH;IAkJI;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAiCf;IApLD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAmBD;;;;;;;;;;;;;;OAcG;IACH,YAFU,IAAI,MAAM,EAAE,MAAM,CAAC,CAEN;IAgEvB;;OAEG;IACH,6CAEC;IAeD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;;OAYG;IACH,uCAUC;IAED,+BAUC;IAkKD;;;;;;;;;;OAUG;IACH,kBAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;;OAOG;IACH,gCAEC;IAuRD;;;;;;OAMG;IACH,cA4DC;IAED;;;OAGG;IACH,YAFW,eAAe,QAyBzB;IAED;;;;;;;;;;;;;OAaG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAIhB;IAED,gBAQC;IAIL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAv4BY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;qBAC9D,OAAO,aAAa,EAAE,MAAM;+BAhBV,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;oCAPtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;uCATjD,wCAAwC"}

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -15,6 +15,13 @@ import { SCENE_DATABASE_SPEC } from "./SCENE_DATABASE_SPEC.js";
 import { SceneNodeBinding } from "./SceneNodeBinding.js";
 import { TransformAuthority } from "./TransformAuthority.js";
 
+/**
+ * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
+ * @typedef {import("../geometry/GPUGeometryManager.js").GPUGeometryManager} GPUGeometryManager
+ * @typedef {import("../material/GPUMaterialManager.js").GPUMaterialManager} GPUMaterialManager
+ * @typedef {import("./Node3D.js").Node3D} Node3D
+ */
+
 
 let id_counter = 0;
 
@@ -619,6 +626,14 @@ export class GPUSceneContext {
 
             this.#instance_metadata[mesh_row * 2] = 0;
             this.#instance_metadata[mesh_row * 2 + 1] = 0;
+
+            // A skinned mesh renders a per-instance copy of its geometry, and the row just
+            // given back was the only thing naming it. This is where that copy — its vertex
+            // region, its BLAS and its prev-position slice — goes back too; nothing else in
+            // the engine sees a mesh leave, and unbinding deliberately does not free it.
+            if (node.isSkinnedMesh === true) {
+                this.skinning.release_clone(node);
+            }
         }
 
         transforms_table.remove(binding.transform_row);

package/src/shade/renderer/scene/InstanceBatch.d.ts

@@ -1,3 +1,8 @@
+/**
+ * @typedef {import("../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ * @typedef {import("./Mesh.js").Mesh} Mesh
+ * @typedef {import("./Node3D.js").Node3D} Node3D
+ */
 /**
  * The renderable side of a {@link Scene} — every {@link Node3D} that the
  * GPU's `transforms` table needs a row for, plus the cached mesh-only
@@ -19,7 +24,7 @@ export class InstanceBatch {
      * Primarily useful for rendering.
      * @type {ShadeMaterial[]}
      */
-    get materials(): ShadeMaterial[];
+    get materials(): import("../material/ShadeMaterial.js").ShadeMaterial[];
     /**
      *
      * @param {boolean} v
@@ -37,7 +42,7 @@ export class InstanceBatch {
      *
      * @returns {Mesh[]}
      */
-    get instances(): Mesh[];
+    get instances(): import("./Mesh.js").Mesh[];
     /**
      * Every node in the batch — the input the GPU scene-graph propagation
      * pass iterates. Order is insertion order; {@link instances} is
@@ -45,7 +50,7 @@ export class InstanceBatch {
      *
      * @returns {Node3D[]}
      */
-    get nodes(): Node3D[];
+    get nodes(): import("./Node3D.js").Node3D[];
     /**
      * Add a node. Accepts any {@link Node3D} — meshes, anchors, future
      * skeleton joints. Meshes will additionally appear in
@@ -80,5 +85,8 @@ export class InstanceBatch {
     equals(other: InstanceBatch): boolean;
     #private;
 }
+export type ShadeMaterial = import("../material/ShadeMaterial.js").ShadeMaterial;
+export type Mesh = import("./Mesh.js").Mesh;
+export type Node3D = import("./Node3D.js").Node3D;
 import { AABB3 } from "../../../core/geom/3d/aabb/AABB3.js";
 //# sourceMappingURL=InstanceBatch.d.ts.map

package/src/shade/renderer/scene/InstanceBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InstanceBatch.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/InstanceBatch.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH;IAyCI;;;;OAIG;IACH,iCAcC;IAED;;;OAGG;IACH,4BAMC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;;;OAMG;IACH,wBAeC;IAED;;;;;;OAMG;IACH,sBAEC;IAGD;;;;;;OAMG;IACH,wBAOC;IAED;;;OAGG;IACH,0BAoBC;IAED;;;OAGG;IACH,wBAFa,MAAM,CAclB;IAED;;;;;;OAMG;IACH,sBAFa,OAAO,CAWnB;IAED,eAEC;IAED;;;OAGG;IACH,cAFW,aAAa,WAIvB;;CAEJ;sBAjOqB,qCAAqC"}
+{"version":3,"file":"InstanceBatch.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/InstanceBatch.js"],"names":[],"mappings":"AAKA;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IAyCI;;;;OAIG;IACH,wEAcC;IAED;;;OAGG;IACH,4BAMC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;;;OAMG;IACH,4CAeC;IAED;;;;;;OAMG;IACH,4CAEC;IAGD;;;;;;OAMG;IACH,UAFW,MAAM,QAShB;IAED;;;OAGG;IACH,0BAoBC;IAED;;;OAGG;IACH,wBAFa,MAAM,CAclB;IAED;;;;;;OAMG;IACH,aAHW,MAAM,GACJ,OAAO,CAWnB;IAED,eAEC;IAED;;;OAGG;IACH,cAFW,aAAa,WAIvB;;CAEJ;4BApOY,OAAO,8BAA8B,EAAE,aAAa;mBACpD,OAAO,WAAW,EAAE,IAAI;qBACxB,OAAO,aAAa,EAAE,MAAM;sBALnB,qCAAqC"}

package/src/shade/renderer/scene/InstanceBatch.js

@@ -3,6 +3,12 @@ import { array_remove_first } from "../../../core/collection/array/array_remove_
 import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
 import { AABB3 } from "../../../core/geom/3d/aabb/AABB3.js";
 
+/**
+ * @typedef {import("../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ * @typedef {import("./Mesh.js").Mesh} Mesh
+ * @typedef {import("./Node3D.js").Node3D} Node3D
+ */
+
 /**
  * The renderable side of a {@link Scene} — every {@link Node3D} that the
  * GPU's `transforms` table needs a row for, plus the cached mesh-only

package/src/shade/renderer/scene/Mesh.d.ts

@@ -1,12 +1,16 @@
+/**
+ * @typedef {import("../geometry/MeshletGeometry.js").MeshletGeometry} MeshletGeometry
+ * @typedef {import("../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ */
 export class Mesh extends Node3D {
     /**
      *
      * @param {MeshletGeometry} geometry
      * @param {ShadeMaterial} material
-     * @param {mat4} [transform]
+     * @param {number[]|Float32Array|Float64Array} [transform] 4x4 affine matrix, column-major
      * @return {Mesh}
      */
-    static from(geometry: MeshletGeometry, material: ShadeMaterial, transform?: mat4): Mesh;
+    static from(geometry: MeshletGeometry, material: ShadeMaterial, transform?: number[] | Float32Array | Float64Array): Mesh;
     /**
      * @type {MeshletGeometry}
      */
@@ -45,5 +49,7 @@ export class Mesh extends Node3D {
     updateBoundsTight(): void;
     isMesh: boolean;
 }
+export type MeshletGeometry = import("../geometry/MeshletGeometry.js").MeshletGeometry;
+export type ShadeMaterial = import("../material/ShadeMaterial.js").ShadeMaterial;
 import { Node3D } from "./Node3D.js";
 //# sourceMappingURL=Mesh.d.ts.map

package/src/shade/renderer/scene/Mesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Mesh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/Mesh.js"],"names":[],"mappings":"AAUA;IA2HI;;;;;;OAMG;IACH,mFAFY,IAAI,CAoBf;IAnJD;;OAEG;IACH,0BAAS;IAET;;OAEG;IACH,wBAAS;IAET;;;OAGG;IACH,cAFU,YAAY,CAEa;IAEnC;;;OAGG;IACH,iBAFU,YAAY,CAEgB;IAEtC;;;OAGG;IACH,SAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,YAFW,IAAI,QAiBd;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAQnB;IAQD,0BAOC;IAED,0BAqCC;IA+BL,gBAAqB;CAHpB;uBAvJsB,aAAa"}
+{"version":3,"file":"Mesh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/Mesh.js"],"names":[],"mappings":"AAUA;;;GAGG;AAEH;IA2HI;;;;;;OAMG;IACH,sBALW,eAAe,YACf,aAAa,cACb,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GACjC,IAAI,CAoBf;IAnJD;;OAEG;IACH,UAFU,eAAe,CAEhB;IAET;;OAEG;IACH,UAFU,aAAa,CAEd;IAET;;;OAGG;IACH,cAFU,YAAY,CAEa;IAEnC;;;OAGG;IACH,iBAFU,YAAY,CAEgB;IAEtC;;;OAGG;IACH,SAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,YAFW,IAAI,QAiBd;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAQnB;IAQD,0BAOC;IAED,0BAqCC;IA+BL,gBAAqB;CAHpB;8BAzJY,OAAO,gCAAgC,EAAE,eAAe;4BACxD,OAAO,8BAA8B,EAAE,aAAa;uBAJ1C,aAAa"}

package/src/shade/renderer/scene/Mesh.js

@@ -8,6 +8,11 @@ import { optional_equality } from "../../../core/model/object/optional_equality.
 import { StandardAttributes } from "../geometry/StandardAttributes.js";
 import { Node3D } from "./Node3D.js";
 
+/**
+ * @typedef {import("../geometry/MeshletGeometry.js").MeshletGeometry} MeshletGeometry
+ * @typedef {import("../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ */
+
 export class Mesh extends Node3D {
     /**
      * @type {MeshletGeometry}
@@ -135,7 +140,7 @@ export class Mesh extends Node3D {
      *
      * @param {MeshletGeometry} geometry
      * @param {ShadeMaterial} material
-     * @param {mat4} [transform]
+     * @param {number[]|Float32Array|Float64Array} [transform] 4x4 affine matrix, column-major
      * @return {Mesh}
      */
     static from(geometry, material, transform) {

package/src/shade/renderer/scene/SceneManager.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
+ * @typedef {import("./Scene.js").Scene} Scene
+ */
 export class SceneManager {
     /**
      *
@@ -17,5 +21,7 @@ export class SceneManager {
     obtain(scene: Scene): GPUSceneContext;
     #private;
 }
+export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;
+export type Scene = import("./Scene.js").Scene;
 import { GPUSceneContext } from "./GPUSceneContext.js";
 //# sourceMappingURL=SceneManager.d.ts.map

package/src/shade/renderer/scene/SceneManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SceneManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SceneManager.js"],"names":[],"mappings":"AAEA;IAaI;;;OAGG;IACH,uCAEC;IAjBD;;;OAGG;IACH,gBAFU,WAAU,eAAe,CAAC,CAET;IA6B3B;;;;OAIG;IACH,sBAFa,eAAe,CAY3B;;CAEJ;gCAtD+B,sBAAsB"}
+{"version":3,"file":"SceneManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SceneManager.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;IAaI;;;OAGG;IACH,sBAFW,eAAe,EAIzB;IAjBD;;;OAGG;IACH,gBAFU,IAAI,KAAK,EAAC,eAAe,CAAC,CAET;IA6B3B;;;;OAIG;IACH,cAHW,KAAK,GACH,eAAe,CAY3B;;CAEJ;8BAxDY,OAAO,uBAAuB,EAAE,eAAe;oBAC/C,OAAO,YAAY,EAAE,KAAK;gCAJP,sBAAsB"}

package/src/shade/renderer/scene/SceneManager.js

@@ -1,5 +1,10 @@
 import { GPUSceneContext } from "./GPUSceneContext.js";
 
+/**
+ * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
+ * @typedef {import("./Scene.js").Scene} Scene
+ */
+
 export class SceneManager {
 
     /**

package/src/shade/renderer/scene/SkinnedMesh.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import("../animation/Skin.js").Skin} Skin
+ */
 /**
  * A mesh whose vertices are deformed each frame by joint transforms.
  *
@@ -102,5 +105,6 @@ export class SkinnedMesh extends Mesh {
      */
     readonly isSkinnedMesh: boolean;
 }
+export type Skin = import("../animation/Skin.js").Skin;
 import { Mesh } from "./Mesh.js";
 //# sourceMappingURL=SkinnedMesh.d.ts.map

package/src/shade/renderer/scene/SkinnedMesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SkinnedMesh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SkinnedMesh.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH;IAEI;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAFU,OAAK,IAAI,CAEP;IAEZ;;OAEG;IACH,SAFa,WAAW,CAMvB;IAED;;OAEG;IACH,YAFW,WAAW,QAYrB;IA4CL;;;OAGG;IACH,wBAFU,OAAO,CAEkB;CANlC;qBA9JoB,WAAW"}
+{"version":3,"file":"SkinnedMesh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SkinnedMesh.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH;IAEI;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAFU,IAAI,GAAC,IAAI,CAEP;IAEZ;;OAEG;IACH,SAFa,WAAW,CAMvB;IAED;;OAEG;IACH,YAFW,WAAW,QAYrB;IA4CL;;;OAGG;IACH,wBAFU,OAAO,CAEkB;CANlC;mBA/JY,OAAO,sBAAsB,EAAE,IAAI;qBAH3B,WAAW"}

package/src/shade/renderer/scene/SkinnedMesh.js

@@ -1,6 +1,10 @@
 import { compute_skin_world_bounds } from "../animation/compute_skin_world_bounds.js";
 import { Mesh } from "./Mesh.js";
 
+/**
+ * @typedef {import("../animation/Skin.js").Skin} Skin
+ */
+
 /**
  * A mesh whose vertices are deformed each frame by joint transforms.
  *

package/src/shade/renderer/scene/serialization/serialize_scene.d.ts

@@ -7,9 +7,13 @@
 export function material_write_standard(buffer: BinaryBuffer, material: StandardShadeMaterial, texture_lookup: Map<ShadeTexture, number>): void;
 /**
  *
- * @param {Scene} scene
- * @param {boolean} [include_blas] BLAS BVH takes up a lot of space, but it is optimal and will save processing time
+ * @param {Object} options
+ * @param {Scene} options.scene
+ * @param {boolean} [options.include_blas] BLAS BVH takes up a lot of space, but it is optimal and will save processing time
  */
-export function serialize_scene({ scene, include_blas, }: Scene): Promise<BinaryBuffer>;
+export function serialize_scene({ scene, include_blas, }: {
+    scene: Scene;
+    include_blas?: boolean;
+}): Promise<BinaryBuffer>;
 import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 //# sourceMappingURL=serialize_scene.d.ts.map

package/src/shade/renderer/scene/serialization/serialize_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialize_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/serialization/serialize_scene.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,gDAJW,YAAY,mDAEZ,kBAAkB,MAAM,CAAC,QAsDnC;AAwJD;;;;GAIG;AACH,wFAgPC;6BA9c4B,yCAAyC"}
+{"version":3,"file":"serialize_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/serialization/serialize_scene.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,gDAJW,YAAY,mDAEZ,kBAAkB,MAAM,CAAC,QAsDnC;AAwJD;;;;;GAKG;AACH;IAH0B,KAAK;IACF,YAAY,GAA9B,OAAO;0BAkPjB;6BA/c4B,yCAAyC"}

package/src/shade/renderer/scene/serialization/serialize_scene.js

@@ -218,8 +218,9 @@ function serialize_light(buffer, light) {
 
 /**
  *
- * @param {Scene} scene
- * @param {boolean} [include_blas] BLAS BVH takes up a lot of space, but it is optimal and will save processing time
+ * @param {Object} options
+ * @param {Scene} options.scene
+ * @param {boolean} [options.include_blas] BLAS BVH takes up a lot of space, but it is optimal and will save processing time
  */
 export async function serialize_scene({
                                           scene,

package/src/shade/renderer/shader/ComputeShader.d.ts

@@ -1,15 +1,21 @@
 export class ComputeShader {
     /**
      *
-     * @param {string} [label]
-     * @param {ShaderResourceSetDescriptor} resources
-     * @param {CodeChunk} body
-     * @param {number[]} [group_size] removed — see {@link group_size_x}. Still destructured only so
+     * @param {Object} options
+     * @param {string} [options.label]
+     * @param {ShaderResourceSetDescriptor} options.resources
+     * @param {CodeChunk} options.body
+     * @param {number[]} [options.group_size] removed — see {@link group_size_x}. Still destructured only so
      * that a call site left over from before the removal fails loudly instead of having its value
      * silently ignored.
      * @returns {ComputeShader}
      */
-    static from({ label, body, resources, group_size, }?: string): ComputeShader;
+    static from({ label, body, resources, group_size, }: {
+        label?: string;
+        resources: ShaderResourceSetDescriptor;
+        body: CodeChunk;
+        group_size?: number[];
+    }): ComputeShader;
     /**
      *
      * @param {ShaderDescriptor} descriptor
@@ -42,11 +48,15 @@ export class ComputeShader {
     get descriptor(): ShaderDescriptor;
     /**
      *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {Object} bindings
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {Object} options.bindings
      * @return {ShadeGPUComputePassEncoder}
      */
-    constructPass({ encoder, bindings }: ShadeGPUCommandContext): ShadeGPUComputePassEncoder;
+    constructPass({ encoder, bindings }: {
+        encoder: ShadeGPUCommandContext;
+        bindings: any;
+    }): ShadeGPUComputePassEncoder;
     /**
      * Shortcut to {@link dispatch}, expressed in threads instead of workgroups.
      *
@@ -56,14 +66,21 @@ export class ComputeShader {
      *
      * NOTE: rounding up means the last group in each dimension is only partially useful, the shader is responsible for discarding threads beyond the requested counts.
      *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {Object} bindings
-     * @param {number} [thread_count_x] number of useful threads to process along X. Must be a non-negative integer. Defaults to `1`.
-     * @param {number} [thread_count_y] number of useful threads to process along Y. Must be a non-negative integer. Defaults to `1`.
-     * @param {number} [thread_count_z] number of useful threads to process along Z. Must be a non-negative integer. Defaults to `1`.
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {Object} options.bindings
+     * @param {number} [options.thread_count_x] number of useful threads to process along X. Must be a non-negative integer. Defaults to `1`.
+     * @param {number} [options.thread_count_y] number of useful threads to process along Y. Must be a non-negative integer. Defaults to `1`.
+     * @param {number} [options.thread_count_z] number of useful threads to process along Z. Must be a non-negative integer. Defaults to `1`.
      * @see dispatch
      */
-    dispatchThreads({ encoder, bindings, thread_count_x, thread_count_y, thread_count_z, }: ShadeGPUCommandContext): void;
+    dispatchThreads({ encoder, bindings, thread_count_x, thread_count_y, thread_count_z, }: {
+        encoder: ShadeGPUCommandContext;
+        bindings: any;
+        thread_count_x?: number;
+        thread_count_y?: number;
+        thread_count_z?: number;
+    }): void;
     /**
      * @deprecated use {@link dispatchThreads} instead, passing `element_count` as `thread_count_x`.
      *
@@ -71,29 +88,47 @@ export class ComputeShader {
      *
      * For example, if we have a workload with 1000 elements, and `@workgroup_size(256,1,1)`. We supply `element_count=1000` and this utility will set group_count to `Math.ceil(1000 / 256) = 4`.
      *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {Object} bindings
-     * @param {number} element_count number of useful threads to process. Must be a non-negative integer.
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {Object} options.bindings
+     * @param {number} options.element_count number of useful threads to process. Must be a non-negative integer.
      * @see dispatchThreads
      */
-    dispatchLinear({ encoder, bindings, element_count }: ShadeGPUCommandContext): void;
+    dispatchLinear({ encoder, bindings, element_count }: {
+        encoder: ShadeGPUCommandContext;
+        bindings: any;
+        element_count: number;
+    }): void;
     /**
      *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {Object} bindings
-     * @param {number} [group_count_x]
-     * @param {number} [group_count_y]
-     * @param {number} [group_count_z]
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {Object} options.bindings
+     * @param {number} [options.group_count_x]
+     * @param {number} [options.group_count_y]
+     * @param {number} [options.group_count_z]
      */
-    dispatch({ encoder, bindings, group_count_x, group_count_y, group_count_z, }: ShadeGPUCommandContext): void;
+    dispatch({ encoder, bindings, group_count_x, group_count_y, group_count_z, }: {
+        encoder: ShadeGPUCommandContext;
+        bindings: any;
+        group_count_x?: number;
+        group_count_y?: number;
+        group_count_z?: number;
+    }): void;
     /**
      *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {GPUBuffer} command
-     * @param {Object} bindings
-     * @param {number} [command_offset] see {@link GPUComputePassEncoder.dispatchWorkgroupsIndirect} indirectOffset parameter
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {GPUBuffer} options.command
+     * @param {Object} options.bindings
+     * @param {number} [options.command_offset] see {@link GPUComputePassEncoder.dispatchWorkgroupsIndirect} indirectOffset parameter
      */
-    dispatchIndirect({ encoder, bindings, command, command_offset }: ShadeGPUCommandContext): void;
+    dispatchIndirect({ encoder, bindings, command, command_offset }: {
+        encoder: ShadeGPUCommandContext;
+        command: GPUBuffer;
+        bindings: any;
+        command_offset?: number;
+    }): void;
     /**
      * @readonly
      * @type {boolean}

package/src/shade/renderer/shader/ComputeShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComputeShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ComputeShader.js"],"names":[],"mappings":"AAMA;IA8FI;;;;;;;;;OASG;IACH,sDARW,MAAM,GAMJ,aAAa,CAuBzB;IA3DD;;;OAGG;IACH,wBAFW,gBAAgB,EAwB1B;IAhFD;;;OAGG;IACH,0CAEC;IAgBD;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,mCAEC;IA+DD;;;;;OAKG;IACH,yFAuBC;IAED;;;;;;;;;;;;;;;OAeG;IACH,sHA6BC;IAED;;;;;;;;;;;OAWG;IACH,mFAmBC;IAED;;;;;;;OAOG;IACH,4GAyCC;IAED;;;;;;OAMG;IACH,+FAsCC;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;0CApVyC,gEAAgE;iCACzE,uBAAuB"}
+{"version":3,"file":"ComputeShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ComputeShader.js"],"names":[],"mappings":"AAMA;IA8FI;;;;;;;;;;OAUG;IACH;QAR4B,KAAK,GAAtB,MAAM;QAC+B,SAAS;QAC3B,IAAI;QACJ,UAAU,GAA7B,MAAM,EAAE;QAGN,aAAa,CAuBzB;IA5DD;;;OAGG;IACH,wBAFW,gBAAgB,EAwB1B;IAhFD;;;OAGG;IACH,0CAEC;IAgBD;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,mCAEC;IAgED;;;;;;OAMG;IACH;QAJ2C,OAAO;QACvB,QAAQ;mCA0BlC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAP2C,OAAO;QACvB,QAAQ;QACP,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;aAgChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACvB,QAAQ;QACR,aAAa,EAA7B,MAAM;aAsBhB;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACvB,QAAQ;QACP,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;aA2ChB;IAED;;;;;;;OAOG;IACH;QAL2C,OAAO;QACpB,OAAO;QACV,QAAQ;QACP,cAAc,GAA/B,MAAM;aAwChB;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;0CA1VyC,gEAAgE;iCACzE,uBAAuB"}

package/src/shade/renderer/shader/ComputeShader.js

@@ -100,10 +100,11 @@ export class ComputeShader {
 
     /**
      *
-     * @param {string} [label]
-     * @param {ShaderResourceSetDescriptor} resources
-     * @param {CodeChunk} body
-     * @param {number[]} [group_size] removed — see {@link group_size_x}. Still destructured only so
+     * @param {Object} options
+     * @param {string} [options.label]
+     * @param {ShaderResourceSetDescriptor} options.resources
+     * @param {CodeChunk} options.body
+     * @param {number[]} [options.group_size] removed — see {@link group_size_x}. Still destructured only so
      * that a call site left over from before the removal fails loudly instead of having its value
      * silently ignored.
      * @returns {ComputeShader}
@@ -133,8 +134,9 @@ export class ComputeShader {
 
     /**
      *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {Object} bindings
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {Object} options.bindings
      * @return {ShadeGPUComputePassEncoder}
      */
     constructPass({
@@ -171,11 +173,12 @@ export class ComputeShader {
      *
      * NOTE: rounding up means the last group in each dimension is only partially useful, the shader is responsible for discarding threads beyond the requested counts.
      *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {Object} bindings
-     * @param {number} [thread_count_x] number of useful threads to process along X. Must be a non-negative integer. Defaults to `1`.
-     * @param {number} [thread_count_y] number of useful threads to process along Y. Must be a non-negative integer. Defaults to `1`.
-     * @param {number} [thread_count_z] number of useful threads to process along Z. Must be a non-negative integer. Defaults to `1`.
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {Object} options.bindings
+     * @param {number} [options.thread_count_x] number of useful threads to process along X. Must be a non-negative integer. Defaults to `1`.
+     * @param {number} [options.thread_count_y] number of useful threads to process along Y. Must be a non-negative integer. Defaults to `1`.
+     * @param {number} [options.thread_count_z] number of useful threads to process along Z. Must be a non-negative integer. Defaults to `1`.
      * @see dispatch
      */
     dispatchThreads({
@@ -216,9 +219,10 @@ export class ComputeShader {
      *
      * For example, if we have a workload with 1000 elements, and `@workgroup_size(256,1,1)`. We supply `element_count=1000` and this utility will set group_count to `Math.ceil(1000 / 256) = 4`.
      *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {Object} bindings
-     * @param {number} element_count number of useful threads to process. Must be a non-negative integer.
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {Object} options.bindings
+     * @param {number} options.element_count number of useful threads to process. Must be a non-negative integer.
      * @see dispatchThreads
      */
     dispatchLinear({
@@ -244,11 +248,12 @@ export class ComputeShader {
 
     /**
      *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {Object} bindings
-     * @param {number} [group_count_x]
-     * @param {number} [group_count_y]
-     * @param {number} [group_count_z]
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {Object} options.bindings
+     * @param {number} [options.group_count_x]
+     * @param {number} [options.group_count_y]
+     * @param {number} [options.group_count_z]
      */
     dispatch({
                  encoder,
@@ -295,10 +300,11 @@ export class ComputeShader {
 
     /**
      *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {GPUBuffer} command
-     * @param {Object} bindings
-     * @param {number} [command_offset] see {@link GPUComputePassEncoder.dispatchWorkgroupsIndirect} indirectOffset parameter
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {GPUBuffer} options.command
+     * @param {Object} options.bindings
+     * @param {number} [options.command_offset] see {@link GPUComputePassEncoder.dispatchWorkgroupsIndirect} indirectOffset parameter
      */
     dispatchIndirect({
                          encoder,

package/src/shade/renderer/shader/ImageShader.d.ts

@@ -4,12 +4,17 @@
 export class ImageShader {
     /**
      * Utility constructor, matching general Shade API
-     * @param {ShaderDescriptor} descriptor
-     * @param {ColorTargetState[]} targets
-     * @param {DepthStencilState} [depthStencil]
+     * @param {Object} options
+     * @param {ShaderDescriptor} options.descriptor
+     * @param {ColorTargetState[]} options.targets
+     * @param {DepthStencilState} [options.depthStencil]
      * @returns {ImageShader}
      */
-    static from({ descriptor, targets, depthStencil, }: ShaderDescriptor): ImageShader;
+    static from({ descriptor, targets, depthStencil, }: {
+        descriptor: ShaderDescriptor;
+        targets: ColorTargetState[];
+        depthStencil?: DepthStencilState;
+    }): ImageShader;
     /**
      *
      * @param {ShaderDescriptor} descriptor

package/src/shade/renderer/shader/ImageShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ImageShader.js"],"names":[],"mappings":"AAQA;;GAEG;AACH;IAyGI;;;;;;OAMG;IACH,uEAFa,WAAW,CAavB;IAlFD;;;;;OAKG;IACH,sEAuDC;IAhGD;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,cAFU,MAAM,EAAE,EAAE,CAEF;IAOlB;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,6BAEC;IAsFD;;;;;;;;;OASG;IACH,6HAsEC;;CACJ"}
+{"version":3,"file":"ImageShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ImageShader.js"],"names":[],"mappings":"AAQA;;GAEG;AACH;IAyGI;;;;;;;OAOG;IACH;QALqC,UAAU;QACR,OAAO,EAAnC,kBAAkB;QACU,YAAY;QACtC,WAAW,CAavB;IAnFD;;;;;OAKG;IACH,sEAuDC;IAhGD;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,cAFU,MAAM,EAAE,EAAE,CAEF;IAOlB;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,6BAEC;IAuFD;;;;;;;;;OASG;IACH,6HAsEC;;CACJ"}

package/src/shade/renderer/shader/ImageShader.js

@@ -116,9 +116,10 @@ export class ImageShader {
     // TODO simplify constructor
     /**
      * Utility constructor, matching general Shade API
-     * @param {ShaderDescriptor} descriptor
-     * @param {ColorTargetState[]} targets
-     * @param {DepthStencilState} [depthStencil]
+     * @param {Object} options
+     * @param {ShaderDescriptor} options.descriptor
+     * @param {ColorTargetState[]} options.targets
+     * @param {DepthStencilState} [options.depthStencil]
      * @returns {ImageShader}
      */
     static from({

package/src/shade/renderer/shader/ShaderDescriptor.d.ts

@@ -1,11 +1,16 @@
 export class ShaderDescriptor {
     /**
      *
-     * @param {string} [label]
-     * @param {ShaderResourceSetDescriptor} [resources] will default to "EMPTY"
-     * @param {CodeChunk} body
+     * @param {Object} options
+     * @param {string} [options.label]
+     * @param {ShaderResourceSetDescriptor} [options.resources] will default to "EMPTY"
+     * @param {CodeChunk} options.body
      */
-    static from({ label, resources, body }?: string): ShaderDescriptor;
+    static from({ label, resources, body }: {
+        label?: string;
+        resources?: ShaderResourceSetDescriptor;
+        body: CodeChunk;
+    }): ShaderDescriptor;
     /**
      *
      * @return {string}
@@ -46,4 +51,5 @@ export class ShaderDescriptor {
     #private;
 }
 import { ShaderResourceSetDescriptor } from "./resource/ShaderResourceSetDescriptor.js";
+import { CodeChunk } from "./compiler/CodeChunk.js";
 //# sourceMappingURL=ShaderDescriptor.d.ts.map

package/src/shade/renderer/shader/ShaderDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ShaderDescriptor.js"],"names":[],"mappings":"AAIA;IA+JI;;;;;OAKG;IACH,yCAJW,MAAM,oBAwBhB;IAlLD;;;OAGG;IACH,oBAEC;IAOD;;;OAGG;IACH,6CAEC;IAaD;;;OAGG;IACH,0CAEC;IAQD;;;OAGG;IACH,qBAQC;IAED;;;OAGG;IACH,WAFY,MAAM,CAiCjB;IAED;;;OAGG;IACH,iDA6BC;IAED;;;;;OAKG;IACH,0CAHa,OAAO,CAenB;;CA6BJ;4CA5L2C,2CAA2C"}
+{"version":3,"file":"ShaderDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ShaderDescriptor.js"],"names":[],"mappings":"AAIA;IA+JI;;;;;;OAMG;IACH;QAJ4B,KAAK,GAAtB,MAAM;QACgC,SAAS,GAA/C,2BAA2B;QACR,IAAI,EAAvB,SAAS;yBAsBnB;IAnLD;;;OAGG;IACH,oBAEC;IAOD;;;OAGG;IACH,6CAEC;IAaD;;;OAGG;IACH,0CAEC;IAQD;;;OAGG;IACH,qBAQC;IAED;;;OAGG;IACH,WAFY,MAAM,CAiCjB;IAED;;;OAGG;IACH,iDA6BC;IAED;;;;;OAKG;IACH,0CAHa,OAAO,CAenB;;CA8BJ;4CA7L2C,2CAA2C;0BAD7D,yBAAyB"}

package/src/shade/renderer/shader/ShaderDescriptor.js

@@ -163,9 +163,10 @@ export class ShaderDescriptor {
 
     /**
      *
-     * @param {string} [label]
-     * @param {ShaderResourceSetDescriptor} [resources] will default to "EMPTY"
-     * @param {CodeChunk} body
+     * @param {Object} options
+     * @param {string} [options.label]
+     * @param {ShaderResourceSetDescriptor} [options.resources] will default to "EMPTY"
+     * @param {CodeChunk} options.body
      */
     static from({
                     label = "",

package/src/shade/renderer/shader/chunk/brdf/dfg/generate_dfg_texture.d.ts

@@ -1,7 +1,11 @@
 /**
  *
- * @param {GraphicsContext} graphics
- * @param {number} [resolution]
+ * @param {Object} options
+ * @param {GraphicsContext} options.graphics
+ * @param {number} [options.resolution]
  */
-export function generate_dfg_texture({ graphics, resolution }: GraphicsContext): void;
+export function generate_dfg_texture({ graphics, resolution }: {
+    graphics: GraphicsContext;
+    resolution?: number;
+}): void;
 //# sourceMappingURL=generate_dfg_texture.d.ts.map