@woosh/meep-engine 2.169.1 → 2.169.3

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/FULL_SCREEN_QUAD_VERTEX_SHADER.d.ts

@@ -1,2 +1,13 @@
-export const FULL_SCREEN_QUAD_VERTEX_SHADER: "        \n        varying vec2 vUv;\n\n        void main() {\n\n            vUv = uv;\n                \n            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );\n            \n        }";
+/**
+ * Vertex shader for a full-screen quad, NDC form: the quad's own model matrix is ignored and the
+ * position is derived from `uv` directly.
+ *
+ * This used to be a second, hand-typed copy of {@link ScreenSpaceQuadShader.vertexShader} - the
+ * same five lines of GLSL living under two different names, which made the pair impossible to spot
+ * from an import list. `ScreenSpaceQuadShader` is the home (it has more consumers and is co-located
+ * with `glsl_gen_swizzled_read`); this name is kept because it is public surface.
+ *
+ * @type {string}
+ */
+export const FULL_SCREEN_QUAD_VERTEX_SHADER: string;
 //# sourceMappingURL=FULL_SCREEN_QUAD_VERTEX_SHADER.d.ts.map

package/src/engine/graphics/FULL_SCREEN_QUAD_VERTEX_SHADER.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FULL_SCREEN_QUAD_VERTEX_SHADER.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics/FULL_SCREEN_QUAD_VERTEX_SHADER.js"],"names":[],"mappings":"AAAA,6OASW"}
+{"version":3,"file":"FULL_SCREEN_QUAD_VERTEX_SHADER.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics/FULL_SCREEN_QUAD_VERTEX_SHADER.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,6CAFU,MAAM,CAEmE"}

package/src/engine/graphics/FULL_SCREEN_QUAD_VERTEX_SHADER.js

@@ -1,10 +1,14 @@
-export const FULL_SCREEN_QUAD_VERTEX_SHADER = `        
-        varying vec2 vUv;
-
-        void main() {
-
-            vUv = uv;
-                
-            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
-            
-        }`;
+import { ScreenSpaceQuadShader } from "./shaders/ScreenSpaceQuadShader.js";
+
+/**
+ * Vertex shader for a full-screen quad, NDC form: the quad's own model matrix is ignored and the
+ * position is derived from `uv` directly.
+ *
+ * This used to be a second, hand-typed copy of {@link ScreenSpaceQuadShader.vertexShader} - the
+ * same five lines of GLSL living under two different names, which made the pair impossible to spot
+ * from an import list. `ScreenSpaceQuadShader` is the home (it has more consumers and is co-located
+ * with `glsl_gen_swizzled_read`); this name is kept because it is public surface.
+ *
+ * @type {string}
+ */
+export const FULL_SCREEN_QUAD_VERTEX_SHADER = ScreenSpaceQuadShader.vertexShader();

package/src/engine/graphics/ecs/camera/auto_set_camera_clipping_planes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auto_set_camera_clipping_planes.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/camera/auto_set_camera_clipping_planes.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,6FA2FC"}
+{"version":3,"file":"auto_set_camera_clipping_planes.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/camera/auto_set_camera_clipping_planes.js"],"names":[],"mappings":"AA0BA;;;;;;;GAOG;AACH,6FAqEC"}

package/src/engine/graphics/ecs/camera/auto_set_camera_clipping_planes.js

@@ -1,5 +1,6 @@
 import { Frustum as ThreeFrustum } from "three";
 import { frustum3_planes_to_flat_from_three } from "../../../../core/geom/3d/frustum/frustum3_planes_to_flat_from_three.js";
+import { render_layers_compute_depth_range } from "../render_layers_compute_depth_range.js";
 import { frustum_from_camera } from "./frustum_from_camera.js";
 
 const CLIPPING_EPSILON = 0.001;
@@ -54,34 +55,12 @@ export function auto_set_camera_clipping_planes(c, layers) {
     frustum_from_camera(camera, scratch_three_frustum, true);
     frustum3_planes_to_flat_from_three(scratch_three_frustum.planes, scratch_frustum_planes);
 
-    // Depth plane: passes through camera position, normal pointing along the
-    // view direction (-Z in camera local). A world-space point's distance to
-    // this plane equals its signed depth in front of the camera.
-    const m = camera.matrixWorld.elements;
-    const nx = -m[8];
-    const ny = -m[9];
-    const nz = -m[10];
-    const cam_x = m[12];
-    const cam_y = m[13];
-    const cam_z = m[14];
-    const plane_constant = -(nx * cam_x + ny * cam_y + nz * cam_z);
-
-    scratch_range.near = Number.POSITIVE_INFINITY;
-    scratch_range.far = Number.NEGATIVE_INFINITY;
-
-    layers.traverse((layer) => {
-        if (!layer.state.visible) {
-            return;
-        }
-
-        const compute = layer.compute_depth_range;
-
-        if (compute === null) {
-            return;
-        }
-
-        compute(scratch_range, scratch_frustum_planes, nx, ny, nz, plane_constant);
-    });
+    render_layers_compute_depth_range(
+        scratch_range,
+        layers,
+        scratch_frustum_planes,
+        camera.matrixWorld.elements
+    );
 
     let new_near = scratch_range.near - CLIPPING_EPSILON;
     let new_far = scratch_range.far + CLIPPING_EPSILON;

package/src/engine/graphics/ecs/highlight/renderer/HighlightDecodeShader.d.ts

@@ -1,3 +1,2 @@
-export function makeHighlightDecodeShader(): ShaderMaterial;
-import { ShaderMaterial } from "three";
+export function makeHighlightDecodeShader(): import("three").ShaderMaterial;
 //# sourceMappingURL=HighlightDecodeShader.d.ts.map

package/src/engine/graphics/ecs/highlight/renderer/HighlightDecodeShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HighlightDecodeShader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/highlight/renderer/HighlightDecodeShader.js"],"names":[],"mappings":"AAoCA,4DA8BC;+BAlEmD,OAAO"}
+{"version":3,"file":"HighlightDecodeShader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/highlight/renderer/HighlightDecodeShader.js"],"names":[],"mappings":"AAoCA,4EAsBC"}