@woosh/meep-engine 2.169.2 → 2.169.4

package/src/engine/ecs/transform/Transform64.js

@@ -0,0 +1,591 @@
+import { assert } from "../../../core/assert.js";
+import { array_copy } from "../../../core/collection/array/array_copy.js";
+import { array_range_equal_strict } from "../../../core/collection/array/array_range_equal_strict.js";
+import { m4_decompose_array } from "../../../core/geom/3d/mat4/m4_decompose_array.js";
+import { m4_from_rotation_translation_scale_scalar } from "../../../core/geom/3d/mat4/m4_from_rotation_translation_scale_scalar.js";
+import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
+
+/**
+ * Index of the first element of the 4x4 affine matrix inside a {@link Transform64}.
+ *
+ * It is 0, which means a `Transform64` can be passed to any `mat4` function directly,
+ * in place of the matrix - `m4_multiply(out, a_transform, b_transform)` and the like.
+ * @type {number}
+ */
+export const TRANSFORM64_MATRIX_OFFSET = 0;
+
+/**
+ * Index of the first element of the translation (x, y, z) inside a {@link Transform64}
+ * @type {number}
+ */
+export const TRANSFORM64_TRANSLATION_OFFSET = 16;
+
+/**
+ * Index of the first element of the rotation quaternion (x, y, z, w) inside a {@link Transform64}
+ * @type {number}
+ */
+export const TRANSFORM64_ROTATION_OFFSET = 19;
+
+/**
+ * Index of the first element of the scale (x, y, z) inside a {@link Transform64}
+ * @type {number}
+ */
+export const TRANSFORM64_SCALE_OFFSET = 23;
+
+/**
+ * Number of elements in a {@link Transform64}
+ * @type {number}
+ */
+export const TRANSFORM64_SIZE = 26;
+
+/**
+ * Position, rotation and scale of an object in 3D space, along with the affine matrix they compose into,
+ * packed into a single `Float64Array`.
+ *
+ * This is the passive counterpart of {@link Transform}. There are no signals, no flags and no change
+ * detection: setting the translation, rotation or scale does **not** refresh {@link matrix}, you call
+ * {@link updateMatrix} yourself once you are done mutating. What you get for that is one allocation of one
+ * contiguous buffer per transform, plain array stores instead of setter dispatch, and double precision
+ * throughout.
+ *
+ * Every element is addressable directly, and the layout is part of the contract, so hot code can read and
+ * write the buffer without going through the accessors:
+ * ```
+ * [ 0..15] matrix, column-major
+ * [16..18] translation  x, y, z
+ * [19..22] rotation     x, y, z, w
+ * [23..25] scale        x, y, z
+ * ```
+ *
+ * @example
+ *  const t = new Transform64();
+ *
+ *  t.setTranslation(1, 2, 3);
+ *  t.setScale(2, 2, 2);
+ *
+ *  // nothing has touched the matrix up to this point
+ *  t.updateMatrix();
+ *
+ * @example
+ *  // reading a component in a hot loop, without the accessors
+ *  const x = t[TRANSFORM64_TRANSLATION_OFFSET];
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class Transform64 extends Float64Array {
+
+    /**
+     * Arrays derived from a transform (`slice`, `subarray`, `map`, ...) are plain `Float64Array`s
+     * @returns {Float64ArrayConstructor}
+     */
+    static get [Symbol.species]() {
+        // without this the derived array would be built by our own constructor, which takes no length,
+        // so it would silently come back sized as a whole transform
+        return Float64Array;
+    }
+
+    constructor() {
+        super(TRANSFORM64_SIZE);
+
+        this.makeIdentity();
+    }
+
+    /**
+     * Affine transform matrix, column-major.
+     *
+     * Unlike {@link Transform}, this is not maintained for you - it holds whatever {@link updateMatrix},
+     * {@link fromMatrix} or {@link multiply} last wrote, and goes stale the moment you set a component.
+     *
+     * NOTE: the returned array is a live view over the transform's own buffer, but a freshly allocated
+     * view on every access. Hold on to it rather than reading this property in a loop, or index the
+     * transform itself - the matrix starts at element 0.
+     * @returns {Float64Array}
+     */
+    get matrix() {
+        return new Float64Array(this.buffer, this.byteOffset, 16);
+    }
+
+    /**
+     * Position in 3D space.
+     * NOTE: live view over the transform's own buffer, freshly allocated on every access
+     * @returns {Float64Array}
+     */
+    get translation() {
+        return new Float64Array(this.buffer, this.byteOffset + TRANSFORM64_TRANSLATION_OFFSET * 8, 3);
+    }
+
+    /**
+     * Reads 3 elements, does not update {@link matrix}
+     * @param {number[]|Float32Array|Float64Array} v
+     */
+    set translation(v) {
+        array_copy(v, 0, this, TRANSFORM64_TRANSLATION_OFFSET, 3);
+    }
+
+    get translation_x() {
+        return this[TRANSFORM64_TRANSLATION_OFFSET];
+    }
+
+    get translation_y() {
+        return this[TRANSFORM64_TRANSLATION_OFFSET + 1];
+    }
+
+    get translation_z() {
+        return this[TRANSFORM64_TRANSLATION_OFFSET + 2];
+    }
+
+    /**
+     * Does not update {@link matrix}
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    setTranslation(x, y, z) {
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
+        assert.isNumber(z, 'z');
+
+        this[TRANSFORM64_TRANSLATION_OFFSET] = x;
+        this[TRANSFORM64_TRANSLATION_OFFSET + 1] = y;
+        this[TRANSFORM64_TRANSLATION_OFFSET + 2] = z;
+    }
+
+    /**
+     * Orientation, as a quaternion (x, y, z, w).
+     * NOTE: live view over the transform's own buffer, freshly allocated on every access
+     * @returns {Float64Array}
+     */
+    get rotation() {
+        return new Float64Array(this.buffer, this.byteOffset + TRANSFORM64_ROTATION_OFFSET * 8, 4);
+    }
+
+    /**
+     * Reads 4 elements, does not update {@link matrix}
+     * @param {number[]|Float32Array|Float64Array} q
+     */
+    set rotation(q) {
+        array_copy(q, 0, this, TRANSFORM64_ROTATION_OFFSET, 4);
+    }
+
+    get rotation_x() {
+        return this[TRANSFORM64_ROTATION_OFFSET];
+    }
+
+    get rotation_y() {
+        return this[TRANSFORM64_ROTATION_OFFSET + 1];
+    }
+
+    get rotation_z() {
+        return this[TRANSFORM64_ROTATION_OFFSET + 2];
+    }
+
+    get rotation_w() {
+        return this[TRANSFORM64_ROTATION_OFFSET + 3];
+    }
+
+    /**
+     * The quaternion is expected to be of unit length, nothing here normalizes it.
+     * Does not update {@link matrix}.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} w
+     */
+    setRotation(x, y, z, w) {
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
+        assert.isNumber(z, 'z');
+        assert.isNumber(w, 'w');
+
+        this[TRANSFORM64_ROTATION_OFFSET] = x;
+        this[TRANSFORM64_ROTATION_OFFSET + 1] = y;
+        this[TRANSFORM64_ROTATION_OFFSET + 2] = z;
+        this[TRANSFORM64_ROTATION_OFFSET + 3] = w;
+    }
+
+    /**
+     * Size along each local axis.
+     * NOTE: live view over the transform's own buffer, freshly allocated on every access
+     * @returns {Float64Array}
+     */
+    get scale() {
+        return new Float64Array(this.buffer, this.byteOffset + TRANSFORM64_SCALE_OFFSET * 8, 3);
+    }
+
+    /**
+     * Reads 3 elements, does not update {@link matrix}
+     * @param {number[]|Float32Array|Float64Array} v
+     */
+    set scale(v) {
+        array_copy(v, 0, this, TRANSFORM64_SCALE_OFFSET, 3);
+    }
+
+    get scale_x() {
+        return this[TRANSFORM64_SCALE_OFFSET];
+    }
+
+    get scale_y() {
+        return this[TRANSFORM64_SCALE_OFFSET + 1];
+    }
+
+    get scale_z() {
+        return this[TRANSFORM64_SCALE_OFFSET + 2];
+    }
+
+    /**
+     * Does not update {@link matrix}
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    setScale(x, y, z) {
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
+        assert.isNumber(z, 'z');
+
+        this[TRANSFORM64_SCALE_OFFSET] = x;
+        this[TRANSFORM64_SCALE_OFFSET + 1] = y;
+        this[TRANSFORM64_SCALE_OFFSET + 2] = z;
+    }
+
+    /**
+     * Uniform scale. Does not update {@link matrix}.
+     * @param {number} s
+     */
+    setScaleScalar(s) {
+        this.setScale(s, s, s);
+    }
+
+    /**
+     * Write {@link matrix} from the current {@link translation}, {@link rotation} and {@link scale}.
+     * Nothing calls this for you, and until you do, the matrix is whatever it was before.
+     */
+    updateMatrix() {
+        m4_from_rotation_translation_scale_scalar(
+            this,
+            this[TRANSFORM64_ROTATION_OFFSET],
+            this[TRANSFORM64_ROTATION_OFFSET + 1],
+            this[TRANSFORM64_ROTATION_OFFSET + 2],
+            this[TRANSFORM64_ROTATION_OFFSET + 3],
+
+            this[TRANSFORM64_TRANSLATION_OFFSET],
+            this[TRANSFORM64_TRANSLATION_OFFSET + 1],
+            this[TRANSFORM64_TRANSLATION_OFFSET + 2],
+
+            this[TRANSFORM64_SCALE_OFFSET],
+            this[TRANSFORM64_SCALE_OFFSET + 1],
+            this[TRANSFORM64_SCALE_OFFSET + 2]
+        );
+    }
+
+    /**
+     * Write {@link translation}, {@link rotation} and {@link scale} from the current {@link matrix}.
+     * The inverse of {@link updateMatrix}; call it after writing the matrix in place.
+     *
+     * A matrix carrying shear cannot be described by a translation, a rotation and a scale, so shear is
+     * dropped from the components. It survives in {@link matrix} until the next {@link updateMatrix}.
+     */
+    updateComponents() {
+        m4_decompose_array(
+            this,
+            this, TRANSFORM64_TRANSLATION_OFFSET,
+            this, TRANSFORM64_ROTATION_OFFSET,
+            this, TRANSFORM64_SCALE_OFFSET
+        );
+    }
+
+    /**
+     * Set the whole transform, matrix and components both, from an affine matrix.
+     * See {@link updateComponents} for how shear is handled.
+     * @param {number[]|Float32Array|Float64Array|mat4} m4 4x4 affine matrix, column-major
+     * @returns {this}
+     */
+    fromMatrix(m4) {
+        assert.isArrayLike(m4, 'm4');
+        assert.greaterThanOrEqual(m4.length, 16, 'm4.length');
+
+        array_copy(m4, 0, this, TRANSFORM64_MATRIX_OFFSET, 16);
+
+        this.updateComponents();
+
+        return this;
+    }
+
+    /**
+     * Post-multiplication, `this = this * other`. See {@link multiplyTransforms}.
+     * @param {Transform64} other
+     * @returns {this}
+     */
+    multiply(other) {
+        return this.multiplyTransforms(this, other);
+    }
+
+    /**
+     * Multiply two transforms, writing the result into this one. Either operand may be this transform.
+     *
+     * Both operands are read through their matrices, not their components, so a stale matrix on either
+     * side produces a stale result - {@link updateMatrix} them first if you have been setting components.
+     * Both the matrix and the components of the result are left up to date.
+     *
+     * @param {Transform64} a
+     * @param {Transform64} b
+     * @returns {this}
+     */
+    multiplyTransforms(a, b) {
+        assert.equal(a.isTransform64, true, 'a.isTransform64 !== true');
+        assert.equal(b.isTransform64, true, 'b.isTransform64 !== true');
+
+        // both operands are fully read into locals before the first write, so aliasing is safe
+        m4_multiply(this, a, b);
+
+        this.updateComponents();
+
+        return this;
+    }
+
+    /**
+     * Reset to the identity transform, matrix included:
+     *      - translation: [0,0,0]
+     *      - rotation:    [0,0,0,1]
+     *      - scale:       [1,1,1]
+     */
+    makeIdentity() {
+        this.fill(0);
+
+        // matrix diagonal
+        this[0] = 1;
+        this[5] = 1;
+        this[10] = 1;
+        this[15] = 1;
+
+        this[TRANSFORM64_ROTATION_OFFSET + 3] = 1;
+
+        this[TRANSFORM64_SCALE_OFFSET] = 1;
+        this[TRANSFORM64_SCALE_OFFSET + 1] = 1;
+        this[TRANSFORM64_SCALE_OFFSET + 2] = 1;
+    }
+
+    /**
+     * Whether the translation is exactly [0,0,0], the rotation exactly [0,0,0,1] and the scale exactly
+     * [1,1,1]. Says nothing about {@link matrix}, which only agrees after an {@link updateMatrix}.
+     * @returns {boolean}
+     */
+    isIdentity() {
+        return this[TRANSFORM64_TRANSLATION_OFFSET] === 0
+            && this[TRANSFORM64_TRANSLATION_OFFSET + 1] === 0
+            && this[TRANSFORM64_TRANSLATION_OFFSET + 2] === 0
+            && this[TRANSFORM64_ROTATION_OFFSET] === 0
+            && this[TRANSFORM64_ROTATION_OFFSET + 1] === 0
+            && this[TRANSFORM64_ROTATION_OFFSET + 2] === 0
+            && this[TRANSFORM64_ROTATION_OFFSET + 3] === 1
+            && this[TRANSFORM64_SCALE_OFFSET] === 1
+            && this[TRANSFORM64_SCALE_OFFSET + 1] === 1
+            && this[TRANSFORM64_SCALE_OFFSET + 2] === 1;
+    }
+
+    /**
+     * Set this transform to match `other`, matrix included. The `other` is left unchanged.
+     * @param {Transform64} other
+     */
+    copy(other) {
+        this.set(other);
+    }
+
+    /**
+     * A new transform equal to this one
+     * @returns {Transform64}
+     */
+    clone() {
+        const r = new Transform64();
+
+        r.copy(this);
+
+        return r;
+    }
+
+    /**
+     * Strict equality across the whole transform, {@link matrix} included. Two transforms whose components
+     * match but whose matrices do not - because one of them is stale - are not equal.
+     * @param {Transform64} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return array_range_equal_strict(this, 0, other, 0, TRANSFORM64_SIZE);
+    }
+
+    /**
+     * Only the translation contributes, for speed - in most applications it is what varies the most.
+     *
+     * This is weaker than {@link equals}: transforms differing only in rotation, scale or matrix collide.
+     * Legal for a hash, but a poor key if your set varies along those axes alone.
+     * @returns {number}
+     */
+    hash() {
+        const x = this[TRANSFORM64_TRANSLATION_OFFSET];
+        const y = this[TRANSFORM64_TRANSLATION_OFFSET + 1];
+        const z = this[TRANSFORM64_TRANSLATION_OFFSET + 2];
+
+        // Same arithmetic as `computeHashFloat`, written out by hand so that this is a straight line with
+        // no calls and no loop. Per component: split into whole and fractional parts, scale the fraction
+        // into uint32 range and flip it so that tiny fractions land in the high bits, then XOR the two.
+        const x_whole = x >> 0;
+        const y_whole = y >> 0;
+        const z_whole = z >> 0;
+
+        const x_hash = (4294967295 - (((x - x_whole) * 4294967295) >>> 0)) ^ x_whole;
+        const y_hash = (4294967295 - (((y - y_whole) * 4294967295) >>> 0)) ^ y_whole;
+        const z_hash = (4294967295 - (((z - z_whole) * 4294967295) >>> 0)) ^ z_whole;
+
+        // mix, `h*31 + v` expressed as a shift so it stays in integer arithmetic
+        let hash = ((x_hash << 5) - x_hash + y_hash) | 0;
+
+        hash = ((hash << 5) - hash + z_hash) | 0;
+
+        return hash;
+    }
+
+    /**
+     * Read the components from `{translation, rotation, scale}`, each of them optional and defaulting to
+     * identity. Composes {@link matrix} from the result.
+     *
+     * NOTE: the translation is keyed `translation`, where {@link Transform} keys the same thing
+     * `position`. The two JSON forms are not interchangeable.
+     * @param json
+     */
+    fromJSON(json) {
+        const t = json.translation;
+
+        if (t !== undefined) {
+            this.setTranslation(t.x, t.y, t.z);
+        } else {
+            this.setTranslation(0, 0, 0);
+        }
+
+        const r = json.rotation;
+
+        if (r !== undefined) {
+            this.setRotation(r.x, r.y, r.z, r.w);
+        } else {
+            this.setRotation(0, 0, 0, 1);
+        }
+
+        const s = json.scale;
+
+        if (s !== undefined) {
+            this.setScale(s.x, s.y, s.z);
+        } else {
+            this.setScale(1, 1, 1);
+        }
+
+        this.updateMatrix();
+    }
+
+    /**
+     * Writes out the components only; {@link matrix} is recomposed from them on the way back in
+     * @returns {{translation:{x:number,y:number,z:number}, rotation:{x:number,y:number,z:number,w:number}, scale:{x:number,y:number,z:number}}}
+     */
+    toJSON() {
+        return {
+            translation: {
+                x: this[TRANSFORM64_TRANSLATION_OFFSET],
+                y: this[TRANSFORM64_TRANSLATION_OFFSET + 1],
+                z: this[TRANSFORM64_TRANSLATION_OFFSET + 2]
+            },
+            rotation: {
+                x: this[TRANSFORM64_ROTATION_OFFSET],
+                y: this[TRANSFORM64_ROTATION_OFFSET + 1],
+                z: this[TRANSFORM64_ROTATION_OFFSET + 2],
+                w: this[TRANSFORM64_ROTATION_OFFSET + 3]
+            },
+            scale: {
+                x: this[TRANSFORM64_SCALE_OFFSET],
+                y: this[TRANSFORM64_SCALE_OFFSET + 1],
+                z: this[TRANSFORM64_SCALE_OFFSET + 2]
+            }
+        };
+    }
+
+    /**
+     * Human-readable form, components only
+     * @returns {string}
+     */
+    toString() {
+        return `Transform64{ translation: [${this.translation_x}, ${this.translation_y}, ${this.translation_z}]`
+            + `, rotation: [${this.rotation_x}, ${this.rotation_y}, ${this.rotation_z}, ${this.rotation_w}]`
+            + `, scale: [${this.scale_x}, ${this.scale_y}, ${this.scale_z}] }`;
+    }
+
+    /**
+     * Build a transform from loose components, with {@link matrix} already composed from them
+     * @param {number} translation_x
+     * @param {number} translation_y
+     * @param {number} translation_z
+     * @param {number} rotation_x
+     * @param {number} rotation_y
+     * @param {number} rotation_z
+     * @param {number} rotation_w
+     * @param {number} scale_x
+     * @param {number} scale_y
+     * @param {number} scale_z
+     * @returns {Transform64}
+     */
+    static from(
+        translation_x, translation_y, translation_z,
+        rotation_x, rotation_y, rotation_z, rotation_w,
+        scale_x, scale_y, scale_z
+    ) {
+        const r = new Transform64();
+
+        r.setTranslation(translation_x, translation_y, translation_z);
+        r.setRotation(rotation_x, rotation_y, rotation_z, rotation_w);
+        r.setScale(scale_x, scale_y, scale_z);
+
+        r.updateMatrix();
+
+        return r;
+    }
+
+    /**
+     * Build a transform from an affine matrix, see {@link fromMatrix}
+     * @param {number[]|Float32Array|Float64Array|mat4} m4 4x4 affine matrix, column-major
+     * @returns {Transform64}
+     */
+    static fromMatrix(m4) {
+        const r = new Transform64();
+
+        r.fromMatrix(m4);
+
+        return r;
+    }
+
+    /**
+     * Build a transform from its JSON form, see {@link fromJSON}
+     * @param json
+     * @returns {Transform64}
+     */
+    static fromJSON(json) {
+        const r = new Transform64();
+
+        r.fromJSON(json);
+
+        return r;
+    }
+}
+
+/**
+ * @readonly
+ * @type {string}
+ */
+Transform64.typeName = "Transform64";
+
+/**
+ * Enables a fast type check, without having to import the class separately.
+ * @readonly
+ * @type {boolean}
+ * @example
+ *  if(t.isTransform64){
+ *      // t is a Transform64, do stuff
+ *  }
+ */
+Transform64.prototype.isTransform64 = true;

