@woosh/meep-engine 3.21.0 → 3.22.0

package/src/shade/playground/particle_system/particle_scene.js

@@ -11,7 +11,6 @@ import { make_sunlight } from "../../renderer/light/make_sunlight.js";
 import { ShadeDrawSide } from "../../renderer/material/ShadeDrawSide.js";
 import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
 import { TransparencyMode } from "../../renderer/material/TransparencyMode.js";
-import { PARTICLE_COUNTER_COUNT } from "../../renderer/particles/data/PARTICLE_COUNTERS.js";
 import { EMITTER_BLEND, EMITTER_PROJECTION } from "../../renderer/particles/data/PARTICLE_EMITTER_STRUCT.js";
 import { particle_node, particle_wire } from "../../renderer/particles/graph/particle_graph_authoring.js";
 import {
@@ -54,23 +53,6 @@ import { fire_effect } from "./particle_prototype.js";
  * - a sunlight and (from the page) the default environment, because the meshes are lit.
  */
 
-/** Bytes {@link encode_stats_copy} writes: 8 counters, then both indirect arg buffers. */
-export const PARTICLE_STATS_BYTES = 64;
-
-const STATS_OFFSET_DISPATCH_ARGS = 32;
-
-/**
- * @typedef {object} ParticleSceneStats
- * @property {number} alive particles alive at the end of the captured frame
- * @property {number} dead free slots left in the pool
- * @property {number} spawn_budget free slots the frame's emitters left unclaimed
- * @property {number} alive_in the snapshot next frame's simulate reads as its input length — the
- *   PADDED length of the coherence list, so it is `sim_padded` from the captured frame, not `alive`
- * @property {number} sim_padded length of the program-coherent list the coherence pass built this
- *   frame; the gap to `alive` is the lanes padding costs to keep each wave on one VM program
- * @property {number[]} dispatch simulate's indirect dispatch args, `[x, y, z]` workgroups
- */
-
 /**
  * What each of the four parametric emitters emits, apart from the fire, whose effect is the worked
  * example next door. Exported so the page can show what each emitter is doing.
@@ -270,45 +252,6 @@ export function animate_particle_scene(emitters, time) {
     orbit.updateMatrices();
 }
 
-/**
- * Copy the counters and simulate's indirect dispatch args into a {@link PARTICLE_STATS_BYTES}-byte
- * MAP_READ destination, for display. Read back to *look at*: nothing here may size a pass.
- *
- * The DRAW args are not here and cannot be: they never leave the frame graph, which allocates them
- * at the build-indirect pass and releases them after the draw. Their instance count is the alive
- * count, which the counters carry anyway.
- *
- * @param {import("../../renderer/particles/GPUParticleSystem.js").GPUParticleSystem} system
- * @param {GPUCommandEncoder} encoder
- * @param {GPUBuffer} destination
- */
-export function encode_stats_copy(system, encoder, destination) {
-    const buffers = system.buffers;
-
-    encoder.copyBufferToBuffer(buffers.counters, 0, destination, 0, PARTICLE_COUNTER_COUNT * 4);
-    encoder.copyBufferToBuffer(buffers.dispatch_args, 0, destination, STATS_OFFSET_DISPATCH_ARGS, 3 * 4);
-}
-
-/**
- * Interpret the bytes {@link encode_stats_copy} wrote.
- *
- * @param {ArrayBuffer} bytes
- * @returns {ParticleSceneStats}
- */
-export function read_stats(bytes) {
-    const words = new Uint32Array(bytes);
-    const dispatch_base = STATS_OFFSET_DISPATCH_ARGS / 4;
-
-    return {
-        alive: words[0],
-        dead: words[1],
-        spawn_budget: words[2],
-        alive_in: words[4],
-        sim_padded: words[5],
-        dispatch: [words[dispatch_base], words[dispatch_base + 1], words[dispatch_base + 2]],
-    };
-}
-
 /**
  * A 64x64 radial-falloff sprite (white, alpha falloff) for soft additive and alpha blobs.
  *

package/src/shade/playground/ssr_variance/reference.d.ts

@@ -12,7 +12,7 @@ export class ReflectionReference extends RenderExtension {
     textures: any[];
     device: any;
     record(frame: any): void;
-    read(): Promise<TypedArray>;
+    read(): Promise<import("../../../core/primitives/TypedArray.js").TypedArray>;
 }
 import { RenderExtension } from "../../renderer/extension/RenderExtension.js";
 //# sourceMappingURL=reference.d.ts.map

package/src/shade/playground/ssr_variance/reference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ssr_variance/reference.js"],"names":[],"mappings":"AA8DA;;;;;EAeC;AAjDD,yFAAyF;AACzF;IAKI,yBAAsD;IAHtD,iBAAgB;IAChB,cAAU;IACV,gBAAc;IACiB,YAAoB;IACnD,yBAmBC;IACD,4BAIC;CACJ;gCA5D+B,6CAA6C"}
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ssr_variance/reference.js"],"names":[],"mappings":"AA8DA;;;;;EAeC;AAjDD,yFAAyF;AACzF;IAKI,yBAAsD;IAHtD,iBAAgB;IAChB,cAAU;IACV,gBAAc;IACiB,YAAoB;IACnD,yBAmBC;IACD,6EAIC;CACJ;gCA5D+B,6CAA6C"}

package/src/shade/playground/vgeo_viewer/README.md

@@ -36,8 +36,17 @@ page pointing at it wrote down.
 
 So a cut can be taken before the file has finished arriving, and this is the interesting part: it is
 **clamped, not wrong**. Where the page holding a refinement is missing, the coarser cluster is drawn
-and a *want* is recorded, and the surface is watertight either way. Three controls turn that into
-something you can watch:
+and a *want* is recorded, and the surface is watertight either way.
+
+"Missing" there means §10's *selectable*, not merely resident: a group is refined into only once
+every page holding one of its parents is here. A group's parents are made by one simplification step
+but grouped for the next one separately, so an asset of more than a page per band puts some of them
+in different pages — and refining into a group because its own page arrived, while a coarse cluster
+still stands in for a parent that has not, draws both over the same surface. Those clamps carry no
+want, because there is nothing to fetch from a cluster that already has the bytes it points at; the
+panel counts them under *of those, on a parent*.
+
+Three controls turn that into something you can watch:
 
 | control | what it shows |
 |---|---|

package/src/shade/playground/vgeo_viewer/cut_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cut_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/cut_geometry.js"],"names":[],"mappings":"AA0QA;;;;;;GAMG;AACH,kEAHW,eAAe,GACb,eAAe,CAsM3B;;;;;;;;;;;;;;;8BA3ZS,MAAM;;;;;;;;;;;AAkLhB;;;;;GAKG;AACH;IACI;;;OAGG;IACH,UAFU,QAAQ,CAEQ;IAE1B;;;OAGG;IACH,WAFU,WAAW,CAEU;IAE/B;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,cAFU,MAAM,CAEC;CACpB;yBAlQwB,qCAAqC"}
+{"version":3,"file":"cut_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/cut_geometry.js"],"names":[],"mappings":"AAqOA;;;;;;GAMG;AACH,kEAHW,eAAe,GACb,eAAe,CAsM3B;;;;;;;;;;;;;;;8BArXS,MAAM;;;;;;;;;;;AA4IhB;;;;;GAKG;AACH;IACI;;;OAGG;IACH,UAFU,QAAQ,CAEQ;IAE1B;;;OAGG;IACH,WAFU,WAAW,CAEU;IAE/B;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,cAFU,MAAM,CAEC;CACpB;yBA5NwB,qCAAqC"}

package/src/shade/playground/vgeo_viewer/cut_geometry.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { UINT16_MAX } from "../../../core/binary/UINT16_MAX.js";
+import { hsv_to_rgb } from "../../../core/color/hsv/hsv_to_rgb.js";
 import {
     decode_octahedron_to_unit
 } from "../../../core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js";
@@ -123,44 +124,6 @@ const stored_normals = new Float32Array(256 * 3);
  */
 const scratch_direction = new Float32Array(3);
 
-/**
- * @param {number} hue in `[0, 1)`
- * @param {number} saturation
- * @param {number} value
- * @param {Float32Array} out
- * @param {number} offset
- */
-function hsv_to_rgb(hue, saturation, value, out, offset) {
-    const sector = hue * 6;
-    const i = Math.floor(sector);
-    const f = sector - i;
-
-    const p = value * (1 - saturation);
-    const q = value * (1 - saturation * f);
-    const t = value * (1 - saturation * (1 - f));
-
-    switch (i % 6) {
-        case 0:
-            out[offset] = value; out[offset + 1] = t; out[offset + 2] = p;
-            break;
-        case 1:
-            out[offset] = q; out[offset + 1] = value; out[offset + 2] = p;
-            break;
-        case 2:
-            out[offset] = p; out[offset + 1] = value; out[offset + 2] = t;
-            break;
-        case 3:
-            out[offset] = p; out[offset + 1] = q; out[offset + 2] = value;
-            break;
-        case 4:
-            out[offset] = t; out[offset + 1] = p; out[offset + 2] = value;
-            break;
-        default:
-            out[offset] = value; out[offset + 1] = p; out[offset + 2] = q;
-            break;
-    }
-}
-
 /**
  * Decode one cluster's stored normal section into unit vectors.
  *
@@ -420,7 +383,7 @@ export function vgeo_build_cut_geometry(cut, color_mode) {
             // cool where the cut is refined, hot where it settled for the most error
             const t = error_span > 0 ? (page.self_error[id] - error_low) / error_span : 0;
 
-            hsv_to_rgb(0.68 * (1 - t), 0.9, 1, tint, 0);
+            hsv_to_rgb(tint, 0, 0.68 * (1 - t), 0.9, 1);
         } else if (color_mode === VGEO_COLOR_MODE.Clamp) {
             /*
              Two colours and nothing in between. Amber is a cluster standing in for a page that has
@@ -433,7 +396,7 @@ export function vgeo_build_cut_geometry(cut, color_mode) {
             tint[1] = waiting ? 0.66 : 0.52;
             tint[2] = waiting ? 0.16 : 0.62;
         } else {
-            hsv_to_rgb((color_key(page, id, color_mode) * HUE_STEP) % 1, 0.85, 1, tint, 0);
+            hsv_to_rgb(tint, 0, (color_key(page, id, color_mode) * HUE_STEP) % 1, 0.85, 1);
         }
 
         const end = first + vertices;

package/src/shade/playground/vgeo_viewer/main.js

@@ -596,6 +596,19 @@ class VGeoViewer {
             ['camera drift', `${this.#drift().toExponential(2)} u`],
         ];
 
+        /*
+         A clamp whose child page is already resident is waiting on a page holding one of that
+         group's *other* parents (§10, activation) — so it is not counted by any want, and without
+         this row the panel reads as `20 waiting on 5 page(s)` while five pages would not have
+         settled all twenty. Only shown when it happens, which on a small asset is never.
+        */
+        if (cut.clamped_on_activation > 0) {
+            rows.push([
+                'of those, on a parent',
+                `<span class="warn">${thousands(cut.clamped_on_activation)}</span>`
+            ]);
+        }
+
         if (cut.broken_child_refs > 0) {
             rows.push(['broken child refs', `<span class="bad">${thousands(cut.broken_child_refs)}</span>`]);
         }
@@ -1275,6 +1288,7 @@ function __state() {
         clusters: cut.clusters.length,
         triangles: cut.triangle_count,
         clamped: cut.clamped,
+        clamped_on_activation: cut.clamped_on_activation,
         wants: cut.wants.length,
         broken_child_refs: cut.broken_child_refs,
     };

package/src/shade/playground/vgeo_viewer/select_cut.d.ts

@@ -28,6 +28,13 @@ export function vgeo_select_cut(reader: VGeoContainerReader, view: VGeoCutView):
  * records carries the exact byte range that would refine it. That is what makes streaming safe in
  * any arrival order, and it is why this file's most interesting number is `clamped`.
  *
+ * "Not here" is `VGeoContainerReader.is_selectable`, not `is_resident`, and the difference is the
+ * one thing about this traversal that is not obvious: a group is refined into only once every page
+ * holding one of its *parents* is installed. Residency alone lets a group be entered through the
+ * parents that arrived while a coarse cluster still covers the one that did not, and then both are
+ * drawn over the same surface. §10 calls that out by name — "no holes **and no double-draw**, in any
+ * arrival order" — and the second half is the one that fails silently.
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -119,6 +126,18 @@ export class VGeoCut {
      * @type {number}
      */
     clamped: number;
+    /**
+     * Of those, the ones whose child group's page is **here** and merely not selectable yet, because
+     * a page holding one of that group's other parents is not.
+     *
+     * They carry no want: there is nothing to fetch from a cluster that already has the bytes it
+     * points at. What unblocks them is elsewhere in the same cut — the cluster clamped directly
+     * against the missing page — so this number is not a second streaming frontier, it is how much
+     * of the coarseness on screen is the ancestor rule holding a group back rather than bandwidth.
+     *
+     * @type {number}
+     */
+    clamped_on_activation: number;
     /**
      * Which clusters those were, keyed `page · 65536 + cluster`. What the panel counts, a display
      * can paint — so the regions still waiting on bytes are visible as regions.

package/src/shade/playground/vgeo_viewer/select_cut.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select_cut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/select_cut.js"],"names":[],"mappings":"AAkOA;;;;;;;;;;;;;;;GAeG;AACH,mEAHW,WAAW,GACT,OAAO,CAwInB;AAhXD;;;;;;;;;;;;;;;GAeG;AAEH;;;GAGG;AACH;IACI;;;OAGG;IACH,KAFU,YAAY,CAEI;IAE1B;;;OAGG;IACH,KAFU,MAAM,CAER;IAER;;;OAGG;IACH,eAFU,MAAM,CAEK;IAErB;;OAEG;IACH,OAFU,MAAM,CAEQ;IAExB;;OAEG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,SAFU,YAAY,CAES;CAClC;AAED;;;;;;;GAOG;AACH;IACI;;;OAGG;IACH,OAFU,UAAU,CAET;IAEX;;;;OAIG;IACH,UAFU,MAAM,EAAE,CAEJ;IAEd;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,cAFU,MAAM,CAEC;IAEjB;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,QAFU,MAAM,CAEL;IAEX;;;;;;;;;;OAUG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;OAIG;IACH,cAFU,IAAI,MAAM,CAAC,CAEI;IAEzB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,OAFU,YAAY,EAAE,CAEb;IAEX;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;OAEG;IACH,aAFU,MAAM,CAEA;CACnB;6BA7JM,6DAA6D"}
+{"version":3,"file":"select_cut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/select_cut.js"],"names":[],"mappings":"AAsPA;;;;;;;;;;;;;;;GAeG;AACH,mEAHW,WAAW,GACT,OAAO,CAgKnB;AA5ZD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;GAGG;AACH;IACI;;;OAGG;IACH,KAFU,YAAY,CAEI;IAE1B;;;OAGG;IACH,KAFU,MAAM,CAER;IAER;;;OAGG;IACH,eAFU,MAAM,CAEK;IAErB;;OAEG;IACH,OAFU,MAAM,CAEQ;IAExB;;OAEG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,SAFU,YAAY,CAES;CAClC;AAED;;;;;;;GAOG;AACH;IACI;;;OAGG;IACH,OAFU,UAAU,CAET;IAEX;;;;OAIG;IACH,UAFU,MAAM,EAAE,CAEJ;IAEd;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,cAFU,MAAM,CAEC;IAEjB;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,QAFU,MAAM,CAEL;IAEX;;;;;;;;;;OAUG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;;;;;;;OAUG;IACH,uBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,cAFU,IAAI,MAAM,CAAC,CAEI;IAEzB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,OAFU,YAAY,EAAE,CAEb;IAEX;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;OAEG;IACH,aAFU,MAAM,CAEA;CACnB;6BAjLM,6DAA6D"}

package/src/shade/playground/vgeo_viewer/select_cut.js

@@ -19,6 +19,13 @@ import { VGEO_SAME_PAGE } from "../../renderer/geometry/virtual/format/cluster/V
  * records carries the exact byte range that would refine it. That is what makes streaming safe in
  * any arrival order, and it is why this file's most interesting number is `clamped`.
  *
+ * "Not here" is `VGeoContainerReader.is_selectable`, not `is_resident`, and the difference is the
+ * one thing about this traversal that is not obvious: a group is refined into only once every page
+ * holding one of its *parents* is installed. Residency alone lets a group be entered through the
+ * parents that arrived while a coarse cluster still covers the one that did not, and then both are
+ * drawn over the same surface. §10 calls that out by name — "no holes **and no double-draw**, in any
+ * arrival order" — and the second half is the one that fails silently.
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -125,6 +132,19 @@ export class VGeoCut {
      */
     clamped = 0;
 
+    /**
+     * Of those, the ones whose child group's page is **here** and merely not selectable yet, because
+     * a page holding one of that group's other parents is not.
+     *
+     * They carry no want: there is nothing to fetch from a cluster that already has the bytes it
+     * points at. What unblocks them is elsewhere in the same cut — the cluster clamped directly
+     * against the missing page — so this number is not a second streaming frontier, it is how much
+     * of the coarseness on screen is the ancestor rule holding a group back rather than bandwidth.
+     *
+     * @type {number}
+     */
+    clamped_on_activation = 0;
+
     /**
      * Which clusters those were, keyed `page · 65536 + cluster`. What the panel counts, a display
      * can paint — so the regions still waiting on bytes are visible as regions.
@@ -336,22 +356,33 @@ export function vgeo_select_cut(reader, view) {
                 continue;
             }
 
-            if (child_ref === VGEO_SAME_PAGE) {
-                push(stack, queued, page_index, page.child_group[id]);
-                continue;
-            }
-
-            if (child_ref >= page.child_page_index.length) {
+            if (child_ref !== VGEO_SAME_PAGE && child_ref >= page.child_page_index.length) {
                 cut.broken_child_refs++;
 
                 select(cut, page, id);
                 continue;
             }
 
-            const child_page = page.child_page_index[child_ref];
+            const child_page = child_ref === VGEO_SAME_PAGE
+                ? page_index
+                : page.child_page_index[child_ref];
 
-            if (reader.is_resident(child_page)) {
-                push(stack, queued, child_page, page.child_group[id]);
+            const child_group = page.child_group[id];
+
+            /*
+             *Selectable*, not resident — §10, and the difference is the whole of this file's
+             correctness. A group's parents are made by one simplification step but grouped for the
+             next one separately, so they can end up in different pages; refining into a group
+             because its own page arrived, while a page holding one of its other parents has not,
+             draws it underneath the coarse cluster still standing in for that parent. Both cover the
+             same surface and the depth buffer picks between them at random. `is_selectable` is the
+             counter that says the group's entire ancestor cone is here.
+
+             `SAME_PAGE` is asked the same question. Being in this page settles where the bytes are
+             and nothing about where the group's other parents live.
+             */
+            if (reader.is_selectable(child_page, child_group)) {
+                push(stack, queued, child_page, child_group);
                 continue;
             }
 
@@ -365,6 +396,19 @@ export function vgeo_select_cut(reader, view) {
 
             select(cut, page, id);
 
+            if (reader.is_resident(child_page)) {
+                /*
+                 §10: a want naming a page that is already installed is an activation recheck, never
+                 a fetch. There is nothing to ask for *here* — what this group is waiting on is a
+                 page holding one of its other parents, and the format stores parent counts rather
+                 than parent references precisely so that nobody has to name it. Another cluster in
+                 this same traversal is clamped directly against that page and wants it, because
+                 monotonicity puts every ancestor of a cluster projecting above τ above τ as well.
+                 */
+                cut.clamped_on_activation++;
+                continue;
+            }
+
             want(wants, page, child_ref, child_page, self_px);
         }
     }

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

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import("../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor} SamplerDescriptor
+ */
 export class GPUSamplerManager {
     constructor(device: any);
     /**
@@ -14,4 +17,5 @@ export class GPUSamplerManager {
     obtain(descriptor: SamplerDescriptor): GPUSampler;
     #private;
 }
+export type SamplerDescriptor = import("../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor;
 //# sourceMappingURL=GPUSamplerManager.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GPUSamplerManager.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GPUSamplerManager.js"],"names":[],"mappings":"AAGA;IAWI,yBAEC;IAED;;;;OAIG;IACH,kDAEC;IAED;;;;OAIG;IACH,kDAKC;;CAEJ"}
+{"version":3,"file":"GPUSamplerManager.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GPUSamplerManager.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;IAWI,yBAEC;IAED;;;;OAIG;IACH,mBAHW,iBAAiB,cAK3B;IAED;;;;OAIG;IACH,mBAHW,iBAAiB,cAQ3B;;CAEJ;gCAvCY,OAAO,4CAA4C,EAAE,iBAAiB"}

package/src/shade/renderer/GPUSamplerManager.js

@@ -1,6 +1,10 @@
 import { assert } from "../../core/assert.js";
 import { Cache } from "../../core/cache/Cache.js";
 
+/**
+ * @typedef {import("../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor} SamplerDescriptor
+ */
+
 export class GPUSamplerManager {
 
     #cache = new Cache({

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

@@ -118,6 +118,8 @@ export class GraphicsContext {
     readonly isGraphicsContext: boolean;
     #private;
 }
+export type BufferDescriptor = import("../descriptor/buffer/BufferDescriptor.js").BufferDescriptor;
+export type PipelineDescriptorBase = import("../descriptor/pipeline/PipelineDescriptorBase.js").PipelineDescriptorBase;
 export type BinaryBuffer = import("../../core/binary/BinaryBuffer.js").BinaryBuffer;
 import { GPUGeometryManager } from "./geometry/GPUGeometryManager.js";
 import { GPUMaterialManager } from "./material/GPUMaterialManager.js";

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

@@ -1 +1 @@
-{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AA4BA;IAoJI,yBA8BC;IAjLD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;OAGG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAkCD;;;;;;;;OAQG;IACH,gGALW,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,mDAFa,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAcC;IAED,4BAEC;IAED,eAmBC;IAED,gBAcC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;2BAtUY,OAAO,mCAAmC,EAAE,YAAY;mCAZlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAXzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAchD,6BAA6B;sCACtB,4CAA4C;iCAbjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAErC,uCAAuC;oCAO7C,kCAAkC;iCARtB,8BAA8B"}
+{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAiCA;IAoJI,yBA8BC;IAjLD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;OAGG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAkCD;;;;;;;;OAQG;IACH,6DANW,sBAAsB,aACtB,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAcC;IAED,4BAEC;IAED,eAmBC;IAED,gBAcC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BA5UY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAjBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAXzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAchD,6BAA6B;sCACtB,4CAA4C;iCAbjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAErC,uCAAuC;oCAO7C,kCAAkC;iCARtB,8BAA8B"}

package/src/shade/renderer/GraphicsContext.js

@@ -20,6 +20,11 @@ import { GPUTextureAllocator } from "./texture/GPUTextureAllocator.js";
 import { TextureManager } from "./texture/TextureManager.js";
 import { VirtualTextureManager } from "./texture/virtual/VirtualTextureManager.js";
 
+/**
+ * @typedef {import("../descriptor/buffer/BufferDescriptor.js").BufferDescriptor} BufferDescriptor
+ * @typedef {import("../descriptor/pipeline/PipelineDescriptorBase.js").PipelineDescriptorBase} PipelineDescriptorBase
+ */
+
 
 /**
  * @typedef {import("../../core/binary/BinaryBuffer.js").BinaryBuffer} BinaryBuffer

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

@@ -357,11 +357,16 @@ export class Renderer {
     get nss(): NSS;
     /**
      *
-     * @param {GPUCanvasContext} [context] Optional, if not provided - one will be created.
-     * @param {GPUDevice} [device] Optional, if not provided - one will be created.
-     * @param {number} [pixelRatio] Optiona, if not provided - will be taken from browser context
+     * @param {Object} [options]
+     * @param {GPUCanvasContext} [options.context] Optional, if not provided - one will be created.
+     * @param {GPUDevice} [options.device] Optional, if not provided - one will be created.
+     * @param {number} [options.pixelRatio] Optional, if not provided - will be taken from browser context
      */
-    initialize({ context, device, pixelRatio, }?: GPUCanvasContext): Promise<void>;
+    initialize({ context, device, pixelRatio, }?: {
+        context?: GPUCanvasContext;
+        device?: GPUDevice;
+        pixelRatio?: number;
+    }): Promise<void>;
     /**
      * Cleanup
      */
@@ -406,6 +411,11 @@ export class Renderer {
     render_to_target(camera: PerspectiveCamera, scene: Scene, time_delta_seconds: number, target: GPUTextureContext): boolean;
     #private;
 }
+export type GPUProfileSession = import("../device/timing/profile/GPUProfileSession.js").GPUProfileSession;
+export type PerspectiveCamera = import("./camera/PerspectiveCamera.js").PerspectiveCamera;
+export type RenderExtension = import("./extension/RenderExtension.js").RenderExtension;
+export type GPUSceneContext = import("./scene/GPUSceneContext.js").GPUSceneContext;
+export type Scene = import("./scene/Scene.js").Scene;
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";

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":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}