@configura/babylon-view 1.2.1 → 1.3.0-alpha.3

package/dist/utilities/CfgBoundingBox.d.ts

@@ -1,17 +1,17 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-export declare class CfgBoundingBox {
-    minimum: Vector3;
-    maximum: Vector3;
-    constructor(minimum?: Vector3, maximum?: Vector3);
-    private _isEmpty;
-    reConstruct(minimum: Vector3, maximum: Vector3): CfgBoundingBox;
-    copyFrom(otherBoundingBox: CfgBoundingBox): CfgBoundingBox;
-    clone(): CfgBoundingBox;
-    get center(): Vector3;
-    translate(vec: Vector3): CfgBoundingBox;
-    expand(otherBoundingBox: CfgBoundingBox): CfgBoundingBox;
-    applyMatrix(matrix: Matrix): CfgBoundingBox;
-    get spaceDiagonal(): number;
-    get isEmpty(): boolean;
-}
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+export declare class CfgBoundingBox {
+    minimum: Vector3;
+    maximum: Vector3;
+    constructor(minimum?: Vector3, maximum?: Vector3);
+    private _isEmpty;
+    reConstruct(minimum: Vector3, maximum: Vector3): CfgBoundingBox;
+    copyFrom(otherBoundingBox: CfgBoundingBox): CfgBoundingBox;
+    clone(): CfgBoundingBox;
+    get center(): Vector3;
+    translate(vec: Vector3): CfgBoundingBox;
+    expand(otherBoundingBox: CfgBoundingBox): CfgBoundingBox;
+    applyMatrix(matrix: Matrix): CfgBoundingBox;
+    get spaceDiagonal(): number;
+    get isEmpty(): boolean;
+}
 //# sourceMappingURL=CfgBoundingBox.d.ts.map

package/dist/utilities/CfgBoundingBox.js

@@ -1,64 +1,64 @@
-import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-export class CfgBoundingBox {
-    constructor(minimum, maximum) {
-        /// Means that the bounding box should be seen as "undefined", which is not the same as "zero".
-        this._isEmpty = true;
-        this.minimum = (minimum === null || minimum === void 0 ? void 0 : minimum.clone()) || Vector3.Zero();
-        this.maximum = (maximum === null || maximum === void 0 ? void 0 : maximum.clone()) || Vector3.Zero();
-        this._isEmpty = minimum === undefined && maximum === undefined;
-    }
-    reConstruct(minimum, maximum) {
-        this.minimum.copyFrom(minimum);
-        this.maximum.copyFrom(maximum);
-        this._isEmpty = false;
-        return this;
-    }
-    copyFrom(otherBoundingBox) {
-        this.reConstruct(otherBoundingBox.minimum, otherBoundingBox.maximum);
-        this._isEmpty = otherBoundingBox.isEmpty;
-        return this;
-    }
-    clone() {
-        return new CfgBoundingBox(this.minimum, this.maximum);
-    }
-    get center() {
-        return Vector3.Center(this.minimum, this.maximum);
-    }
-    translate(vec) {
-        this.minimum.addInPlace(vec);
-        this.maximum.addInPlace(vec);
-        return this;
-    }
-    expand(otherBoundingBox) {
-        if (otherBoundingBox.isEmpty) {
-            return this;
-        }
-        if (this.isEmpty) {
-            this.reConstruct(otherBoundingBox.minimum, otherBoundingBox.maximum);
-            return this;
-        }
-        this.reConstruct(this.minimum.minimizeInPlace(otherBoundingBox.minimum), this.maximum.maximizeInPlace(otherBoundingBox.maximum));
-        return this;
-    }
-    applyMatrix(matrix) {
-        if (this.isEmpty) {
-            return this;
-        }
-        // Transform can be rotation, in which case we might need to re-minimize/maximize
-        const transformedMin = Vector3.TransformCoordinates(this.minimum, matrix);
-        const transformedMax = Vector3.TransformCoordinates(this.maximum, matrix);
-        this.reConstruct(transformedMin.clone().minimizeInPlace(transformedMax), transformedMax.maximizeInPlace(transformedMin));
-        return this;
-    }
-    get spaceDiagonal() {
-        if (this.isEmpty) {
-            return 0;
-        }
-        const minimum = this.minimum.asArray();
-        const maximum = this.maximum.asArray();
-        return Math.sqrt(minimum.reduce((a, c, i) => a + Math.pow(maximum[i] - c, 2)));
-    }
-    get isEmpty() {
-        return this._isEmpty;
-    }
-}
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+export class CfgBoundingBox {
+    constructor(minimum, maximum) {
+        /// Means that the bounding box should be seen as "undefined", which is not the same as "zero".
+        this._isEmpty = true;
+        this.minimum = (minimum === null || minimum === void 0 ? void 0 : minimum.clone()) || Vector3.Zero();
+        this.maximum = (maximum === null || maximum === void 0 ? void 0 : maximum.clone()) || Vector3.Zero();
+        this._isEmpty = minimum === undefined && maximum === undefined;
+    }
+    reConstruct(minimum, maximum) {
+        this.minimum.copyFrom(minimum);
+        this.maximum.copyFrom(maximum);
+        this._isEmpty = false;
+        return this;
+    }
+    copyFrom(otherBoundingBox) {
+        this.reConstruct(otherBoundingBox.minimum, otherBoundingBox.maximum);
+        this._isEmpty = otherBoundingBox.isEmpty;
+        return this;
+    }
+    clone() {
+        return new CfgBoundingBox(this.minimum, this.maximum);
+    }
+    get center() {
+        return Vector3.Center(this.minimum, this.maximum);
+    }
+    translate(vec) {
+        this.minimum.addInPlace(vec);
+        this.maximum.addInPlace(vec);
+        return this;
+    }
+    expand(otherBoundingBox) {
+        if (otherBoundingBox.isEmpty) {
+            return this;
+        }
+        if (this.isEmpty) {
+            this.reConstruct(otherBoundingBox.minimum, otherBoundingBox.maximum);
+            return this;
+        }
+        this.reConstruct(this.minimum.minimizeInPlace(otherBoundingBox.minimum), this.maximum.maximizeInPlace(otherBoundingBox.maximum));
+        return this;
+    }
+    applyMatrix(matrix) {
+        if (this.isEmpty) {
+            return this;
+        }
+        // Transform can be rotation, in which case we might need to re-minimize/maximize
+        const transformedMin = Vector3.TransformCoordinates(this.minimum, matrix);
+        const transformedMax = Vector3.TransformCoordinates(this.maximum, matrix);
+        this.reConstruct(transformedMin.clone().minimizeInPlace(transformedMax), transformedMax.maximizeInPlace(transformedMin));
+        return this;
+    }
+    get spaceDiagonal() {
+        if (this.isEmpty) {
+            return 0;
+        }
+        const minimum = this.minimum.asArray();
+        const maximum = this.maximum.asArray();
+        return Math.sqrt(minimum.reduce((a, c, i) => a + Math.pow(maximum[i] - c, 2)));
+    }
+    get isEmpty() {
+        return this._isEmpty;
+    }
+}