package/src/engine/graphics/ecs/mesh/SkeletonUtils.d.ts

@@ -1,5 +1,5 @@
 /**
- *
+ * @deprecated
  * @param {Mesh} component
  * @param {string} boneName
  * @returns {THREE.Bone | null}
@@ -26,14 +26,14 @@ export function findSkeletonBoneByType(skeleton: Skeleton, boneType: HumanoidBon
  */
 export function getSkeletonBoneByType(component: Mesh, boneType: HumanoidBoneType | string): Bone | null;
 /**
- *
+ * @deprecated
  * @param {Mesh} component
  * @param {String} name
  * @returns {Bone | null}
  */
 export function getSkeletonBoneByName_old(component: Mesh, name: string): Bone | null;
 /**
- *
+ * @deprecated
  * @param {Mesh} component
  * @param {String} name
  * @returns {Bone | null}

package/src/engine/graphics/ecs/mesh/SkeletonUtils.js

@@ -6,7 +6,7 @@ import { BoneMapping } from "./skeleton/BoneMapping.js";
 
 
 /**
- *
+ * @deprecated
  * @param {Mesh} component
  * @param {string} boneName
  * @returns {THREE.Bone | null}
@@ -160,7 +160,7 @@ export function getSkeletonBoneByType(component, boneType) {
 
 
 /**
- *
+ * @deprecated
  * @param {Mesh} component
  * @param {String} name
  * @returns {Bone | null}
@@ -199,7 +199,7 @@ export function getSkeletonBoneByName_old(component, name) {
 const stack = [];
 
 /**
- *
+ * @deprecated
  * @param {Mesh} component
  * @param {String} name
  * @returns {Bone | null}
@@ -235,7 +235,7 @@ export function getSkeletonBoneByName(component, name) {
 }
 
 /**
- *
+ * @deprecated
  * @param {Mesh} mesh
  * @returns {Array}
  */

