@woosh/meep-engine 3.21.0 → 3.23.0

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

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

@@ -1 +1 @@
-{"version":3,"file":"generate_dfg_texture.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/brdf/dfg/generate_dfg_texture.js"],"names":[],"mappings":"AA6EA;;;;GAIG;AACH,sFAyBC"}
+{"version":3,"file":"generate_dfg_texture.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/brdf/dfg/generate_dfg_texture.js"],"names":[],"mappings":"AA8EA;;;;;GAKG;AACH;IAHoC,QAAQ;IAChB,UAAU,GAA3B,MAAM;SA2BhB"}

package/src/shade/renderer/shader/chunk/brdf/dfg/generate_dfg_texture.js

@@ -12,8 +12,9 @@ import { shader_split_sum_dgf_lut } from "./shader_split_sum_dgf_lut.js";
 
 /**
  *
- * @param {FrameGraph} graph
- * @param {number} [texture] graph resource
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {number} [options.texture] graph resource
  */
 function graph_download_texture({
                                     graph,
@@ -77,8 +78,9 @@ function graph_download_texture({
 
 /**
  *
- * @param {GraphicsContext} graphics
- * @param {number} [resolution]
+ * @param {Object} options
+ * @param {GraphicsContext} options.graphics
+ * @param {number} [options.resolution]
  */
 export function generate_dfg_texture({
                                          graphics,

package/src/shade/renderer/shader/fullscreen/create_full_quad_pipeline_descriptor.d.ts

@@ -1,12 +1,19 @@
 /**
  * disable stencil and depth by omitting `depthStencil`.
- * @param {string} label
- * @param {PipelineLayoutDescriptor} layout
- * @param {string} fragment_code
- * @param {ColorTargetState[]} [targets]
- * @param {DepthStencilState} [depthStencil] optional, assumed to have read-only access. Do not include unless you understand the implications.
+ * @param {Object} options
+ * @param {string} options.label
+ * @param {PipelineLayoutDescriptor} options.layout
+ * @param {string} options.fragment_code
+ * @param {ColorTargetState[]} [options.targets]
+ * @param {DepthStencilState} [options.depthStencil] optional, assumed to have read-only access. Do not include unless you understand the implications.
  * @returns {RenderPipelineDescriptor}
  */
-export function create_full_quad_pipeline_descriptor({ label, layout, fragment_code, targets, depthStencil }: string): RenderPipelineDescriptor;
+export function create_full_quad_pipeline_descriptor({ label, layout, fragment_code, targets, depthStencil }: {
+    label: string;
+    layout: PipelineLayoutDescriptor;
+    fragment_code: string;
+    targets?: ColorTargetState[];
+    depthStencil?: DepthStencilState;
+}): RenderPipelineDescriptor;
 import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 //# sourceMappingURL=create_full_quad_pipeline_descriptor.d.ts.map

package/src/shade/renderer/shader/fullscreen/create_full_quad_pipeline_descriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create_full_quad_pipeline_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/fullscreen/create_full_quad_pipeline_descriptor.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,8GAPW,MAAM,GAKJ,wBAAwB,CAwCpC;yCAlDwC,iEAAiE"}
+{"version":3,"file":"create_full_quad_pipeline_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/fullscreen/create_full_quad_pipeline_descriptor.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH;IAP2B,KAAK,EAArB,MAAM;IAC4B,MAAM;IACxB,aAAa,EAA7B,MAAM;IACuB,OAAO,GAApC,kBAAkB;IACU,YAAY;IACtC,wBAAwB,CAwCpC;yCAnDwC,iEAAiE"}

package/src/shade/renderer/shader/fullscreen/create_full_quad_pipeline_descriptor.js

@@ -4,11 +4,12 @@ import { vertex_full_viewport_quad } from "./vertex_full_viewport_quad.js";
 
 /**
  * disable stencil and depth by omitting `depthStencil`.
- * @param {string} label
- * @param {PipelineLayoutDescriptor} layout
- * @param {string} fragment_code
- * @param {ColorTargetState[]} [targets]
- * @param {DepthStencilState} [depthStencil] optional, assumed to have read-only access. Do not include unless you understand the implications.
+ * @param {Object} options
+ * @param {string} options.label
+ * @param {PipelineLayoutDescriptor} options.layout
+ * @param {string} options.fragment_code
+ * @param {ColorTargetState[]} [options.targets]
+ * @param {DepthStencilState} [options.depthStencil] optional, assumed to have read-only access. Do not include unless you understand the implications.
  * @returns {RenderPipelineDescriptor}
  */
 export function create_full_quad_pipeline_descriptor({

package/src/shade/renderer/shader/graph/compute/graph_compute_indirect_pass.d.ts

@@ -1,11 +1,18 @@
 /**
  * Simplified way of running compute shaders
- * @param {FrameGraph} graph
- * @param {ComputeShader} shader
- * @param {Object} bindings typically inputs, but can contain some output bindings as well
- * @param {number} command handle to buffer with indirect command
- * @param {GPUTimer} [timer]
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {ComputeShader} options.shader
+ * @param {Object} options.bindings typically inputs, but can contain some output bindings as well
+ * @param {number} options.command handle to buffer with indirect command
+ * @param {GPUTimer} [options.timer]
  * @returns {Object} outputs, named after resources declared in the shader
  */
-export function graph_compute_indirect_pass({ graph, shader, bindings, command, timer }: FrameGraph): any;
+export function graph_compute_indirect_pass({ graph, shader, bindings, command, timer }: {
+    graph: FrameGraph;
+    shader: ComputeShader;
+    bindings: any;
+    command: number;
+    timer?: GPUTimer;
+}): any;
 //# sourceMappingURL=graph_compute_indirect_pass.d.ts.map

package/src/shade/renderer/shader/graph/compute/graph_compute_indirect_pass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_compute_indirect_pass.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/graph/compute/graph_compute_indirect_pass.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,0GAsDC"}
+{"version":3,"file":"graph_compute_indirect_pass.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/graph/compute/graph_compute_indirect_pass.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH;IAP+B,KAAK;IACF,MAAM;IACb,QAAQ;IACR,OAAO,EAAvB,MAAM;IACa,KAAK;QAyDlC"}

package/src/shade/renderer/shader/graph/compute/graph_compute_indirect_pass.js

@@ -5,11 +5,12 @@ import { graph_prepare_compute_resources } from "./graph_prepare_compute_resourc
 
 /**
  * Simplified way of running compute shaders
- * @param {FrameGraph} graph
- * @param {ComputeShader} shader
- * @param {Object} bindings typically inputs, but can contain some output bindings as well
- * @param {number} command handle to buffer with indirect command
- * @param {GPUTimer} [timer]
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {ComputeShader} options.shader
+ * @param {Object} options.bindings typically inputs, but can contain some output bindings as well
+ * @param {number} options.command handle to buffer with indirect command
+ * @param {GPUTimer} [options.timer]
  * @returns {Object} outputs, named after resources declared in the shader
  */
 export function graph_compute_indirect_pass({

package/src/shade/renderer/shader/graph/compute/graph_compute_pass.d.ts

@@ -1,11 +1,18 @@
 /**
  * Simplified way of running compute shaders
- * @param {FrameGraph} graph
- * @param {ComputeShader} shader
- * @param {Object} bindings typically inputs, but can contain some output bindings as well
- * @param {number[]} group_count
- * @param {GPUTimer} [timer]
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {ComputeShader} options.shader
+ * @param {Object} options.bindings typically inputs, but can contain some output bindings as well
+ * @param {number[]} options.group_count
+ * @param {GPUTimer} [options.timer]
  * @returns {Object} outputs, named after resources declared in the shader
  */
-export function graph_compute_pass({ graph, shader, bindings, group_count, timer }: FrameGraph): any;
+export function graph_compute_pass({ graph, shader, bindings, group_count, timer }: {
+    graph: FrameGraph;
+    shader: ComputeShader;
+    bindings: any;
+    group_count: number[];
+    timer?: GPUTimer;
+}): any;
 //# sourceMappingURL=graph_compute_pass.d.ts.map

package/src/shade/renderer/shader/graph/compute/graph_compute_pass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_compute_pass.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/graph/compute/graph_compute_pass.js"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,qGAkDC"}
+{"version":3,"file":"graph_compute_pass.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/graph/compute/graph_compute_pass.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH;IAP+B,KAAK;IACF,MAAM;IACb,QAAQ;IACN,WAAW,EAA7B,MAAM,EAAE;IACW,KAAK;QAqDlC"}

package/src/shade/renderer/shader/graph/compute/graph_compute_pass.js

@@ -7,11 +7,12 @@ import { graph_prepare_compute_resources } from "./graph_prepare_compute_resourc
 
 /**
  * Simplified way of running compute shaders
- * @param {FrameGraph} graph
- * @param {ComputeShader} shader
- * @param {Object} bindings typically inputs, but can contain some output bindings as well
- * @param {number[]} group_count
- * @param {GPUTimer} [timer]
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {ComputeShader} options.shader
+ * @param {Object} options.bindings typically inputs, but can contain some output bindings as well
+ * @param {number[]} options.group_count
+ * @param {GPUTimer} [options.timer]
  * @returns {Object} outputs, named after resources declared in the shader
  */
 export function graph_compute_pass({

package/src/shade/renderer/shader/graph/graph_image_pass.d.ts

@@ -1,18 +1,32 @@
 /**
  * Simplified way of running image shaders
- * @param {FrameGraph} graph
- * @param {ImageShader} shader
- * @param {Object} [inputs] typically will not be empty
- * @param {number} [input_depth] optional depth texture, will be available in `readOnly` mode for the shader if present
- * @param {number[]} [output_resolution]
- * @param {boolean} [output_mipmaps] should mipmaps be allocated for the output? Only valid when no direct output is specified
- * @param {number} [output_extra_usage_flags] When output textures are created by this function, we can request additional usage flags. What you get by default is RENDER_ATTACHMENT and TEXTURE_BINDING.
- * @param {number[]} [output] Destination textures, color attachments only
- * @param {GPULoadOp} [load_op]
- * @param {GPUStoreOp} [store_op]
- * @param {number[]} [clear_value]
- * @param {number[]} [viewport] Optional. controls `setViewport`
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {ImageShader} options.shader
+ * @param {Object} [options.inputs] typically will not be empty
+ * @param {number} [options.input_depth] optional depth texture, will be available in `readOnly` mode for the shader if present
+ * @param {number[]} [options.output_resolution]
+ * @param {boolean} [options.output_mipmaps] should mipmaps be allocated for the output? Only valid when no direct output is specified
+ * @param {number} [options.output_extra_usage_flags] When output textures are created by this function, we can request additional usage flags. What you get by default is RENDER_ATTACHMENT and TEXTURE_BINDING.
+ * @param {number[]} [options.output] Destination textures, color attachments only
+ * @param {GPULoadOp} [options.load_op]
+ * @param {GPUStoreOp} [options.store_op]
+ * @param {number[]} [options.clear_value]
+ * @param {number[]} [options.viewport] Optional. controls `setViewport`
  * @returns {number[]}
  */
-export function graph_image_pass({ graph, shader, inputs, input_depth, output_resolution, output_mipmaps, output_extra_usage_flags, output, load_op, store_op, clear_value, viewport, }: FrameGraph): number[];
+export function graph_image_pass({ graph, shader, inputs, input_depth, output_resolution, output_mipmaps, output_extra_usage_flags, output, load_op, store_op, clear_value, viewport, }: {
+    graph: FrameGraph;
+    shader: ImageShader;
+    inputs?: any;
+    input_depth?: number;
+    output_resolution?: number[];
+    output_mipmaps?: boolean;
+    output_extra_usage_flags?: number;
+    output?: number[];
+    load_op?: GPULoadOp;
+    store_op?: GPUStoreOp;
+    clear_value?: number[];
+    viewport?: number[];
+}): number[];
 //# sourceMappingURL=graph_image_pass.d.ts.map

package/src/shade/renderer/shader/graph/graph_image_pass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_image_pass.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/graph/graph_image_pass.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;GAeG;AACH,sMAFa,MAAM,EAAE,CAsLpB"}
+{"version":3,"file":"graph_image_pass.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/graph/graph_image_pass.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AACH;IAd+B,KAAK;IACJ,MAAM;IACV,MAAM;IACN,WAAW,GAA5B,MAAM;IACa,iBAAiB,GAApC,MAAM,EAAE;IACU,cAAc,GAAhC,OAAO;IACU,wBAAwB,GAAzC,MAAM;IACa,MAAM,GAAzB,MAAM,EAAE;IACY,OAAO;IACN,QAAQ;IACV,WAAW,GAA9B,MAAM,EAAE;IACW,QAAQ,GAA3B,MAAM,EAAE;IACN,MAAM,EAAE,CAsLpB"}