package/dist/utilities/utilities3D.d.ts

@@ -1,27 +1,27 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { Transform as ModelTransform } from "@configura/web-api";
-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 { Point } from "@configura/web-core/dist/cm/geometry/Point.js";
-import { Transform as GeoTransform } from "@configura/web-core/dist/cm/geometry/Transform.js";
-import { CfgBoundingBox } from "./CfgBoundingBox.js";
-export declare function vector3Equals(left: Vector3, right: Vector3): boolean;
-declare type Axis = "x" | "y" | "z";
-export declare const getBoundingBoxChangeForAxis: (bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, forMax: boolean, axis: Axis) => number;
-export declare const boundingBoxChangeIsSignificantForAxis: (bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, forMax: boolean, axis: Axis, acceptableDifferenceShrink: number, acceptableDifferenceGrow: number) => boolean;
-export declare function boundingBoxesAreSignificantlyDifferent(bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, acceptableDifferenceShrink: number, acceptableDifferenceGrow: number): boolean;
-export declare function unifyBoundingRect(boundingRect: ClientRect | DOMRect): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-export declare function symTransformToMatrix(symTransform: GeoTransform): Matrix;
-export declare function modelTransformsEqual(left: ModelTransform, right: ModelTransform): boolean;
-export declare function modelTransformToSymTransform(modelTransform: ModelTransform): SymTransform;
-export declare function cloneName(name: string): string;
-export declare function measureLongestDistanceToCorner(bb: CfgBoundingBox, measureComponents: number[]): number;
-export declare function aTriMeshSphere(radius?: number, center?: Point, segments?: number): ATriMeshF;
-export declare function aTriMeshBox(p0?: Point, p1?: Point): ATriMeshF;
-export {};
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { Transform as ModelTransform } from "@configura/web-api";
+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 { Point } from "@configura/web-core/dist/cm/geometry/Point.js";
+import { Transform as GeoTransform } from "@configura/web-core/dist/cm/geometry/Transform.js";
+import { CfgBoundingBox } from "./CfgBoundingBox.js";
+export declare function vector3Equals(left: Vector3, right: Vector3): boolean;
+declare type Axis = "x" | "y" | "z";
+export declare const getBoundingBoxChangeForAxis: (bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, forMax: boolean, axis: Axis) => number;
+export declare const boundingBoxChangeIsSignificantForAxis: (bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, forMax: boolean, axis: Axis, acceptableDifferenceShrink: number, acceptableDifferenceGrow: number) => boolean;
+export declare function boundingBoxesAreSignificantlyDifferent(bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, acceptableDifferenceShrink: number, acceptableDifferenceGrow: number): boolean;
+export declare function unifyBoundingRect(boundingRect: ClientRect | DOMRect): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare function symTransformToMatrix(symTransform: GeoTransform): Matrix;
+export declare function modelTransformsEqual(left: ModelTransform, right: ModelTransform): boolean;
+export declare function modelTransformToSymTransform(modelTransform: ModelTransform): SymTransform;
+export declare function cloneName(name: string): string;
+export declare function measureLongestDistanceToCorner(bb: CfgBoundingBox, measureComponents: number[]): number;
+export declare function aTriMeshSphere(radius?: number, center?: Point, segments?: number): ATriMeshF;
+export declare function aTriMeshBox(p0?: Point, p1?: Point): ATriMeshF;
+export {};
 //# sourceMappingURL=utilities3D.d.ts.map

package/dist/utilities/utilities3D.js

@@ -1,187 +1,187 @@
-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;
-}
-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 one bb was empty and the other not or
-/// 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]);
+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;
+}
+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 one bb was empty and the other not or
+/// 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]);

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[];
-/**
- * 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[];
+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[];
+/**
+ * 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[];
 //# sourceMappingURL=utilitiesColor.d.ts.map