@configura/babylon-view 2.0.0-alpha.20 → 2.0.0-alpha.21

package/dist/utilities/utilities3D.js

@@ -1,265 +1,265 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { ATriMeshF } from "@configura/web-core/dist/cm/core3D/ATriMeshF.js";
-import { SymTransform } from "@configura/web-core/dist/cm/format/cmsym/components/SymTransform.js";
-import { Angle } from "@configura/web-core/dist/cm/geometry/Angle.js";
-import { Matrix33 } from "@configura/web-core/dist/cm/geometry/Matrix33.js";
-import { Orientation } from "@configura/web-core/dist/cm/geometry/Orientation.js";
-import { Point } from "@configura/web-core/dist/cm/geometry/Point.js";
-export function vector3Equals(left, right) {
-    return left.x === right.x && left.y === right.y && left.z === right.z;
-}
-export function cmPointToVector3(point) {
-    return new Vector3(point.x, point.y, point.z);
-}
-const allAxes = ["x", "y", "z"];
-/**
- * Calculates the change in one component for min or max when moving from one bounding box to
- * another. Negative result is shrink, positive is grow. forMax is accounted for.
- */
-export const getBoundingBoxChangeForAxis = (bbOld, bbNew, forMax, axis) => {
-    const getMinMax = forMax
-        ? (bb) => bb.maximum
-        : (bb) => bb.minimum;
-    const getC = axis === "x"
-        ? (c) => c.x
-        : axis === "y"
-            ? (c) => c.y
-            : (c) => c.z;
-    return ((forMax ? 1 : -1) *
-        ((getC(getMinMax(bbNew)) - getC(getMinMax(bbOld))) /
-            Math.abs(getC(bbOld.maximum) - getC(bbOld.minimum))));
-};
-/**
- * Given an old bounding box and a new tells if the size difference in one component is significant.
- */
-export const boundingBoxChangeIsSignificantForAxis = (bbOld, bbNew, forMax, axis, acceptableDifferenceShrink, acceptableDifferenceGrow) => {
-    const change = getBoundingBoxChangeForAxis(bbOld, bbNew, forMax, axis);
-    return (change < 0 ? acceptableDifferenceShrink : acceptableDifferenceGrow) < Math.abs(change);
-};
-/**
- * Returns true if either:
- * - One bounding box was empty and the other not.
- * - There is a size change in any of the six primary directions which is larger than
- * acceptableDifferenceShrink or acceptableDifferenceGrow depending if the change from bbOld to
- * bbNew in that direction is shrink or grow.
- */
-export function boundingBoxesAreSignificantlyDifferent(bbOld, bbNew, acceptableDifferenceShrink, acceptableDifferenceGrow) {
-    if (bbOld.isEmpty !== bbNew.isEmpty) {
-        return true;
-    }
-    for (const axis of allAxes) {
-        for (const forMax of [true, false]) {
-            if (boundingBoxChangeIsSignificantForAxis(bbOld, bbNew, forMax, axis, acceptableDifferenceShrink, acceptableDifferenceGrow)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-export function unifyBoundingRect(boundingRect) {
-    function isDomRect(object) {
-        return typeof object === "object" && object !== null && "x" in object;
-    }
-    if (isDomRect(boundingRect)) {
-        return boundingRect;
-    }
-    return {
-        x: boundingRect.left,
-        y: boundingRect.top,
-        width: boundingRect.width,
-        height: boundingRect.height,
-    };
-}
-export function symTransformToMatrix(symTransform) {
-    const pos = symTransform.pos;
-    const mapping = symTransform.mapping || Matrix33.identity;
-    const { c0, c1, c2 } = mapping;
-    return Matrix.FromValues(c0.x, c0.y, c0.z, 0, c1.x, c1.y, c1.z, 0, c2.x, c2.y, c2.z, 0, pos.x, pos.y, pos.z, 1);
-}
-export function modelTransformsEqual(left, right) {
-    const { scale: leftScale, pos: leftPos, rot: leftRot } = left;
-    const { scale: rightScale, pos: rightPos, rot: rightRot } = right;
-    return (leftScale.x === rightScale.x &&
-        leftScale.y === rightScale.y &&
-        leftScale.z === rightScale.z &&
-        leftPos.x === rightPos.x &&
-        leftPos.y === rightPos.y &&
-        leftPos.z === rightPos.z &&
-        leftRot.pitch === rightRot.pitch &&
-        leftRot.roll === rightRot.roll &&
-        leftRot.yaw === rightRot.yaw);
-}
-export function modelTransformToSymTransform(modelTransform) {
-    const { pos, scale, rot } = modelTransform;
-    return new SymTransform(new Point(pos.x, pos.y, pos.z), new Orientation(new Angle(rot.yaw), new Angle(rot.pitch), new Angle(rot.roll)), undefined, new Point(scale.x, scale.y, scale.z));
-}
-export function cloneName(name) {
-    if (!name.endsWith(" ")) {
-        name += " ";
-    }
-    return name + "(clone)";
-}
-export function measureLongestDistanceToCorner(bb, measureComponents) {
-    if (bb.isEmpty) {
-        throw Error("Empty bounding box");
-    }
-    const minimum = bb.minimum.asArray();
-    const maximum = bb.maximum.asArray();
-    let longestSquaredDistanceFromCenter = 0;
-    const cornerCount = Math.pow(2, measureComponents.length);
-    for (let i = 0; i < cornerCount; i++) {
-        const vectorComponents = measureComponents.map((componentIndex, n) => (i & (1 << n) ? minimum : maximum)[componentIndex]);
-        const squaredDistance = vectorComponents.reduce((pV, cV) => pV + Math.pow(cV, 2), 0);
-        longestSquaredDistanceFromCenter = Math.max(longestSquaredDistanceFromCenter, squaredDistance);
-    }
-    return Math.sqrt(longestSquaredDistanceFromCenter);
-}
-/**
- * Creates an ATriMeshF instance containing a mesh of a sphere of the given radius (default 1)
- * centered on the given position (default <0,0,0>). The "resolution" of the mesh is set by the
- * segments value (default 32).
- *
- * UV coordinates are generated by wrapping the texture around the sphere like a world map.
- */
-export function aTriMeshSphere(radius, center, segments) {
-    // Simplified and slightly modified (mostly z-up etc) version of SphereBuilder from Babylon.js
-    // https://github.com/BabylonJS/Babylon.js/blob/master/src/Meshes/Builders/sphereBuilder.ts
-    const totalYRotationSteps = 2 + (segments !== null && segments !== void 0 ? segments : 32);
-    const totalZRotationSteps = 2 * totalYRotationSteps;
-    radius = radius !== null && radius !== void 0 ? radius : 1;
-    center = center !== null && center !== void 0 ? center : new Point(0, 0, 0);
-    const offset = new Vector3(center.x, center.y, center.z);
-    const indices = [];
-    const positions = [];
-    const normals = [];
-    const uvs = [];
-    for (let yRotationStep = 0; yRotationStep <= totalYRotationSteps; yRotationStep++) {
-        const normalizedY = yRotationStep / totalYRotationSteps;
-        const angleY = normalizedY * Math.PI;
-        for (let zRotationStep = 0; zRotationStep <= totalZRotationSteps; zRotationStep++) {
-            const normalizedZ = zRotationStep / totalZRotationSteps;
-            const angleZ = normalizedZ * Math.PI * 2;
-            const rotationY = Matrix.RotationY(-angleY);
-            const rotationZ = Matrix.RotationZ(angleZ);
-            const afterRotY = Vector3.TransformCoordinates(new Vector3(0, 0, 1), rotationY);
-            const complete = Vector3.TransformCoordinates(afterRotY, rotationZ);
-            const vertex = complete.scale(radius).add(offset);
-            const normal = complete.normalize();
-            positions.push(vertex.x, vertex.y, vertex.z);
-            normals.push(normal.x, normal.y, normal.z);
-            uvs.push(normalizedZ, normalizedY);
-        }
-        if (yRotationStep > 0) {
-            const verticesCount = positions.length / 3;
-            for (let firstIndex = verticesCount - 2 * (totalZRotationSteps + 1); firstIndex + totalZRotationSteps + 2 < verticesCount; firstIndex++) {
-                indices.push(firstIndex);
-                indices.push(firstIndex + totalZRotationSteps + 1);
-                indices.push(firstIndex + 1);
-                indices.push(firstIndex + totalZRotationSteps + 1);
-                indices.push(firstIndex + totalZRotationSteps + 2);
-                indices.push(firstIndex + 1);
-            }
-        }
-    }
-    // It would probably be faster if we could avoid this step and use the typed arrays directly.
-    // On the other hand, during testing the calls below took 0ms for 52k indices...
-    return ATriMeshF.createWithArrays(Uint32Array.from(indices), Float32Array.from(positions), Float32Array.from(normals), Float32Array.from(uvs));
-}
-/**
- * Creates an ATriMeshF instance containing a mesh of a box between the two points.
- * Default value of p0 is <0,0,0> and p1 is <1,1,1>.
- *
- * UV coordinates are generated, repeating the texture on each side.
- */
-export function aTriMeshBox(p0, p1) {
-    p0 = p0 !== null && p0 !== void 0 ? p0 : new Point(0, 0, 0);
-    p1 = p1 !== null && p1 !== void 0 ? p1 : new Point(1, 1, 1);
-    const scales = [p1.x - p0.x, p1.y - p0.y, p1.z - p0.z];
-    const offsets = [p0.x, p0.y, p0.z];
-    const positions = BOX_VERTICES.map((value, index) => {
-        const component = index % 3;
-        return value * scales[component] + offsets[component];
-    });
-    return ATriMeshF.createWithArrays(BOX_INDICES, positions, BOX_NORMALS, BOX_UVS);
-}
-// prettier-ignore
-const BOX_INDICES = new Uint32Array([0, 2, 1, 0, 3, 2, 4, 6, 5, 4, 7, 6, 8, 10, 9, 8, 11, 10, 12,
-    14, 13, 12, 15, 14, 16, 18, 17, 16, 19, 18, 20, 22, 21, 20, 23, 22]);
-// prettier-ignore
-const BOX_NORMALS = new Float32Array([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0,
-    -1, 0, 0, -1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 1,
-    0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0]);
-// prettier-ignore
-const BOX_UVS = new Float32Array([1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0,
-    1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0,]);
-// prettier-ignore
-const BOX_VERTICES = new Float32Array([1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0,
-    0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0,
-    1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1]);
-/**
- * Creates an ATriMeshF instance containing a mesh representing an infinite plane with the given
- * normal, offset by the given distance along the normal.
- *
- * Due to automatic bounding box calculations, the infinite plane is represented by a circular disc
- * with the given radius centered on a point offset from the origin along the normal vector.
- *
- * The number of triangles in the disc is controlled by the refine parameter. The minimum number of
- * triangles is 4, each refine step doubles the triangle count.
- *
- * Default normal: 1, 0, 0
- * Default offset: 0
- * Default radius: 1
- * Default refinement: 4 (64 triangles)
- */
-export function aTriMeshPlane(normal, offset, radius, refine) {
-    normal = normal !== null && normal !== void 0 ? normal : new Point(0, 0, 1);
-    offset = offset !== null && offset !== void 0 ? offset : 0;
-    radius = radius !== null && radius !== void 0 ? radius : 1;
-    refine = refine !== null && refine !== void 0 ? refine : 4;
-    const normalVec = new Vector3(normal.x, normal.y, normal.z).normalize();
-    let base1 = normalVec.cross(new Vector3(1, 0, 0));
-    if (base1.length() < 0.2) {
-        // Normal was pretty close to 1, 0, 0, try another base vector
-        base1 = normalVec.cross(new Vector3(0, 1, 0));
-    }
-    base1 = base1.normalize();
-    const base2 = base1.cross(normalVec);
-    let points = new Array(5);
-    points[0] = Vector3.Zero();
-    points[1] = base1;
-    points[2] = base2;
-    points[3] = base1.negate();
-    points[4] = base2.negate();
-    for (let i = 0; i < refine; i++) {
-        points = refineCircle(points);
-    }
-    const numTriangles = points.length - 1;
-    const indices = new Uint32Array(numTriangles * 3);
-    for (let i = 0; i < numTriangles; i++) {
-        const index = i * 3;
-        indices[index] = 0;
-        indices[index + 1] = i + 1;
-        indices[index + 2] = i >= numTriangles - 1 ? 1 : i + 2;
-    }
-    const vertices = new Float32Array(points.length * 3);
-    for (let i = 0; i < points.length; i++) {
-        const point = points[i];
-        const index = i * 3;
-        vertices[index] = point.x * radius + normal.x * offset;
-        vertices[index + 1] = point.y * radius + normal.y * offset;
-        vertices[index + 2] = point.z * radius + normal.z * offset;
-    }
-    const mesh = ATriMeshF.createWithArrays(indices, vertices);
-    mesh.doubleSided = true;
-    return mesh;
-}
-function refineCircle(points) {
-    const refined = new Array(points.length * 2 - 1);
-    refined[0] = points[0];
-    for (let i = 1; i < points.length; i++) {
-        const next = (i >= points.length - 1 ? 0 : i) + 1;
-        refined[i * 2 - 1] = points[i];
-        refined[i * 2] = points[i].add(points[next]).normalize();
-    }
-    return refined;
-}
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { ATriMeshF } from "@configura/web-core/dist/cm/core3D/ATriMeshF.js";
+import { SymTransform } from "@configura/web-core/dist/cm/format/cmsym/components/SymTransform.js";
+import { Angle } from "@configura/web-core/dist/cm/geometry/Angle.js";
+import { Matrix33 } from "@configura/web-core/dist/cm/geometry/Matrix33.js";
+import { Orientation } from "@configura/web-core/dist/cm/geometry/Orientation.js";
+import { Point } from "@configura/web-core/dist/cm/geometry/Point.js";
+export function vector3Equals(left, right) {
+    return left.x === right.x && left.y === right.y && left.z === right.z;
+}
+export function cmPointToVector3(point) {
+    return new Vector3(point.x, point.y, point.z);
+}
+const allAxes = ["x", "y", "z"];
+/**
+ * Calculates the change in one component for min or max when moving from one bounding box to
+ * another. Negative result is shrink, positive is grow. forMax is accounted for.
+ */
+export const getBoundingBoxChangeForAxis = (bbOld, bbNew, forMax, axis) => {
+    const getMinMax = forMax
+        ? (bb) => bb.maximum
+        : (bb) => bb.minimum;
+    const getC = axis === "x"
+        ? (c) => c.x
+        : axis === "y"
+            ? (c) => c.y
+            : (c) => c.z;
+    return ((forMax ? 1 : -1) *
+        ((getC(getMinMax(bbNew)) - getC(getMinMax(bbOld))) /
+            Math.abs(getC(bbOld.maximum) - getC(bbOld.minimum))));
+};
+/**
+ * Given an old bounding box and a new tells if the size difference in one component is significant.
+ */
+export const boundingBoxChangeIsSignificantForAxis = (bbOld, bbNew, forMax, axis, acceptableDifferenceShrink, acceptableDifferenceGrow) => {
+    const change = getBoundingBoxChangeForAxis(bbOld, bbNew, forMax, axis);
+    return (change < 0 ? acceptableDifferenceShrink : acceptableDifferenceGrow) < Math.abs(change);
+};
+/**
+ * Returns true if either:
+ * - One bounding box was empty and the other not.
+ * - There is a size change in any of the six primary directions which is larger than
+ * acceptableDifferenceShrink or acceptableDifferenceGrow depending if the change from bbOld to
+ * bbNew in that direction is shrink or grow.
+ */
+export function boundingBoxesAreSignificantlyDifferent(bbOld, bbNew, acceptableDifferenceShrink, acceptableDifferenceGrow) {
+    if (bbOld.isEmpty !== bbNew.isEmpty) {
+        return true;
+    }
+    for (const axis of allAxes) {
+        for (const forMax of [true, false]) {
+            if (boundingBoxChangeIsSignificantForAxis(bbOld, bbNew, forMax, axis, acceptableDifferenceShrink, acceptableDifferenceGrow)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function unifyBoundingRect(boundingRect) {
+    function isDomRect(object) {
+        return typeof object === "object" && object !== null && "x" in object;
+    }
+    if (isDomRect(boundingRect)) {
+        return boundingRect;
+    }
+    return {
+        x: boundingRect.left,
+        y: boundingRect.top,
+        width: boundingRect.width,
+        height: boundingRect.height,
+    };
+}
+export function symTransformToMatrix(symTransform) {
+    const pos = symTransform.pos;
+    const mapping = symTransform.mapping || Matrix33.identity;
+    const { c0, c1, c2 } = mapping;
+    return Matrix.FromValues(c0.x, c0.y, c0.z, 0, c1.x, c1.y, c1.z, 0, c2.x, c2.y, c2.z, 0, pos.x, pos.y, pos.z, 1);
+}
+export function modelTransformsEqual(left, right) {
+    const { scale: leftScale, pos: leftPos, rot: leftRot } = left;
+    const { scale: rightScale, pos: rightPos, rot: rightRot } = right;
+    return (leftScale.x === rightScale.x &&
+        leftScale.y === rightScale.y &&
+        leftScale.z === rightScale.z &&
+        leftPos.x === rightPos.x &&
+        leftPos.y === rightPos.y &&
+        leftPos.z === rightPos.z &&
+        leftRot.pitch === rightRot.pitch &&
+        leftRot.roll === rightRot.roll &&
+        leftRot.yaw === rightRot.yaw);
+}
+export function modelTransformToSymTransform(modelTransform) {
+    const { pos, scale, rot } = modelTransform;
+    return new SymTransform(new Point(pos.x, pos.y, pos.z), new Orientation(new Angle(rot.yaw), new Angle(rot.pitch), new Angle(rot.roll)), undefined, new Point(scale.x, scale.y, scale.z));
+}
+export function cloneName(name) {
+    if (!name.endsWith(" ")) {
+        name += " ";
+    }
+    return name + "(clone)";
+}
+export function measureLongestDistanceToCorner(bb, measureComponents) {
+    if (bb.isEmpty) {
+        throw Error("Empty bounding box");
+    }
+    const minimum = bb.minimum.asArray();
+    const maximum = bb.maximum.asArray();
+    let longestSquaredDistanceFromCenter = 0;
+    const cornerCount = Math.pow(2, measureComponents.length);
+    for (let i = 0; i < cornerCount; i++) {
+        const vectorComponents = measureComponents.map((componentIndex, n) => (i & (1 << n) ? minimum : maximum)[componentIndex]);
+        const squaredDistance = vectorComponents.reduce((pV, cV) => pV + Math.pow(cV, 2), 0);
+        longestSquaredDistanceFromCenter = Math.max(longestSquaredDistanceFromCenter, squaredDistance);
+    }
+    return Math.sqrt(longestSquaredDistanceFromCenter);
+}
+/**
+ * Creates an ATriMeshF instance containing a mesh of a sphere of the given radius (default 1)
+ * centered on the given position (default <0,0,0>). The "resolution" of the mesh is set by the
+ * segments value (default 32).
+ *
+ * UV coordinates are generated by wrapping the texture around the sphere like a world map.
+ */
+export function aTriMeshSphere(radius, center, segments) {
+    // Simplified and slightly modified (mostly z-up etc) version of SphereBuilder from Babylon.js
+    // https://github.com/BabylonJS/Babylon.js/blob/master/src/Meshes/Builders/sphereBuilder.ts
+    const totalYRotationSteps = 2 + (segments !== null && segments !== void 0 ? segments : 32);
+    const totalZRotationSteps = 2 * totalYRotationSteps;
+    radius = radius !== null && radius !== void 0 ? radius : 1;
+    center = center !== null && center !== void 0 ? center : new Point(0, 0, 0);
+    const offset = new Vector3(center.x, center.y, center.z);
+    const indices = [];
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    for (let yRotationStep = 0; yRotationStep <= totalYRotationSteps; yRotationStep++) {
+        const normalizedY = yRotationStep / totalYRotationSteps;
+        const angleY = normalizedY * Math.PI;
+        for (let zRotationStep = 0; zRotationStep <= totalZRotationSteps; zRotationStep++) {
+            const normalizedZ = zRotationStep / totalZRotationSteps;
+            const angleZ = normalizedZ * Math.PI * 2;
+            const rotationY = Matrix.RotationY(-angleY);
+            const rotationZ = Matrix.RotationZ(angleZ);
+            const afterRotY = Vector3.TransformCoordinates(new Vector3(0, 0, 1), rotationY);
+            const complete = Vector3.TransformCoordinates(afterRotY, rotationZ);
+            const vertex = complete.scale(radius).add(offset);
+            const normal = complete.normalize();
+            positions.push(vertex.x, vertex.y, vertex.z);
+            normals.push(normal.x, normal.y, normal.z);
+            uvs.push(normalizedZ, normalizedY);
+        }
+        if (yRotationStep > 0) {
+            const verticesCount = positions.length / 3;
+            for (let firstIndex = verticesCount - 2 * (totalZRotationSteps + 1); firstIndex + totalZRotationSteps + 2 < verticesCount; firstIndex++) {
+                indices.push(firstIndex);
+                indices.push(firstIndex + totalZRotationSteps + 1);
+                indices.push(firstIndex + 1);
+                indices.push(firstIndex + totalZRotationSteps + 1);
+                indices.push(firstIndex + totalZRotationSteps + 2);
+                indices.push(firstIndex + 1);
+            }
+        }
+    }
+    // It would probably be faster if we could avoid this step and use the typed arrays directly.
+    // On the other hand, during testing the calls below took 0ms for 52k indices...
+    return ATriMeshF.createWithArrays(Uint32Array.from(indices), Float32Array.from(positions), Float32Array.from(normals), Float32Array.from(uvs));
+}
+/**
+ * Creates an ATriMeshF instance containing a mesh of a box between the two points.
+ * Default value of p0 is <0,0,0> and p1 is <1,1,1>.
+ *
+ * UV coordinates are generated, repeating the texture on each side.
+ */
+export function aTriMeshBox(p0, p1) {
+    p0 = p0 !== null && p0 !== void 0 ? p0 : new Point(0, 0, 0);
+    p1 = p1 !== null && p1 !== void 0 ? p1 : new Point(1, 1, 1);
+    const scales = [p1.x - p0.x, p1.y - p0.y, p1.z - p0.z];
+    const offsets = [p0.x, p0.y, p0.z];
+    const positions = BOX_VERTICES.map((value, index) => {
+        const component = index % 3;
+        return value * scales[component] + offsets[component];
+    });
+    return ATriMeshF.createWithArrays(BOX_INDICES, positions, BOX_NORMALS, BOX_UVS);
+}
+// prettier-ignore
+const BOX_INDICES = new Uint32Array([0, 2, 1, 0, 3, 2, 4, 6, 5, 4, 7, 6, 8, 10, 9, 8, 11, 10, 12,
+    14, 13, 12, 15, 14, 16, 18, 17, 16, 19, 18, 20, 22, 21, 20, 23, 22]);
+// prettier-ignore
+const BOX_NORMALS = new Float32Array([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0,
+    -1, 0, 0, -1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 1,
+    0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0]);
+// prettier-ignore
+const BOX_UVS = new Float32Array([1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0,
+    1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0,]);
+// prettier-ignore
+const BOX_VERTICES = new Float32Array([1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0,
+    0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0,
+    1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1]);
+/**
+ * Creates an ATriMeshF instance containing a mesh representing an infinite plane with the given
+ * normal, offset by the given distance along the normal.
+ *
+ * Due to automatic bounding box calculations, the infinite plane is represented by a circular disc
+ * with the given radius centered on a point offset from the origin along the normal vector.
+ *
+ * The number of triangles in the disc is controlled by the refine parameter. The minimum number of
+ * triangles is 4, each refine step doubles the triangle count.
+ *
+ * Default normal: 1, 0, 0
+ * Default offset: 0
+ * Default radius: 1
+ * Default refinement: 4 (64 triangles)
+ */
+export function aTriMeshPlane(normal, offset, radius, refine) {
+    normal = normal !== null && normal !== void 0 ? normal : new Point(0, 0, 1);
+    offset = offset !== null && offset !== void 0 ? offset : 0;
+    radius = radius !== null && radius !== void 0 ? radius : 1;
+    refine = refine !== null && refine !== void 0 ? refine : 4;
+    const normalVec = new Vector3(normal.x, normal.y, normal.z).normalize();
+    let base1 = normalVec.cross(new Vector3(1, 0, 0));
+    if (base1.length() < 0.2) {
+        // Normal was pretty close to 1, 0, 0, try another base vector
+        base1 = normalVec.cross(new Vector3(0, 1, 0));
+    }
+    base1 = base1.normalize();
+    const base2 = base1.cross(normalVec);
+    let points = new Array(5);
+    points[0] = Vector3.Zero();
+    points[1] = base1;
+    points[2] = base2;
+    points[3] = base1.negate();
+    points[4] = base2.negate();
+    for (let i = 0; i < refine; i++) {
+        points = refineCircle(points);
+    }
+    const numTriangles = points.length - 1;
+    const indices = new Uint32Array(numTriangles * 3);
+    for (let i = 0; i < numTriangles; i++) {
+        const index = i * 3;
+        indices[index] = 0;
+        indices[index + 1] = i + 1;
+        indices[index + 2] = i >= numTriangles - 1 ? 1 : i + 2;
+    }
+    const vertices = new Float32Array(points.length * 3);
+    for (let i = 0; i < points.length; i++) {
+        const point = points[i];
+        const index = i * 3;
+        vertices[index] = point.x * radius + normal.x * offset;
+        vertices[index + 1] = point.y * radius + normal.y * offset;
+        vertices[index + 2] = point.z * radius + normal.z * offset;
+    }
+    const mesh = ATriMeshF.createWithArrays(indices, vertices);
+    mesh.doubleSided = true;
+    return mesh;
+}
+function refineCircle(points) {
+    const refined = new Array(points.length * 2 - 1);
+    refined[0] = points[0];
+    for (let i = 1; i < points.length; i++) {
+        const next = (i >= points.length - 1 ? 0 : i) + 1;
+        refined[i * 2 - 1] = points[i];
+        refined[i * 2] = points[i].add(points[next]).normalize();
+    }
+    return refined;
+}

package/dist/utilities/utilitiesColor.d.ts

@@ -1,19 +1,19 @@
-import { Color3 } from "@babylonjs/core/Maths/math.color.js";
-import { Color } from "@configura/web-core/dist/cm/basic/Color.js";
-import { ColorF } from "@configura/web-core/dist/cm/basic/ColorF.js";
-/**
- * Converts a number of different color formats into Color3 for use with Babylon.js
- * Returns White if object is undefined.
- */
-export declare function toColor3(object: Color3 | ColorF | Color | string | number | undefined): Color3;
-/**
- * in: r,g,b in [0,1], out: h in [0,360) and s,l in [0,1]
- * Original source: https://stackoverflow.com/a/54071699/1488048
- */
-export declare function rgb2hsl(r: number, g: number, b: number): [number, number, number];
-/**
- * input: h in [0,360] and s,v in [0,1] - output: r,g,b in [0,1]
- * Original source: https://stackoverflow.com/a/54014428/1488048
- */
-export declare function hsl2rgb(h: number, s: number, l: number): [number, number, number];
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { Color } from "@configura/web-core/dist/cm/basic/Color.js";
+import { ColorF } from "@configura/web-core/dist/cm/basic/ColorF.js";
+/**
+ * Converts a number of different color formats into Color3 for use with Babylon.js
+ * Returns White if object is undefined.
+ */
+export declare function toColor3(object: Color3 | ColorF | Color | string | number | undefined): Color3;
+/**
+ * in: r,g,b in [0,1], out: h in [0,360) and s,l in [0,1]
+ * Original source: https://stackoverflow.com/a/54071699/1488048
+ */
+export declare function rgb2hsl(r: number, g: number, b: number): [number, number, number];
+/**
+ * input: h in [0,360] and s,v in [0,1] - output: r,g,b in [0,1]
+ * Original source: https://stackoverflow.com/a/54014428/1488048
+ */
+export declare function hsl2rgb(h: number, s: number, l: number): [number, number, number];
 //# sourceMappingURL=utilitiesColor.d.ts.map