package/src/engine/graphics/ecs/mesh-v2/DeferredBoundsQueue.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Collects {@link ShadedGeometry} components whose bounding box has gone stale under
+ * {@link ShadedGeometryFlags.DeferredBoundsUpdate}, until the owner of the BVH is ready
+ * to take the updates.
+ *
+ * WHY THIS EXISTS
+ *
+ * A {@link Transform} signals `position`, `rotation` and `scale` separately, so one
+ * logical move produces several change notifications: two when a caller sets position
+ * and rotation, three when the transform is written as a matrix (which is what
+ * {@link TransformAttachmentSystem} does for every entity in a hierarchy, and what
+ * `Transform.copy` does). Updating bounds on each of those recomputes the same box and
+ * walks the same path to the BVH root several times over. Parking the component here
+ * instead collapses the batch into one update per component per flush.
+ *
+ * Entries are appended without a membership test; {@link ShadedGeometry} carries the
+ * "already queued" bit so enqueueing stays O(1) and a component appears at most once.
+ */
+export class DeferredBoundsQueue {
+    /**
+     * Number of components waiting for their bounds to be applied.
+     * @returns {number}
+     */
+    get size(): number;
+    /**
+     * Park a component whose bounds have gone stale.
+     *
+     * The caller must not add a component that is already queued — see
+     * {@link ShadedGeometry.updateTransform}, which owns that bit.
+     * @param {ShadedGeometry} sg
+     * @returns {void}
+     */
+    add(sg: ShadedGeometry): void;
+    /**
+     * Apply every parked update, leaving the BVH consistent with the current transforms.
+     *
+     * Components that were unlinked while queued, or whose bounds were already settled by
+     * a read, are skipped.
+     *
+     * Must not be re-entered: nothing reached from here writes to a {@link Transform},
+     * so no component can go dirty while the batch is being applied.
+     * @returns {number} how many components actually had an update applied, which is a
+     * useful profiling signal — it is the number of BVH refits the batch cost
+     */
+    flush(): number;
+    #private;
+}
+//# sourceMappingURL=DeferredBoundsQueue.d.ts.map

package/src/engine/graphics/ecs/mesh-v2/DeferredBoundsQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeferredBoundsQueue.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh-v2/DeferredBoundsQueue.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAaI;;;OAGG;IACH,mBAEC;IAED;;;;;;;OAOG;IACH,yBAFa,IAAI,CAIhB;IAED;;;;;;;;;;OAUG;IACH,SAHa,MAAM,CA2BlB;;CACJ"}