@woosh/meep-engine 3.20.0 → 3.21.0

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

@@ -0,0 +1,437 @@
+import { assert } from "../../../core/assert.js";
+import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
+import {
+    VGeoPageWant
+} from "../../renderer/geometry/virtual/format/read/VGeoPageWant.js";
+import { VGEO_NO_CHILD } from "../../renderer/geometry/virtual/format/cluster/VGEO_NO_CHILD.js";
+import { VGEO_SAME_PAGE } from "../../renderer/geometry/virtual/format/cluster/VGEO_SAME_PAGE.js";
+
+/**
+ * Selecting a cut from a partially resident container.
+ *
+ * The traversal itself is the runtime's rule, not a debug approximation of it: descend the page
+ * graph from the root's parentless groups, refine a cluster whose error projects above τ, take it
+ * when it does not. What this file adds is the part a whole-file reader never has to think about —
+ * what to do when the page a refinement wants is not here.
+ *
+ * The answer is the format's (`VGEO_FORMAT.md` §10): **draw the coarser cluster and say so**. The
+ * result is a genuine surface — watertight, correct, merely coarser in that region — and the want it
+ * 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`.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * The view a cut is selected for. `VIRTUAL_GEOMETRY_DESIGN.md` §4: a cut is selected at one camera's
+ * distances and pixel budget, and is the wrong cut for any other.
+ */
+export class VGeoCutView {
+    /**
+     * Camera position, object space — the viewer draws at identity, so world and object agree.
+     * @type {Float32Array}
+     */
+    eye = new Float32Array(3);
+
+    /**
+     * Pixels of permitted error. The one quality dial.
+     * @type {number}
+     */
+    tau = 1;
+
+    /**
+     * Height of the render target, in pixels — the projection's numerator.
+     * @type {number}
+     */
+    screen_height = 1080;
+
+    /**
+     * @type {number}
+     */
+    fov_y = 60 * DEG_TO_RAD;
+
+    /**
+     * @type {boolean}
+     */
+    cull_enabled = false;
+
+    /**
+     * Six normalized world-space planes, as {@link Camera.frustum} holds them.
+     * @type {Float32Array}
+     */
+    frustum = new Float32Array(24);
+}
+
+/**
+ * What one traversal came to, including what it had to look at to get there and what it could not
+ * reach.
+ *
+ * A cut holds the {@link VGeoPage} objects it selected from rather than page indices, so it stays
+ * drawable across an eviction: the bytes it needs are reachable from the cut itself. Nothing here
+ * goes stale because residency moved under it.
+ */
+export class VGeoCut {
+    /**
+     * The page each selected cluster came from, parallel to {@link clusters}.
+     * @type {VGeoPage[]}
+     */
+    pages = [];
+
+    /**
+     * Selected clusters, as indices within the page at the same position of {@link pages}. There is
+     * no global cluster id in the format and none in the reader; a cluster is a page and an index.
+     * @type {number[]}
+     */
+    clusters = [];
+
+    /**
+     * @type {number}
+     */
+    triangle_count = 0;
+
+    /**
+     * @type {number}
+     */
+    vertex_count = 0;
+
+    /**
+     * @type {number}
+     */
+    groups_visited = 0;
+
+    /**
+     * @type {number}
+     */
+    clusters_tested = 0;
+
+    /**
+     * Clusters whose subtree the frustum threw away, which is a whole region rather than one
+     * cluster — the reason culling belongs in the traversal and not after it.
+     * @type {number}
+     */
+    culled = 0;
+
+    /**
+     * Clusters that projected above τ and were drawn anyway, because the page holding their
+     * refinement is not resident.
+     *
+     * **This is the number that says a cut is still arriving.** Zero means the cut on screen is the
+     * one the container's own metric selects for this view; anything above it means part of the
+     * surface is standing in for something finer, and {@link wants} says exactly what to fetch to
+     * fix it.
+     *
+     * @type {number}
+     */
+    clamped = 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.
+     * @type {Set<number>}
+     */
+    clamped_keys = new Set();
+
+    /**
+     * Clusters whose `child_ref` names an entry outside their page's child table.
+     *
+     * Impossible in a file the validator accepts, and reachable here precisely because validation is
+     * off by default — so it is counted and the cluster is drawn as a leaf, rather than read out of
+     * bounds or thrown out of a traversal that was two thirds of the way to a picture.
+     *
+     * @type {number}
+     */
+    broken_child_refs = 0;
+
+    /**
+     * The pages this cut would need to stop being clamped, one entry per page, most wanted first.
+     * @type {VGeoPageWant[]}
+     */
+    wants = [];
+
+    /**
+     * Distinct pages the traversal read from.
+     * @type {number}
+     */
+    pages_touched = 0;
+
+    /**
+     * @type {number}
+     */
+    duration_ms = 0;
+}
+
+/**
+ * `VIRTUAL_GEOMETRY_DESIGN.md` §4: `err_px = r_e · screen_height / (2 · tan(fov_y / 2) · d)`, with
+ * `d` the distance to the *closest point* of the sphere.
+ *
+ * A zero error projects to zero unconditionally — otherwise a leaf, whose error is exactly zero,
+ * would become undrawable the moment the camera entered its sphere.
+ *
+ * @param {number} error object-space `r_e`; `+Infinity` for a root's parent
+ * @param {Float32Array} spheres
+ * @param {number} base index of the sphere's first component
+ * @param {Float32Array} eye
+ * @param {number} k `screen_height / (2 · tan(fov_y / 2))`, hoisted out of the loop
+ * @returns {number} pixels
+ */
+function project_error(error, spheres, base, eye, k) {
+    if (error === 0) {
+        return 0;
+    }
+
+    const dx = eye[0] - spheres[base];
+    const dy = eye[1] - spheres[base + 1];
+    const dz = eye[2] - spheres[base + 2];
+
+    const distance = Math.sqrt(dx * dx + dy * dy + dz * dz) - spheres[base + 3];
+
+    if (distance <= 0) {
+        // camera inside the sphere; the projection is unbounded and the cluster must refine
+        return Number.POSITIVE_INFINITY;
+    }
+
+    return (error * k) / distance;
+}
+
+/**
+ * Whether a sphere is entirely outside the frustum.
+ *
+ * Only the five finite planes are tested. The projection is infinite reverse-Z, so the far plane's
+ * row is degenerate and normalizing it produces nothing a test can use.
+ *
+ * @param {Float32Array} frustum
+ * @param {Float32Array} spheres
+ * @param {number} base
+ * @returns {boolean}
+ */
+function sphere_outside_frustum(frustum, spheres, base) {
+    const x = spheres[base];
+    const y = spheres[base + 1];
+    const z = spheres[base + 2];
+    const radius = spheres[base + 3];
+
+    for (let plane = 0; plane < 5; plane++) {
+        const o = plane * 4;
+
+        const distance = frustum[o] * x + frustum[o + 1] * y + frustum[o + 2] * z + frustum[o + 3];
+
+        if (distance < -radius) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Select the cut for a view from whatever the reader currently holds.
+ *
+ * A traversal rather than a flat pass over every cluster, per design §4 — and it gets the cut rule's
+ * first half for free. The rule is `project(parent) > τ AND project(self) ≤ τ`; a group is only ever
+ * reached by descending *through* the cluster whose step consumed it, and that descent happened
+ * precisely because the step projected above τ. Every cluster of a group shares that step's sphere
+ * and error, so the parent test is satisfied by the act of arriving.
+ *
+ * The residency clamp is the live one here, and it is the reason a cut can be taken at all before
+ * the file has finished arriving: a cluster that wants a page nobody has is drawn as it stands.
+ *
+ * @param {VGeoContainerReader} reader
+ * @param {VGeoCutView} view
+ * @returns {VGeoCut}
+ */
+export function vgeo_select_cut(reader, view) {
+    assert.defined(reader.root, 'reader.root — the container must be open');
+
+    const started = performance.now();
+
+    const cut = new VGeoCut();
+
+    const k = view.screen_height / (2 * Math.tan(view.fov_y * 0.5));
+
+    /**
+     * Groups already queued, keyed `page · 65536 + group`. A group is referenced by every sibling
+     * cluster of the step that consumed it, so without this the traversal would expand it once per
+     * parent and the cut would carry duplicates.
+     *
+     * Multiplied rather than shifted: a page index is a u32, and `<<` would wrap it at the sixteenth
+     * page of a large asset.
+     *
+     * @type {Set<number>}
+     */
+    const queued = new Set();
+
+    /**
+     * @type {Set<number>}
+     */
+    const touched = new Set();
+
+    /**
+     * Wants by page index, so that many clamped clusters wanting one page produce one entry — which
+     * is also where {@link VGeoPageWant.reference_count} comes from.
+     * @type {Map<number, VGeoPageWant>}
+     */
+    const wants = new Map();
+
+    /**
+     * Page and group index, interleaved.
+     * @type {number[]}
+     */
+    const stack = [];
+
+    const root = reader.root;
+
+    for (let group = 0; group < root.group_parent_count.length; group++) {
+        // no cluster anywhere refines into this group, so it is the top of the DAG and selectable
+        // with nothing above it
+        if (root.group_parent_count[group] === 0) {
+            queued.add(group);
+            stack.push(0, group);
+        }
+    }
+
+    while (stack.length > 0) {
+        const group = stack.pop();
+        const page_index = stack.pop();
+
+        const page = reader.page(page_index);
+
+        if (page === undefined) {
+            // Evicted between being queued and being reached. Nothing here fetches, so the subtree
+            // is simply not selected; the clusters above it were already taken by whoever queued it.
+            continue;
+        }
+
+        cut.groups_visited++;
+        touched.add(page_index);
+
+        const first = page.group_cluster_first[group];
+        const count = page.group_cluster_count[group];
+
+        for (let i = 0; i < count; i++) {
+            const id = first + i;
+
+            cut.clusters_tested++;
+
+            /*
+             Culling on `self_sphere` rather than on the tight `bounds_sphere`, because this decides
+             the subtree as well as the cluster: monotonicity makes a cluster's self sphere contain
+             every descendant's geometry, so a self sphere outside the frustum means nothing under
+             it can be on screen either.
+             */
+            if (view.cull_enabled
+                && sphere_outside_frustum(view.frustum, page.self_sphere, id * 4)) {
+                cut.culled++;
+                continue;
+            }
+
+            const child_ref = page.child_ref[id];
+
+            const self_px = project_error(
+                page.self_error[id], page.self_sphere, id * 4, view.eye, k
+            );
+
+            if (self_px <= view.tau || child_ref === VGEO_NO_CHILD) {
+                select(cut, page, id);
+                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) {
+                cut.broken_child_refs++;
+
+                select(cut, page, id);
+                continue;
+            }
+
+            const child_page = page.child_page_index[child_ref];
+
+            if (reader.is_resident(child_page)) {
+                push(stack, queued, child_page, page.child_group[id]);
+                continue;
+            }
+
+            /*
+             The clamp. Drawing this cluster is not a fallback for a missing one — it is the correct
+             coarser surface over exactly the region the missing page would have refined, which is
+             what makes an arriving cut watertight at every moment rather than only at the end.
+             */
+            cut.clamped++;
+            cut.clamped_keys.add(page_index * 65536 + id);
+
+            select(cut, page, id);
+
+            want(wants, page, child_ref, child_page, self_px);
+        }
+    }
+
+    cut.wants = Array.from(wants.values()).sort((a, b) => b.priority - a.priority);
+    cut.pages_touched = touched.size;
+    cut.duration_ms = performance.now() - started;
+
+    return cut;
+}
+
+/**
+ * @param {VGeoCut} cut
+ * @param {VGeoPage} page
+ * @param {number} cluster index within `page`
+ */
+function select(cut, page, cluster) {
+    cut.pages.push(page);
+    cut.clusters.push(cluster);
+
+    cut.triangle_count += page.triangle_count[cluster];
+    cut.vertex_count += page.vertex_count[cluster];
+}
+
+/**
+ * @param {number[]} stack
+ * @param {Set<number>} queued
+ * @param {number} page_index
+ * @param {number} group
+ */
+function push(stack, queued, page_index, group) {
+    const key = page_index * 65536 + group;
+
+    if (queued.has(key)) {
+        return;
+    }
+
+    queued.add(key);
+    stack.push(page_index, group);
+}
+
+/**
+ * Record — or reinforce — a want for the page a clamped cluster could not reach.
+ *
+ * Everything the fetch needs comes out of the child table of the page that is already here, which is
+ * the property (§5) that lets refinement cost one round trip and no metadata request.
+ *
+ * @param {Map<number, VGeoPageWant>} wants
+ * @param {VGeoPage} page the resident page holding the clamped cluster
+ * @param {number} child_ref index into that page's child table
+ * @param {number} child_page
+ * @param {number} projected pixels the clamped cluster's error came to
+ */
+function want(wants, page, child_ref, child_page, projected) {
+    let record = wants.get(child_page);
+
+    if (record === undefined) {
+        record = new VGeoPageWant();
+
+        record.page_index = child_page;
+        record.frame_offset = page.child_frame_offset[child_ref];
+        record.fetch_size = page.child_fetch_size[child_ref];
+        record.decoded_size = page.child_decoded_size[child_ref];
+
+        wants.set(child_page, record);
+    }
+
+    record.reference_count++;
+    record.priority = Math.max(record.priority, projected);
+}

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

@@ -48,7 +48,7 @@ export class DynamicResolutionScaling {
     /**
      * @param {number} v
      */
-    set target_frame_rate(arg: number);
+    set target_frame_rate(v: number);
     /**
      * @returns {number}
      */

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

@@ -1 +1 @@
-{"version":3,"file":"DynamicResolutionScaling.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/DynamicResolutionScaling.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAEI;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;;OAIG;IACH,WAFU,MAAM,MAAM,CAEL;IAEjB;;;OAGG;IACH,eAFc,MAAM,KAAK,IAAI,CAEZ;IAEjB;;;OAGG;IACH,qBAFU,MAAM,CAEa;IAE7B;;OAEG;IACH,mCAIC;IAED;;OAEG;IACH,gCAEC;IAED;;;OAGG;IACH,WAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,WAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,WAFU,MAAM,CAEC;IAEjB;;;;;OAKG;IACH,YAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,kBAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,eAFU,MAAM,CAEG;IAEnB;;;;;OAKG;IACH,qBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,0BAFU,MAAM,CAEa;IAE7B;;;OAGG;IACH,uBAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,uBAFU,MAAM,CAEY;IAE5B;;;OAGG;IACH,eAFU,MAAM,CAEG;IA8BnB;;;OAGG;IACH,cAOC;IAED,4EAA4E;IAC5E,qCAEC;IAED,4EAA4E;IAC5E,qCAEC;IAED;;;;;OAKG;IACH,2BAFW,MAAM,QA2DhB;;CAqGJ"}
+{"version":3,"file":"DynamicResolutionScaling.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/DynamicResolutionScaling.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAEI;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;;OAIG;IACH,WAFU,MAAM,MAAM,CAEL;IAEjB;;;OAGG;IACH,WAFU,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAEZ;IAEjB;;;OAGG;IACH,qBAFU,MAAM,CAEa;IAE7B;;OAEG;IACH,iCAIC;IAED;;OAEG;IACH,gCAEC;IAED;;;OAGG;IACH,WAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,WAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,WAFU,MAAM,CAEC;IAEjB;;;;;OAKG;IACH,YAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,kBAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,eAFU,MAAM,CAEG;IAEnB;;;;;OAKG;IACH,qBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,0BAFU,MAAM,CAEa;IAE7B;;;OAGG;IACH,uBAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,uBAFU,MAAM,CAEY;IAE5B;;;OAGG;IACH,eAFU,MAAM,CAEG;IA8BnB;;;OAGG;IACH,cAOC;IAED,4EAA4E;IAC5E,qCAEC;IAED,4EAA4E;IAC5E,qCAEC;IAED;;;;;OAKG;IACH,2BAFW,MAAM,QA2DhB;;CAqGJ"}

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

@@ -21,7 +21,7 @@ export class Renderer {
      * @returns {SceneManager}
      */
     get scenes(): SceneManager;
-    set feature_shadows_enabled(arg: boolean);
+    set feature_shadows_enabled(v: boolean);
     get feature_shadows_enabled(): boolean;
     /**
      * Controls which indirect lighting technique is used for
@@ -72,7 +72,7 @@ export class Renderer {
     feature_tetrahedron_point_shadows: boolean;
     feature_bloom_enabled: boolean;
     feature_automatic_exposure_enabled: boolean;
-    set exposure_compensation(arg: number);
+    set exposure_compensation(v: number);
     /**
      * Fixed exposure, in f-stops, used when {@link feature_automatic_exposure_enabled} is off.
      *
@@ -100,7 +100,7 @@ export class Renderer {
      * history of arbitrary parity. Reset temporal history on the transition.
      * @param {boolean} v
      */
-    set feature_taa_enabled(arg: boolean);
+    set feature_taa_enabled(v: boolean);
     get feature_taa_enabled(): boolean;
     /**
      * Jimenez 2014 reconstruction-filter motion blur, runs between
@@ -212,7 +212,7 @@ export class Renderer {
      *
      * @param {number} v
      */
-    set internal_resolution_scale(arg: number);
+    set internal_resolution_scale(v: number);
     /**
      *
      * @returns {number}
@@ -243,7 +243,7 @@ export class Renderer {
      *
      * @param {number} ratio
      */
-    set pixel_ratio(arg: number);
+    set pixel_ratio(ratio: number);
     /**
      *
      * @return {number}

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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"}

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

@@ -1 +1 @@
-{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AAiIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IA6OI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA0FlB;IAyLD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAsElB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAoChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA6ChB;IAqHD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,kDAFW,MAAM,QAmChB;IA8FD,gBAYC;;CACJ;4BAn6D2B,gCAAgC"}
+{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AAiIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IA6OI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eARW;QACV,IAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAc,CAAC,EAAE,MAAM,CAAC;QACxB,QAAc,EAAE,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAC1E,GACS,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,eALW;QACV,MAAY,EAAE,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC,CAAC;KAC1E,GACS,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA0FlB;IAyLD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAsElB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAoChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA6ChB;IAqHD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,kDAFW,MAAM,QAmChB;IA8FD,gBAYC;;CACJ;4BAn6D2B,gCAAgC"}

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

@@ -1 +1 @@
-{"version":3,"file":"skin_normalize_mesh_frame.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/skin_normalize_mesh_frame.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH;kBAdqB,MAAM;cACV,MAAM;eACL,MAAM;eACN,MAAM;cACP,MAAM;gBACJ,QAAQ;cACV,QAAQ;EA4GxB"}
+{"version":3,"file":"skin_normalize_mesh_frame.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/skin_normalize_mesh_frame.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,uDAfa;IACZ,YAAkB,EAAE,MAAM,CAAC;IAC3B,QAAc,EAAE,MAAM,CAAC;IACvB,SAAe,EAAE,MAAM,CAAC;IACxB,SAAe,EAAE,MAAM,CAAC;IACxB,QAAc,EAAE,MAAM,CAAC;IACvB,UAAgB,EAAE,QAAQ,CAAC;IAC3B,QAAc,EAAE,QAAQ,CAAC;CACtB,CA2GH"}

package/src/shade/renderer/camera/Camera.d.ts

@@ -8,11 +8,11 @@ export class Camera {
      * @type {Float32Array}
      */
     frustum: Float32Array;
-    set near(arg: number);
+    set near(v: number);
     get near(): number;
-    set far(arg: number);
+    set far(v: number);
     get far(): number;
-    set aspect(arg: number);
+    set aspect(v: number);
     get aspect(): number;
     get isReverseZ(): boolean;
     get isInfiniteFar(): boolean;

package/src/shade/renderer/camera/Camera.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Camera.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/Camera.js"],"names":[],"mappings":"AAiFA;IAMI,uBAA8B;IAE9B,0BAA4B;IAC5B,gCAAkC;IAClC,qCAAuC;IAEvC;;;OAGG;IACH,SAFU,YAAY,CAES;IAoB/B,sBAEC;IAED,mBAEC;IAED,qBAEC;IAED,kBAEC;IAED,wBAKC;IAED,qBAEC;IAED,0BAEC;IAED,6BAEC;IAED;;;OAGG;IACH,YAFW,MAAM,QAchB;IAED,aAQC;IAED,iBAEC;IAED,eAMC;IAED;;;OAGG;IACH,cAFW,MAAM,WAQhB;IAED,wBAKC;IAED,0BAEC;IAED,2BAuDC;IAED,uBAIC;IAED,eAQC;;CACJ;4BAvR2B,8CAA8C"}
+{"version":3,"file":"Camera.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/Camera.js"],"names":[],"mappings":"AAiFA;IAMI,uBAA8B;IAE9B,0BAA4B;IAC5B,gCAAkC;IAClC,qCAAuC;IAEvC;;;OAGG;IACH,SAFU,YAAY,CAES;IAoB/B,oBAEC;IAED,mBAEC;IAED,mBAEC;IAED,kBAEC;IAED,sBAKC;IAED,qBAEC;IAED,0BAEC;IAED,6BAEC;IAED;;;OAGG;IACH,YAFW,MAAM,QAchB;IAED,aAQC;IAED,iBAEC;IAED,eAMC;IAED;;;OAGG;IACH,cAFW,MAAM,WAQhB;IAED,wBAKC;IAED,0BAEC;IAED,2BAuDC;IAED,uBAIC;IAED,eAQC;;CACJ;4BAvR2B,8CAA8C"}

package/src/shade/renderer/camera/GPUCameraContext.d.ts

@@ -25,7 +25,7 @@ export class GPUCameraContext {
      *
      * @param {Camera} v
      */
-    set camera(arg: Camera);
+    set camera(v: Camera);
     /**
      *
      * @return {Camera}

package/src/shade/renderer/camera/GPUCameraContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUCameraContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/GPUCameraContext.js"],"names":[],"mappings":"AAWA;IAyEI;;;;OAIG;IACH,+CAIC;IA9ED,iBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,QAFU,cAAc,CAEjB;IAyBP,2CAEC;IAED;;;;OAIG;IACH,qBAHW,MAAM,KACN,MAAM,QAKhB;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,qBAEC;IAaD,0BAMC;IAED;;;;OAIG;IACH,YAHW,gBAAgB,8CAkC1B;IAED,mBAQC;IAED,gBAEC;IAED,eAEC;;CA6EJ;+BArO8B,6BAA6B"}
+{"version":3,"file":"GPUCameraContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/GPUCameraContext.js"],"names":[],"mappings":"AAWA;IAyEI;;;;OAIG;IACH,+CAIC;IA9ED,iBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,QAFU,cAAc,CAEjB;IAyBP,2CAEC;IAED;;;;OAIG;IACH,qBAHW,MAAM,KACN,MAAM,QAKhB;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,qBAEC;IAaD,0BAMC;IAED;;;;OAIG;IACH,YAHW,gBAAgB,8CAkC1B;IAED,mBAQC;IAED,gBAEC;IAED,eAEC;;CA6EJ;+BArO8B,6BAA6B"}

package/src/shade/renderer/camera/OrthographicCamera.d.ts

@@ -1,11 +1,11 @@
 export class OrthographicCamera extends Camera {
-    set left(arg: number);
+    set left(v: number);
     get left(): number;
-    set right(arg: number);
+    set right(v: number);
     get right(): number;
-    set top(arg: number);
+    set top(v: number);
     get top(): number;
-    set bottom(arg: number);
+    set bottom(v: number);
     get bottom(): number;
     /**
      *

package/src/shade/renderer/camera/OrthographicCamera.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OrthographicCamera.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/OrthographicCamera.js"],"names":[],"mappings":"AA4CA;IAgBI,sBAEC;IAND,mBAEC;IAUD,uBAEC;IAND,oBAEC;IAUD,qBAEC;IAND,kBAEC;IAUD,wBAEC;IAND,qBAEC;IAMD;;;OAGG;IACH,2BAFW,MAAM,EAAE,QASlB;IAED;;;OAGG;IACH,YAFW,kBAAkB,QAY5B;IAED,4BAWC;IAaL;;;OAGG;IACH,sBAFU,OAAO,CAEgC;;CANhD;uBA1IsB,aAAa"}
+{"version":3,"file":"OrthographicCamera.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/OrthographicCamera.js"],"names":[],"mappings":"AA4CA;IAgBI,oBAEC;IAND,mBAEC;IAUD,qBAEC;IAND,oBAEC;IAUD,mBAEC;IAND,kBAEC;IAUD,sBAEC;IAND,qBAEC;IAMD;;;OAGG;IACH,2BAFW,MAAM,EAAE,QASlB;IAED;;;OAGG;IACH,YAFW,kBAAkB,QAY5B;IAED,4BAWC;IAaL;;;OAGG;IACH,sBAFU,OAAO,CAEgC;;CANhD;uBA1IsB,aAAa"}

package/src/shade/renderer/camera/PerspectiveCamera.d.ts

@@ -3,7 +3,7 @@ export class PerspectiveCamera extends Camera {
      *
      * @param {number} fov_radians in Radians
      */
-    set fov(arg: number);
+    set fov(fov_radians: number);
     /**
      * In Radians
      * @returns {number}
@@ -13,7 +13,7 @@ export class PerspectiveCamera extends Camera {
      * Utility property to specify FOV in degrees instead of Radians.
      * @param {number} degrees
      */
-    set fov_degrees(arg: number);
+    set fov_degrees(degrees: number);
     /**
      *
      * @returns {number}

package/src/shade/renderer/camera/PerspectiveCamera.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PerspectiveCamera.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/PerspectiveCamera.js"],"names":[],"mappings":"AA+CA;IAYI;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,kBAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,0BAEC;IAED,4BAIC;IAGD;;;OAGG;IACH,YAFW,iBAAiB,QAS3B;IA8BL;;;OAGG;IACH,qBAFU,OAAO,CAE8B;;CAN9C;uBAtIsB,aAAa"}
+{"version":3,"file":"PerspectiveCamera.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/PerspectiveCamera.js"],"names":[],"mappings":"AA+CA;IAYI;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,kBAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,0BAEC;IAED,4BAIC;IAGD;;;OAGG;IACH,YAFW,iBAAiB,QAS3B;IA8BL;;;OAGG;IACH,qBAFU,OAAO,CAE8B;;CAN9C;uBAtIsB,aAAa"}

package/src/shade/renderer/camera/orbital/OrbitalCameraController.d.ts

@@ -47,9 +47,10 @@ export class OrbitalCameraController {
     _lastRecorded: Transform64;
     _lastUpdateTime: number;
     _scratchEye: Vector3;
+    _scratchTarget: Vector3;
     /** Zoom range, in world units (NumericInterval). Mutate `.min/.max` or `.set()`. */
     get distanceLimits(): import("../../../../core/math/interval/NumericInterval.js").NumericInterval;
-    set movement_speed_scale(arg: number);
+    set movement_speed_scale(value: number);
     /** Scene-relative WASD/keyboard move speed. */
     get movement_speed_scale(): number;
     /** Current smoothed orbit distance (radius). */
@@ -72,9 +73,16 @@ export class OrbitalCameraController {
     /**
      * Adopt an external camera transform as the new orbit pose (target is placed
      * `distance` ahead along its forward).
-     * @param {Transform} transform
+     *
+     * Read component-wise rather than through `Vector3.copy`, because a
+     * {@link Transform64} answers `forward` and `translation` with raw
+     * `Float64Array`s — no `.x`, and a `copy` of one silently sets three
+     * undefineds. Those two arrays are also freshly allocated per access, so
+     * each is read once into a scratch that outlives the call.
+     *
+     * @param {Transform64} transform
      */
-    from_transform(transform: Transform): void;
+    from_transform(transform: Transform64): void;
     /**
      * Screen-space pan of the orbit target, in pointer pixels (legacy signature).
      * @param {number} delta_x

package/src/shade/renderer/camera/orbital/OrbitalCameraController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OrbitalCameraController.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/camera/orbital/OrbitalCameraController.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;OAIG;IACH,oBAJW,OAAO,yBAAyB,EAAE,iBAAiB,cACnD,WAAW,yBAuCrB;IAnCG,4DAAoB;IACpB,wBAA4B;IAE5B;;;;;;;;;;;;;OAAwD;IAGxD,uBAA4C;IAI5C,yBAA8C;IAK9C,sBAAwD;IAExD,0BAOE;IAIF,2BAAsC;IAEtC,wBAAgD;IAChD,qBAAgC;IAUpC,oFAAoF;IACpF,kGAEC;IAOD,sCAEC;IAPD,+CAA+C;IAC/C,mCAEC;IAMD,gDAAgD;IAChD,uBAEC;IAED,gFAAgF;IAChF,sBAEC;IAED;;;;OAIG;IACH,WAHW,OAAO,MACP,OAAO,QAUjB;IAED;;;;;OAKG;IACH,YAHW,OAAO,MACP,OAAO,QAUjB;IAED;;;;OAIG;IACH,2CAMC;IAED;;;;OAIG;IACH,aAHW,MAAM,WACN,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,YAJW,MAAM,QAuBhB;IAED,uDAAuD;IACvD,gBAIC;IAMD;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAelB;CACJ;8BAjN6B,mDAAmD;2BADtD,oDAAoD;iCAE9C,uBAAuB;mCACrB,yBAAyB;4BALhC,iDAAiD;oBAFzD,kCAAkC"}
+{"version":3,"file":"OrbitalCameraController.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/camera/orbital/OrbitalCameraController.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;OAIG;IACH,oBAJW,OAAO,yBAAyB,EAAE,iBAAiB,cACnD,WAAW,yBAwCrB;IApCG,4DAAoB;IACpB,wBAA4B;IAE5B;;;;;;;;;;;;;OAAwD;IAGxD,uBAA4C;IAI5C,yBAA8C;IAK9C,sBAAwD;IAExD,0BAOE;IAIF,2BAAsC;IAEtC,wBAAgD;IAChD,qBAAgC;IAChC,wBAAmC;IAUvC,oFAAoF;IACpF,kGAEC;IAOD,wCAEC;IAPD,+CAA+C;IAC/C,mCAEC;IAMD,gDAAgD;IAChD,uBAEC;IAED,gFAAgF;IAChF,sBAEC;IAED;;;;OAIG;IACH,WAHW,OAAO,MACP,OAAO,QAUjB;IAED;;;;;OAKG;IACH,YAHW,OAAO,MACP,OAAO,QAUjB;IAED;;;;;;;;;;;OAWG;IACH,0BAFW,WAAW,QAoBrB;IAED;;;;OAIG;IACH,aAHW,MAAM,WACN,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,YAJW,MAAM,QAuBhB;IAED,uDAAuD;IACvD,gBAIC;IAMD;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAelB;CACJ;8BArO6B,mDAAmD;2BADtD,oDAAoD;iCAE9C,uBAAuB;mCACrB,yBAAyB;4BALhC,iDAAiD;oBAFzD,kCAAkC"}