@woosh/meep-engine 3.47.0 → 3.50.0

package/src/core/geom/3d/shape/record/shape_record_pack.js

@@ -0,0 +1,418 @@
+import { assert } from "../../../../assert.js";
+import { m4_decompose_rigid_array } from "../../mat4/m4_decompose_rigid_array.js";
+import { pose3_compose_array } from "../../pose/pose3_compose_array.js";
+import {
+    SHAPE_RECORD_HULL_PLANE_LIMIT,
+    SHAPE_RECORD_KIND,
+    SHAPE_RECORD_PARAM_0,
+    SHAPE_RECORD_PARAM_1,
+    SHAPE_RECORD_PARAM_2,
+    SHAPE_RECORD_PARAM_3,
+    SHAPE_RECORD_STRIDE
+} from "./ShapeRecord.js";
+import { ShapeRecordKind } from "./ShapeRecordKind.js";
+
+/**
+ * # `AbstractShape3D` → shape records
+ *
+ * The one place a shape is an object rather than a row of floats. It runs when a shape is linked or
+ * changes, never per evaluation.
+ *
+ * Each kind is asked by its prototype marker, as the physics narrowphase asks.
+ *
+ * ## One shape, a run of records
+ *
+ * A shape packs into a run of records, and {@link shape_record_count} says how long:
+ *
+ * - an analytic primitive or a convex hull is one record, posed at the identity;
+ * - a `TransformedShape3D` whose matrix is a rigid motion is its subject's run, each record's pose
+ *   composed with the wrapper's — it moves the subject without changing it;
+ * - a `UnionShape3D` is its children's runs in child order, depth first; its children share its frame;
+ * - anything else is none: a mesh, a heightmap, a wrapper that scales, shears or mirrors, a hull with
+ *   no planes or more than {@link SHAPE_RECORD_HULL_PLANE_LIMIT}. A union holding any of those is none
+ *   as well — a shape packs whole or not at all, so a caller never collides against part of one.
+ *
+ * {@link shape_record_pack} writes record `element` of the run, and hands back its pose within the shape
+ * asked about. A caller packs a shape as
+ *
+ *     const n = shape_record_count(shape);
+ *     for (let i = 0; i < n; i++) {
+ *         shape_record_pack(records, i * stride, poses, i * SHAPE_RECORD_POSE_STRIDE, planes, cursor, shape, i);
+ *         cursor += shape_record_plane_count(records, i * stride);
+ *     }
+ *
+ * Nothing is allocated. Finding element `i` walks the run from its start, so packing a whole union of
+ * `n` leaves costs O(n²) — the price of one call shape for every kind, paid when a shape changes.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Write an analytic primitive's kind and parameters: a sphere, a capsule, a box, a cylinder or a plane.
+ *
+ * The five whose fields are closed-form, and the subset of {@link shape_record_pack} a client takes
+ * when it collides against nothing else. Unused parameters are written as zero.
+ *
+ * @param {Float32Array|Float64Array|number[]} record
+ * @param {number} record_offset where the record starts
+ * @param {AbstractShape3D} shape in its canonical local frame
+ * @returns {boolean} `false` if `shape` is none of the five, in which case nothing was written
+ */
+export function shape_record_pack_analytic(record, record_offset, shape) {
+    if (shape.isSphereShape3D === true) {
+        // Covers UnitSphereShape3D, which is a SphereShape3D of radius 1.
+        record[record_offset + SHAPE_RECORD_KIND] = ShapeRecordKind.Sphere;
+        record[record_offset + SHAPE_RECORD_PARAM_0] = shape.radius;
+        record[record_offset + SHAPE_RECORD_PARAM_1] = 0;
+        record[record_offset + SHAPE_RECORD_PARAM_2] = 0;
+        record[record_offset + SHAPE_RECORD_PARAM_3] = 0;
+
+        return true;
+    }
+
+    if (shape.isCapsuleShape3D === true) {
+        record[record_offset + SHAPE_RECORD_KIND] = ShapeRecordKind.Capsule;
+        record[record_offset + SHAPE_RECORD_PARAM_0] = shape.radius;
+        record[record_offset + SHAPE_RECORD_PARAM_1] = shape.height;
+        record[record_offset + SHAPE_RECORD_PARAM_2] = 0;
+        record[record_offset + SHAPE_RECORD_PARAM_3] = 0;
+
+        return true;
+    }
+
+    if (shape.isBoxShape3D === true) {
+        // Covers UnitCubeShape3D, which is a BoxShape3D pinned to 0.5.
+        const h = shape.half_extents;
+
+        record[record_offset + SHAPE_RECORD_KIND] = ShapeRecordKind.Box;
+        record[record_offset + SHAPE_RECORD_PARAM_0] = h.x;
+        record[record_offset + SHAPE_RECORD_PARAM_1] = h.y;
+        record[record_offset + SHAPE_RECORD_PARAM_2] = h.z;
+        record[record_offset + SHAPE_RECORD_PARAM_3] = 0;
+
+        return true;
+    }
+
+    if (shape.isCylinderShape3D === true) {
+        record[record_offset + SHAPE_RECORD_KIND] = ShapeRecordKind.Cylinder;
+        record[record_offset + SHAPE_RECORD_PARAM_0] = shape.radius;
+        record[record_offset + SHAPE_RECORD_PARAM_1] = shape.height;
+        record[record_offset + SHAPE_RECORD_PARAM_2] = 0;
+        record[record_offset + SHAPE_RECORD_PARAM_3] = 0;
+
+        return true;
+    }
+
+    if (shape.isPlaneShape3D === true) {
+        record[record_offset + SHAPE_RECORD_KIND] = ShapeRecordKind.Plane;
+        record[record_offset + SHAPE_RECORD_PARAM_0] = shape.normal_x;
+        record[record_offset + SHAPE_RECORD_PARAM_1] = shape.normal_y;
+        record[record_offset + SHAPE_RECORD_PARAM_2] = shape.normal_z;
+        record[record_offset + SHAPE_RECORD_PARAM_3] = shape.offset;
+
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * How many records `shape` packs into. See the module comment for what packs and how.
+ *
+ * @param {AbstractShape3D} shape
+ * @returns {number} `0` when the shape, or any part of it, has no record form
+ */
+export function shape_record_count(shape) {
+    if (shape.isUnionShape3D === true) {
+        const children = shape.children;
+        const child_count = children.length;
+
+        let total = 0;
+
+        for (let i = 0; i < child_count; i++) {
+            const records = shape_record_count(children[i]);
+
+            if (records === 0) {
+                return 0;
+            }
+
+            total += records;
+        }
+
+        return total;
+    }
+
+    if (shape.isTransformedShape3D === true) {
+        if (shape.subject === null || !m4_decompose_rigid_array(shape.transform, COUNT_TRANSLATION, 0, COUNT_ROTATION, 0)) {
+            return 0;
+        }
+
+        return shape_record_count(shape.subject);
+    }
+
+    if (shape.isConvexHullShape3D === true) {
+        const plane_count = convex_hull_plane_count(shape);
+
+        return plane_count > 0 && plane_count <= SHAPE_RECORD_HULL_PLANE_LIMIT ? 1 : 0;
+    }
+
+    // Asked by packing into a scratch record, so the analytic kinds are listed once.
+    return shape_record_pack_analytic(COUNT_RECORD, 0, shape) ? 1 : 0;
+}
+
+/**
+ * Write record `element` of `shape`'s run, and its pose within `shape`.
+ *
+ * PRECONDITION: `element < shape_record_count(shape)`. Outside it this answers `false` and writes
+ * nothing — with one exception: a hull past {@link SHAPE_RECORD_HULL_PLANE_LIMIT} asked for directly (or
+ * through rigid wrappers) fails an assertion, since it is the one refusal an author fixes by editing the
+ * shape. In a build with assertions stripped it is refused like the rest.
+ *
+ * A hull's planes go to `planes` from plane `plane_index` on, its zero planes skipped (a face with no
+ * area has an all-zero plane in `face_loop_planes`); the record holds `plane_index` and the count, which
+ * {@link shape_record_plane_count} reads back. Every other kind leaves `planes` alone.
+ *
+ * @param {Float32Array|Float64Array|number[]} record
+ * @param {number} record_offset where the record starts
+ * @param {Float32Array|Float64Array|number[]} pose receives `[tx, ty, tz, qx, qy, qz, qw]`: where the
+ *   record's local frame sits in `shape`'s, a translation and a unit quaternion
+ * @param {number} pose_offset
+ * @param {Float32Array|Float64Array} planes receives a hull's planes, four floats each `(nx, ny, nz, d)`
+ * @param {number} plane_index the first plane a hull may write, in planes rather than floats
+ * @param {AbstractShape3D} shape
+ * @param {number} element which record of the run, from 0
+ * @returns {boolean} whether the record and its pose were written
+ */
+export function shape_record_pack(record, record_offset, pose, pose_offset, planes, plane_index, shape, element) {
+    assert.isNonNegativeInteger(element, 'element');
+
+    const translation = PACK_TRANSLATION;
+    const rotation = PACK_ROTATION;
+
+    translation[0] = 0;
+    translation[1] = 0;
+    translation[2] = 0;
+
+    rotation[0] = 0;
+    rotation[1] = 0;
+    rotation[2] = 0;
+    rotation[3] = 1;
+
+    let subject = shape;
+    let remaining = element;
+
+    // Down through the unions and rigid wrappers to the one primitive the element names, composing
+    // each wrapper's pose on the way.
+    for (; ;) {
+        if (subject.isUnionShape3D === true) {
+            const children = subject.children;
+            const child_count = children.length;
+
+            let next = null;
+
+            for (let i = 0; i < child_count; i++) {
+                const records = shape_record_count(children[i]);
+
+                if (records === 0) {
+                    // the union has no run, so it has no element either
+                    return false;
+                }
+
+                if (next === null) {
+                    if (remaining < records) {
+                        next = children[i];
+                    } else {
+                        remaining -= records;
+                    }
+                }
+            }
+
+            if (next === null) {
+                return false;
+            }
+
+            subject = next;
+        } else if (subject.isTransformedShape3D === true) {
+            if (subject.subject === null
+                || !m4_decompose_rigid_array(subject.transform, WRAPPER_TRANSLATION, 0, WRAPPER_ROTATION, 0)) {
+                return false;
+            }
+
+            // pose ∘ wrapper: t = t_pose + q_pose · t_wrapper, q = q_pose ⊗ q_wrapper
+            pose3_compose_array(
+                translation, 0, rotation, 0,
+                translation, 0, rotation, 0,
+                WRAPPER_TRANSLATION, 0, WRAPPER_ROTATION, 0
+            );
+
+            subject = subject.subject;
+        } else {
+            break;
+        }
+    }
+
+    if (remaining !== 0) {
+        // a primitive is a run of one
+        return false;
+    }
+
+    if (subject.isConvexHullShape3D === true) {
+        if (!pack_convex_hull(record, record_offset, planes, plane_index, subject)) {
+            return false;
+        }
+    } else if (!shape_record_pack_analytic(record, record_offset, subject)) {
+        return false;
+    }
+
+    pose[pose_offset] = translation[0];
+    pose[pose_offset + 1] = translation[1];
+    pose[pose_offset + 2] = translation[2];
+    pose[pose_offset + 3] = rotation[0];
+    pose[pose_offset + 4] = rotation[1];
+    pose[pose_offset + 5] = rotation[2];
+    pose[pose_offset + 6] = rotation[3];
+
+    return true;
+}
+
+/**
+ * How many planes a record holds in its plane array: a hull's count, and zero for every other kind. What
+ * a caller advances its plane cursor by after packing a record.
+ *
+ * @param {Float32Array|Float64Array|number[]} record
+ * @param {number} record_offset
+ * @returns {number}
+ */
+export function shape_record_plane_count(record, record_offset) {
+    if (record[record_offset + SHAPE_RECORD_KIND] !== ShapeRecordKind.ConvexHull) {
+        return 0;
+    }
+
+    return record[record_offset + SHAPE_RECORD_PARAM_1];
+}
+
+/**
+ * The planes of a hull's faces that have one: `face_loop_planes` holds an all-zero plane for a face
+ * with no area, which bounds nothing.
+ *
+ * @param {ConvexHullShape3D} hull
+ * @returns {number}
+ */
+function convex_hull_plane_count(hull) {
+    const source = hull.face_loop_planes;
+    const length = source.length;
+
+    let count = 0;
+
+    for (let o = 0; o < length; o += 4) {
+        if (source[o] !== 0 || source[o + 1] !== 0 || source[o + 2] !== 0) {
+            count++;
+        }
+    }
+
+    return count;
+}
+
+/**
+ * @param {Float32Array|Float64Array|number[]} record
+ * @param {number} record_offset
+ * @param {Float32Array|Float64Array} planes
+ * @param {number} plane_index
+ * @param {ConvexHullShape3D} hull
+ * @returns {boolean}
+ */
+function pack_convex_hull(record, record_offset, planes, plane_index, hull) {
+    const plane_count = convex_hull_plane_count(hull);
+
+    assert.lessThanOrEqual(plane_count, SHAPE_RECORD_HULL_PLANE_LIMIT,
+        'A hull record holds at most SHAPE_RECORD_HULL_PLANE_LIMIT planes, and shape_record_count answers 0 for this one');
+
+    if (plane_count === 0 || plane_count > SHAPE_RECORD_HULL_PLANE_LIMIT) {
+        return false;
+    }
+
+    assert.isNonNegativeInteger(plane_index, 'plane_index');
+    assert.lessThanOrEqual((plane_index + plane_count) * 4, planes.length, 'planes has no room for the hull');
+
+    const source = hull.face_loop_planes;
+    const length = source.length;
+
+    let write = plane_index * 4;
+
+    for (let o = 0; o < length; o += 4) {
+        const nx = source[o];
+        const ny = source[o + 1];
+        const nz = source[o + 2];
+
+        if (nx === 0 && ny === 0 && nz === 0) {
+            continue;
+        }
+
+        planes[write] = nx;
+        planes[write + 1] = ny;
+        planes[write + 2] = nz;
+        planes[write + 3] = source[o + 3];
+
+        write += 4;
+    }
+
+    // The planes are the shape and say nothing of its extent without solving for its corners, so the
+    // record carries a bound beside them: the sphere about the local origin that holds every vertex.
+    const vertices = hull.vertices;
+    const vertex_floats = vertices.length;
+
+    let radius_sqr = 0;
+
+    for (let v = 0; v < vertex_floats; v += 3) {
+        const x = vertices[v];
+        const y = vertices[v + 1];
+        const z = vertices[v + 2];
+
+        const d = x * x + y * y + z * z;
+
+        if (d > radius_sqr) {
+            radius_sqr = d;
+        }
+    }
+
+    record[record_offset + SHAPE_RECORD_KIND] = ShapeRecordKind.ConvexHull;
+    record[record_offset + SHAPE_RECORD_PARAM_0] = plane_index;
+    record[record_offset + SHAPE_RECORD_PARAM_1] = plane_count;
+    record[record_offset + SHAPE_RECORD_PARAM_2] = Math.sqrt(radius_sqr);
+    record[record_offset + SHAPE_RECORD_PARAM_3] = 0;
+
+    return true;
+}
+
+/**
+ * {@link shape_record_count}'s analytic test writes here.
+ * @type {Float64Array}
+ * @private
+ */
+const COUNT_RECORD = new Float64Array(SHAPE_RECORD_STRIDE);
+
+/**
+ * {@link shape_record_count}'s rigid test writes here; only its answer is read.
+ * @type {Float64Array}
+ * @private
+ */
+const COUNT_TRANSLATION = new Float64Array(3);
+const COUNT_ROTATION = new Float64Array(4);
+
+/**
+ * The pose composed down the wrappers by {@link shape_record_pack}, in double precision whatever the
+ * caller's `pose` holds, so a deep nest rounds once.
+ * @type {Float64Array}
+ * @private
+ */
+const PACK_TRANSLATION = new Float64Array(3);
+const PACK_ROTATION = new Float64Array(4);
+
+/**
+ * One wrapper's rigid motion, as {@link m4_decompose_rigid_array} gives it.
+ * @type {Float64Array}
+ * @private
+ */
+const WRAPPER_TRANSLATION = new Float64Array(3);
+const WRAPPER_ROTATION = new Float64Array(4);

package/src/core/geom/3d/shape/record/shape_record_pack_bounding_box.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Write a shape's bounding box, in the shape's own frame, as one `Box` record, and the box's centre as
+ * the record's pose within the shape: the stand-in for a shape that has no record of its own (a mesh,
+ * a heightmap, a wrapper that scales, shears or mirrors, a hull past
+ * {@link SHAPE_RECORD_HULL_PLANE_LIMIT} planes, a union holding any of them), wherever a box that holds
+ * it is good enough.
+ *
+ * The box holds the shape, so its field is never above the shape's: `d_box(x) ≤ d_shape(x)` at every
+ * point. A solid test against it (`d ≤ r`) answers true wherever the shape's does, and more often.
+ *
+ * Nothing is allocated, beyond what the shape's own `compute_bounding_box` does.
+ *
+ * @param {Float32Array|Float64Array|number[]} record
+ * @param {number} record_offset where the record starts
+ * @param {Float32Array|Float64Array|number[]} pose receives `[tx, ty, tz, qx, qy, qz, qw]`, the box's
+ *   centre and the identity
+ * @param {number} pose_offset
+ * @param {AbstractShape3D} shape
+ * @returns {boolean} `false` when the box is not finite (an unbounded shape, such as a plane under a
+ *   wrapper), in which case nothing was written
+ */
+export function shape_record_pack_bounding_box(record: Float32Array | Float64Array | number[], record_offset: number, pose: Float32Array | Float64Array | number[], pose_offset: number, shape: AbstractShape3D): boolean;
+//# sourceMappingURL=shape_record_pack_bounding_box.d.ts.map

package/src/core/geom/3d/shape/record/shape_record_pack_bounding_box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape_record_pack_bounding_box.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/record/shape_record_pack_bounding_box.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uDATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,iBAClC,MAAM,QACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,eAElC,MAAM,2BAEJ,OAAO,CAmCnB"}

package/src/core/geom/3d/shape/record/shape_record_pack_bounding_box.js

@@ -0,0 +1,69 @@
+import {
+    SHAPE_RECORD_KIND,
+    SHAPE_RECORD_PARAM_0,
+    SHAPE_RECORD_PARAM_1,
+    SHAPE_RECORD_PARAM_2,
+    SHAPE_RECORD_PARAM_3
+} from "./ShapeRecord.js";
+import { ShapeRecordKind } from "./ShapeRecordKind.js";
+
+/**
+ * Write a shape's bounding box, in the shape's own frame, as one `Box` record, and the box's centre as
+ * the record's pose within the shape: the stand-in for a shape that has no record of its own (a mesh,
+ * a heightmap, a wrapper that scales, shears or mirrors, a hull past
+ * {@link SHAPE_RECORD_HULL_PLANE_LIMIT} planes, a union holding any of them), wherever a box that holds
+ * it is good enough.
+ *
+ * The box holds the shape, so its field is never above the shape's: `d_box(x) ≤ d_shape(x)` at every
+ * point. A solid test against it (`d ≤ r`) answers true wherever the shape's does, and more often.
+ *
+ * Nothing is allocated, beyond what the shape's own `compute_bounding_box` does.
+ *
+ * @param {Float32Array|Float64Array|number[]} record
+ * @param {number} record_offset where the record starts
+ * @param {Float32Array|Float64Array|number[]} pose receives `[tx, ty, tz, qx, qy, qz, qw]`, the box's
+ *   centre and the identity
+ * @param {number} pose_offset
+ * @param {AbstractShape3D} shape
+ * @returns {boolean} `false` when the box is not finite (an unbounded shape, such as a plane under a
+ *   wrapper), in which case nothing was written
+ */
+export function shape_record_pack_bounding_box(record, record_offset, pose, pose_offset, shape) {
+    const box = BOX;
+
+    shape.compute_bounding_box(box);
+
+    const x0 = box[0];
+    const y0 = box[1];
+    const z0 = box[2];
+    const x1 = box[3];
+    const y1 = box[4];
+    const z1 = box[5];
+
+    // also refuses NaN
+    if (!(x1 - x0 < Infinity && y1 - y0 < Infinity && z1 - z0 < Infinity && x1 >= x0 && y1 >= y0 && z1 >= z0)) {
+        return false;
+    }
+
+    record[record_offset + SHAPE_RECORD_KIND] = ShapeRecordKind.Box;
+    record[record_offset + SHAPE_RECORD_PARAM_0] = (x1 - x0) * 0.5;
+    record[record_offset + SHAPE_RECORD_PARAM_1] = (y1 - y0) * 0.5;
+    record[record_offset + SHAPE_RECORD_PARAM_2] = (z1 - z0) * 0.5;
+    record[record_offset + SHAPE_RECORD_PARAM_3] = 0;
+
+    pose[pose_offset] = (x0 + x1) * 0.5;
+    pose[pose_offset + 1] = (y0 + y1) * 0.5;
+    pose[pose_offset + 2] = (z0 + z1) * 0.5;
+    pose[pose_offset + 3] = 0;
+    pose[pose_offset + 4] = 0;
+    pose[pose_offset + 5] = 0;
+    pose[pose_offset + 6] = 1;
+
+    return true;
+}
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const BOX = new Float64Array(6);

package/src/core/geom/3d/shape/record/shape_record_signed_distance.d.ts

@@ -0,0 +1,52 @@
+/**
+ * # Evaluating a shape record
+ *
+ * Signed distance and its gradient at a point in the record's own local frame: a branch on the kind,
+ * then the `sdf3_*` field the parameters were laid out for, read where they sit. The fields are the
+ * ones the shapes themselves call, so a record and the shape it was packed from answer from one
+ * implementation; this is the CPU oracle a GPU evaluation of the same records is held to.
+ *
+ * ## A hull is the maximum over its planes
+ *
+ *     d(x) = max_i (n_i · x − d_i)
+ *
+ * **Exact inside**: from a point inside a convex polytope the nearest surface point is the foot on the
+ * nearest face's plane, and that foot is on the face. **Exact outside where the nearest surface point
+ * is inside a face.** Outside near an edge or a corner it is **conservative** — it reads the distance to
+ * the nearest plane, never more than the distance to the solid — so a solid test (`d ≤ r`) answers
+ * true at least as often as the exact field, and a margin grows the hull towards its planes' wedge
+ * rather than towards a rounded edge. The gradient is the normal of the plane that attains the maximum.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Signed distance from a point to a record's surface, negative inside, in the record's local frame.
+ *
+ * @param {Float32Array|Float64Array|number[]} record
+ * @param {number} record_offset where the record starts
+ * @param {Float32Array|Float64Array|number[]} planes the plane array a hull record was packed with;
+ *   read only for a hull
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
+export function shape_record_signed_distance(record: Float32Array | Float64Array | number[], record_offset: number, planes: Float32Array | Float64Array | number[], x: number, y: number, z: number): number;
+/**
+ * Signed distance and the unit outward gradient at a point read from an array, both written to `out`.
+ * For per-element loops: a point handed over as three numbers, or a distance handed back as one, is
+ * boxed into a heap object wherever V8 does not inline the call.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array|number[]} record
+ * @param {number} record_offset where the record starts
+ * @param {Float32Array|Float64Array|number[]} planes the plane array a hull record was packed with;
+ *   read only for a hull
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`, in the record's local frame
+ * @param {number} point_offset
+ * @returns {void}
+ */
+export function shape_record_signed_distance_gradient_array(out: Float32Array | Float64Array | number[], out_offset: number, record: Float32Array | Float64Array | number[], record_offset: number, planes: Float32Array | Float64Array | number[], point: Float32Array | Float64Array | number[], point_offset: number): void;
+//# sourceMappingURL=shape_record_signed_distance.d.ts.map

package/src/core/geom/3d/shape/record/shape_record_signed_distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape_record_signed_distance.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/record/shape_record_signed_distance.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;GAWG;AACH,qDATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,iBAClC,MAAM,UACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAElC,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;;GAcG;AACH,iEAVW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,UACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,iBAClC,MAAM,UACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,SAElC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,GACJ,IAAI,CAsBhB"}