@configura/babylon-view 1.3.0-alpha.2 → 1.3.0-alpha.7

package/dist/nodes/CfgSymRootNode.js

@@ -14,9 +14,13 @@ import { SymGfxMode } from "@configura/web-core/dist/cm/format/cmsym/components/
 import { loadSymFile, makeSymFromDex, } from "@configura/web-core/dist/cm/format/cmsym/SymNode.js";
 import { DetailLevel } from "@configura/web-core/dist/cm/geometry/DetailMask.js";
 import { readFileToArrayBuffer } from "@configura/web-utilities";
+import { CfgStretchData } from "../geometry/stretch/CfgStretchData.js";
+import { CfgAnchorRef, updatedStretchedAnchorPointMatrix, } from "../utilities/anchor/anchor.js";
 import { modelTransformToSymTransform, symTransformToMatrix } from "../utilities/utilities3D.js";
-import { isSameIdentifierAndTransform, makeIdentifier, makeIdentifierFromRootNodeSource, } from "../utilities/utilitiesSymRootIdentifier.js";
+import { isSameIdentifierTransformAndAnchor, makeIdentifier, makeIdentifierFromRootNodeSource, } from "../utilities/utilitiesSymRootIdentifier.js";
 import { CfgSymNode } from "./CfgSymNode.js";
+// It is currently assumed that all meshes are in meters
+export const MESH_UNIT = "m";
 export function isSymRootNode(value) {
     return value instanceof CfgSymRootNode;
 }
@@ -46,23 +50,24 @@ function getBestMatchingDetailLevel(logger, symNode, allowedLevels) {
     return detailLevel || DetailLevel.undefined;
 }
 export class CfgSymRootNode extends CfgSymNode {
-    constructor(renderEnvironment, _isForDebug, detailLevel, symNode, _identifier, modelTransform) {
-        super(renderEnvironment, detailLevel, symNode);
+    constructor(renderEnvironment, cfgProductNodeParent, _isForDebug, detailLevel, symNode, _identifier, modelTransform, anchorRef) {
+        super(renderEnvironment, cfgProductNodeParent, undefined, detailLevel, symNode);
         this._isForDebug = _isForDebug;
         this._identifier = _identifier;
+        this.anchorRef = anchorRef;
         this._destroyed = false;
         this.name = "(SymRoot) " + symNode.id;
         this.modelTransform = modelTransform;
         this.initTransform();
     }
-    static makeCfgSymRootFromRootNodeSource(logger, isForDebug, renderEnvironment, rootNodeSource) {
+    static makeCfgSymRootFromRootNodeSource(logger, isForDebug, renderEnvironment, cfgProductNodeParent, rootNodeSource) {
         return __awaiter(this, void 0, void 0, function* () {
             return isModel(rootNodeSource)
-                ? CfgSymRootNode.makeCfgSymRootFromUrl(logger, isForDebug, renderEnvironment, rootNodeSource.uri, rootNodeSource.t)
-                : CfgSymRootNode.makeCfgSymRootFromFile(logger, isForDebug, renderEnvironment, rootNodeSource);
+                ? this.makeCfgSymRootFromUrl(logger, isForDebug, renderEnvironment, cfgProductNodeParent, rootNodeSource.uri, rootNodeSource.t, CfgAnchorRef.make(rootNodeSource.anchor))
+                : this.makeCfgSymRootFromFile(logger, isForDebug, renderEnvironment, cfgProductNodeParent, rootNodeSource);
         });
     }
-    static makeCfgSymRootFromUrl(logger, isForDebug, renderEnvironment, symUrl, transform) {
+    static makeCfgSymRootFromUrl(logger, isForDebug, renderEnvironment, cfgProductNodeParent, symUrl, transform, anchorRef) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!/.cmsym$/i.test(symUrl)) {
                 renderEnvironment.notifyError(logger.errorAsObject("Unsupported model URL (not cmsym format): ", symUrl));
@@ -70,7 +75,7 @@ export class CfgSymRootNode extends CfgSymNode {
             }
             try {
                 const symNode = yield loadCachedSymNode(logger, symUrl, renderEnvironment);
-                return this.makeCfgSymRootFromSymNode(logger, renderEnvironment, isForDebug, makeIdentifier("uri", symUrl), transform, symNode);
+                return this.makeCfgSymRootFromSymNode(logger, renderEnvironment, cfgProductNodeParent, isForDebug, makeIdentifier("uri", symUrl), transform, anchorRef, symNode);
             }
             catch (e) {
                 logger.errorFromCaught(e);
@@ -78,34 +83,34 @@ export class CfgSymRootNode extends CfgSymNode {
             }
         });
     }
-    static makeCfgSymRootFromFile(logger, isForDebug, renderEnvironment, file) {
+    static makeCfgSymRootFromFile(logger, isForDebug, renderEnvironment, cfgProductNodeParent, file) {
         return __awaiter(this, void 0, void 0, function* () {
             const arrayBuffer = yield readFileToArrayBuffer(file);
             const dexObj = renderEnvironment.dexManager.arrayBufferToDexObj(logger, "", arrayBuffer.buffer);
             const symNode = makeSymFromDex(logger, dexObj);
-            return this.makeCfgSymRootFromSymNode(logger, renderEnvironment, isForDebug, makeIdentifier("file", file.name), undefined, symNode);
+            return this.makeCfgSymRootFromSymNode(logger, renderEnvironment, cfgProductNodeParent, isForDebug, makeIdentifier("file", file.name), undefined, undefined, symNode);
         });
     }
     get cfgClassName() {
         return "CfgSymRootNode";
     }
-    static makeCfgSymRootFromSymNode(logger, renderEnvironment, isForDebug, identifier, transform, symNode) {
+    static makeCfgSymRootFromSymNode(logger, renderEnvironment, cfgProductNodeParent, isForDebug, identifier, transform, anchorRef, symNode) {
         return __awaiter(this, void 0, void 0, function* () {
             if (symNode === undefined) {
                 logger.warn("No symNode");
                 return;
             }
             const detailLevel = getBestMatchingDetailLevel(logger, symNode, renderEnvironment.allowedDetailLevels);
-            const node = new CfgSymRootNode(renderEnvironment, isForDebug, detailLevel, symNode, identifier, transform);
-            yield CfgSymNode.initCfgSymNode(node);
+            const node = new this(renderEnvironment, cfgProductNodeParent, isForDebug, detailLevel, symNode, identifier, transform, anchorRef);
+            yield this.initCfgSymNode(node);
             return node;
         });
     }
     get isForDebug() {
         return this._isForDebug;
     }
-    isSameIdentifierAndTransform(rootNodeSource) {
-        return isSameIdentifierAndTransform(this._identifier, this.modelTransform, makeIdentifierFromRootNodeSource(rootNodeSource), isModel(rootNodeSource) ? rootNodeSource.t : undefined);
+    isSameIdentifierTransformAndAnchor(rootNodeSource) {
+        return isSameIdentifierTransformAndAnchor(this._identifier, this.modelTransform, this.anchorRef, makeIdentifierFromRootNodeSource(rootNodeSource), isModel(rootNodeSource) ? rootNodeSource.t : undefined, isModel(rootNodeSource) ? CfgAnchorRef.make(rootNodeSource.anchor) : undefined);
     }
     destroy() {
         this._destroyed = true;
@@ -145,17 +150,57 @@ export class CfgSymRootNode extends CfgSymNode {
     }
     get originalMatrix() {
         if (this._originalMatrixWithModelTransform === undefined) {
-            const originalMatrix = super.originalMatrix;
+            let originalMatrix = super.originalMatrix;
             let modelMatrix = Matrix.Identity();
             const modelTransform = this.modelTransform;
             if (modelTransform !== undefined) {
                 const modelSymTransform = modelTransformToSymTransform(modelTransform);
                 modelMatrix = symTransformToMatrix(modelSymTransform.transform());
             }
-            this._originalMatrixWithModelTransform = originalMatrix.multiply(modelMatrix);
+            originalMatrix = originalMatrix.multiply(modelMatrix);
+            const stretchedAnchorPointMatrix = this._stretchedAnchorPointMatrix;
+            if (stretchedAnchorPointMatrix !== undefined) {
+                originalMatrix = originalMatrix.multiply(stretchedAnchorPointMatrix);
+            }
+            this._originalMatrixWithModelTransform = originalMatrix;
         }
         return this._originalMatrixWithModelTransform;
     }
+    get stretchDatas() {
+        if (this._stretchDatas === undefined) {
+            const logger = this.logger;
+            const detailLevel = this._detailLevel;
+            const stretchDatas = [];
+            for (const childNode of this._symNode.children(logger, true, true).values()) {
+                if (!childNode.isStretch(logger, detailLevel)) {
+                    continue;
+                }
+                const stretchData = CfgStretchData.make(logger, childNode, detailLevel);
+                if (stretchData === undefined) {
+                    continue;
+                }
+                stretchDatas.push(stretchData);
+            }
+            this._stretchDatas = stretchDatas;
+        }
+        return this._stretchDatas;
+    }
+    get accumulatedStretchDatas() {
+        return this.stretchDatas;
+    }
+    setAnchorTarget(anchorTarget) {
+        this._anchorTarget = anchorTarget;
+    }
+    refreshStretch() {
+        super.refreshStretch();
+        const updated = updatedStretchedAnchorPointMatrix(this.anchorRef, this._anchorTarget, this._stretchedAnchorPointMatrix, false);
+        if (updated === undefined) {
+            return;
+        }
+        this._stretchedAnchorPointMatrix = updated;
+        this._originalMatrixWithModelTransform = undefined; // Reset the matrix
+        this.initTransform();
+    }
     addInspectorProperties() {
         super.addInspectorProperties();
         this.addInspectableCustomProperty({

package/dist/nodes/CfgTransformNode.d.ts

@@ -15,6 +15,10 @@ export declare abstract class CfgTransformNode extends TransformNode {
     clear(dispose: boolean): void;
     add(...objects: Node[]): void;
     abstract get originalMatrix(): Matrix;
+    /**
+     * Recursively calculates the world matrix based on originalMatrix on nodes which inherits
+     * CfgTransformNode.
+     */
     get worldOriginalMatrix(): Matrix;
     remove(dispose: boolean, ...objects: Node[]): this;
     /**

package/dist/nodes/CfgTransformNode.js

@@ -37,8 +37,10 @@ export class CfgTransformNode extends TransformNode {
             obj.parent = this;
         }
     }
-    /// Recursively calculates the world matrix based on originalMatrix on
-    /// nodes which inherits CfgTransformNode.
+    /**
+     * Recursively calculates the world matrix based on originalMatrix on nodes which inherits
+     * CfgTransformNode.
+     */
     get worldOriginalMatrix() {
         const o = this.originalMatrix;
         const p = this.parent;

package/dist/utilities/CfgBoundingBox.d.ts

@@ -3,6 +3,9 @@ export declare class CfgBoundingBox {
     minimum: Vector3;
     maximum: Vector3;
     constructor(minimum?: Vector3, maximum?: Vector3);
+    /**
+     * Means that the bounding box should be seen as "undefined", which is not the same as "zero"
+     */
     private _isEmpty;
     reConstruct(minimum: Vector3, maximum: Vector3): CfgBoundingBox;
     copyFrom(otherBoundingBox: CfgBoundingBox): CfgBoundingBox;
@@ -10,8 +13,10 @@ export declare class CfgBoundingBox {
     get center(): Vector3;
     translate(vec: Vector3): CfgBoundingBox;
     expand(otherBoundingBox: CfgBoundingBox): CfgBoundingBox;
+    expandWithPoint(point: Vector3): CfgBoundingBox;
     applyMatrix(matrix: Matrix): CfgBoundingBox;
     get spaceDiagonal(): number;
     get isEmpty(): boolean;
+    get corners(): Vector3[];
 }
 //# sourceMappingURL=CfgBoundingBox.d.ts.map

package/dist/utilities/CfgBoundingBox.js

@@ -1,7 +1,9 @@
 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".
+        /**
+         * 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();
@@ -40,6 +42,14 @@ export class CfgBoundingBox {
         this.reConstruct(this.minimum.minimizeInPlace(otherBoundingBox.minimum), this.maximum.maximizeInPlace(otherBoundingBox.maximum));
         return this;
     }
+    expandWithPoint(point) {
+        if (this.isEmpty) {
+            this.reConstruct(point, point);
+            return this;
+        }
+        this.reConstruct(this.minimum.minimizeInPlace(point), this.maximum.maximizeInPlace(point));
+        return this;
+    }
     applyMatrix(matrix) {
         if (this.isEmpty) {
             return this;
@@ -61,4 +71,11 @@ export class CfgBoundingBox {
     get isEmpty() {
         return this._isEmpty;
     }
+    get corners() {
+        const corners = [];
+        for (let a = 0; a < 8; a++) {
+            corners.push(new Vector3(((a & 1) === 0 ? this.minimum : this.maximum).x, ((a & 2) === 0 ? this.minimum : this.maximum).y, ((a & 4) === 0 ? this.minimum : this.maximum).z));
+        }
+        return corners;
+    }
 }

package/dist/utilities/anchor/anchor.d.ts

@@ -0,0 +1,52 @@
+import { Matrix, Vector3 } from "@babylonjs/core";
+import { MeasureParam } from "@configura/web-api";
+import { CfgMeasureDefinition, CfgMeasurePriority } from "@configura/web-api/dist/CfgMeasure";
+import { CfgProductNode } from "../../nodes/CfgProductNode.js";
+import { CfgSymRootNode } from "../../nodes/CfgSymRootNode.js";
+export declare type CfgAnchorTargetNode = CfgSymRootNode;
+export declare type CfgAnchorableNode = CfgSymRootNode | CfgProductNode;
+export declare function nodeEqualsMeasurePriorityNodeReference(node: CfgAnchorTargetNode, ref: CfgMeasurePriority): boolean;
+/**
+ * The measureParamCode points to Measures inside Models. A Model can be used multiple times in a Product.
+ * More than one Model can use the same measureParamCode. Therefore what Measure an AnchorRef points to
+ * can be ambiguous. To help resolve the ambiguities, an anchorRef can have measurePriorities that
+ * governs which target it prefers to be anchored to.
+ *
+ * This method sorts the targets so that the highest priority (lowest index) one is first.
+ * Sorting is done in place on the original array.
+ */
+export declare const getAnchorTargetPriorityComparer: (measureDefinitions: CfgMeasureDefinition[]) => (measureParamCode: string, l: CfgAnchorTargetNode, r: CfgAnchorTargetNode) => number;
+/**
+ * It might be possible in the future to anchor to other things than Measures (which are primarily)
+ * used for stretch, but for now we can only support anchoring to the ends of a Measure.
+ * toSp means anchor to start point, else end point.
+ * The MeasureParam class is used in several different contexts. To make the intent inside Stage
+ * clear CfgAnchorRef exists, which including only what is relevant for when used for anchoring.
+ */
+export declare class CfgAnchorRef {
+    readonly measureParamCode: string;
+    readonly toSp: boolean;
+    static make(m: MeasureParam | undefined): CfgAnchorRef | undefined;
+    private constructor();
+    equal(other: CfgAnchorRef): boolean;
+}
+/** Gets the coordinates of the anchor point relative the anchor target. */
+export declare function getRawAnchorPoint(anchorTarget: CfgAnchorTargetNode | undefined, anchorRef: CfgAnchorRef | undefined): Vector3 | undefined;
+/**
+ * Calculate a matrix which is the translation that makes a point move as if it was a child of
+ * anchorTarget and then moved to the end of the anchorPoint.
+ *
+ * It is assumed that all anchoring happens on symRoot/additionalProduct-level and therefore all anchorees are
+ * siblings to the anchorers.
+ *
+ * Application of anchoring happens from anchor tree root and out, so that originalMatrix of
+ * anchorTarget will already have any anchoring and stretch applied.
+ *
+ * @param ignoreTargetTransformation If true, ignore anchorTarget's originalMatrix. This is a
+ * workaround for that CET (as of this writing) somewhat unexpectedly mostly does not apply the
+ * transformation when anchoring Additional Products. We have noticed some cases when it actually
+ * apply the transform as you would expect. When the bug is solved this should be removed.
+ */
+export declare function getStretchedAnchorPointMatrix(anchorRef: CfgAnchorRef | undefined, anchorTarget: CfgAnchorTargetNode | undefined, ignoreTargetTransformation: boolean): Matrix | undefined;
+export declare function updatedStretchedAnchorPointMatrix(anchorRef: CfgAnchorRef | undefined, anchorTarget: CfgAnchorTargetNode | undefined, currentStretchedAnchorPointMatrix: Matrix | undefined, ignoreTargetTransformation: boolean): Matrix | undefined;
+//# sourceMappingURL=anchor.d.ts.map

package/dist/utilities/anchor/anchor.js

@@ -0,0 +1,136 @@
+import { Matrix, Vector3 } from "@babylonjs/core";
+import { toStretchedPoint } from "../../geometry/stretch/CfgStretchData.js";
+import { identifierIsUri } from "../utilitiesSymRootIdentifier.js";
+/*
+ * MeasurePriorityNodeReferences only uses the url of a Model as identifier. Therefore it
+ * can not differentiate between the same Model/CfgSymRootNode used multiple time in the same
+ * Product. Future development in Catalogues might make this change.
+ */
+export function nodeEqualsMeasurePriorityNodeReference(node, ref) {
+    const nodeIdentifier = node._identifier;
+    // The identifier is made from URL when the node was made from an URL
+    if (!identifierIsUri(nodeIdentifier)) {
+        return false;
+    }
+    // The last segment of the URL is the Windows-style formatted relative file path to the model
+    const pathFromIdentifier = decodeURIComponent(nodeIdentifier.substr(nodeIdentifier.lastIndexOf("/") + 1));
+    return pathFromIdentifier === ref.modelLocalFilePath;
+}
+/**
+ * The measureParamCode points to Measures inside Models. A Model can be used multiple times in a Product.
+ * More than one Model can use the same measureParamCode. Therefore what Measure an AnchorRef points to
+ * can be ambiguous. To help resolve the ambiguities, an anchorRef can have measurePriorities that
+ * governs which target it prefers to be anchored to.
+ *
+ * This method sorts the targets so that the highest priority (lowest index) one is first.
+ * Sorting is done in place on the original array.
+ */
+export const getAnchorTargetPriorityComparer = (measureDefinitions) => (measureParamCode, l, r) => {
+    const measureDefinition = measureDefinitions.find((m) => m.measureParamCode === measureParamCode);
+    if (measureDefinition === undefined) {
+        return 0;
+    }
+    const measurePriorities = measureDefinition.measurePriorities;
+    const lP = measurePriorities.find((m) => nodeEqualsMeasurePriorityNodeReference(l, m));
+    const rP = measurePriorities.find((m) => nodeEqualsMeasurePriorityNodeReference(r, m));
+    const lIndex = lP === undefined ? Number.POSITIVE_INFINITY : lP.index;
+    const rIndex = rP === undefined ? Number.POSITIVE_INFINITY : rP.index;
+    const prioDiff = lIndex - rIndex;
+    if (prioDiff !== 0) {
+        return prioDiff;
+    }
+    return l._identifier.localeCompare(r._identifier);
+};
+/**
+ * It might be possible in the future to anchor to other things than Measures (which are primarily)
+ * used for stretch, but for now we can only support anchoring to the ends of a Measure.
+ * toSp means anchor to start point, else end point.
+ * The MeasureParam class is used in several different contexts. To make the intent inside Stage
+ * clear CfgAnchorRef exists, which including only what is relevant for when used for anchoring.
+ */
+export class CfgAnchorRef {
+    constructor(measureParamCode, toSp) {
+        this.measureParamCode = measureParamCode;
+        this.toSp = toSp;
+    }
+    static make(m) {
+        if (m === undefined) {
+            return undefined;
+        }
+        const { anchorPoint, code } = m;
+        if (anchorPoint === undefined) {
+            console.error("No anchorPoint for measureParam intended to be used as anchorRef");
+            return undefined;
+        }
+        const isSp = anchorPoint === "sp";
+        const isEp = anchorPoint === "ep";
+        if (!isSp && !isEp) {
+            console.error("AnchorPoint is neither sp nor ep");
+            return undefined;
+        }
+        return new CfgAnchorRef(code, isSp);
+    }
+    equal(other) {
+        return this.measureParamCode === other.measureParamCode && this.toSp === other.toSp;
+    }
+}
+/** Gets the coordinates of the anchor point relative the anchor target. */
+export function getRawAnchorPoint(anchorTarget, anchorRef) {
+    if (anchorTarget === undefined) {
+        return undefined;
+    }
+    if (anchorRef === undefined) {
+        throw new Error("AnchorTo not set even though we got an anchorTarget");
+    }
+    const { measureParamCode, toSp } = anchorRef;
+    const { stretchDatas } = anchorTarget;
+    const targetStretchData = stretchDatas.find((stretchData) => measureParamCode === stretchData.measureParam);
+    if (targetStretchData === undefined) {
+        throw new Error("No target stretch data for measureParamCode found");
+    }
+    return toSp ? targetStretchData.sp : targetStretchData.ep;
+}
+/**
+ * Calculate a matrix which is the translation that makes a point move as if it was a child of
+ * anchorTarget and then moved to the end of the anchorPoint.
+ *
+ * It is assumed that all anchoring happens on symRoot/additionalProduct-level and therefore all anchorees are
+ * siblings to the anchorers.
+ *
+ * Application of anchoring happens from anchor tree root and out, so that originalMatrix of
+ * anchorTarget will already have any anchoring and stretch applied.
+ *
+ * @param ignoreTargetTransformation If true, ignore anchorTarget's originalMatrix. This is a
+ * workaround for that CET (as of this writing) somewhat unexpectedly mostly does not apply the
+ * transformation when anchoring Additional Products. We have noticed some cases when it actually
+ * apply the transform as you would expect. When the bug is solved this should be removed.
+ */
+export function getStretchedAnchorPointMatrix(anchorRef, anchorTarget, ignoreTargetTransformation) {
+    const rawAnchorPoint = getRawAnchorPoint(anchorTarget, anchorRef);
+    if (rawAnchorPoint === undefined || anchorTarget === undefined) {
+        return undefined;
+    }
+    // Apply current stretch to the anchor point
+    const stretchedAnchorPoint = toStretchedPoint(rawAnchorPoint, anchorTarget.stretchDatas, anchorTarget.cfgProductNode.product.configuration._internal
+        .stretchReferenceLengthsByMeasureParamCode);
+    // Sometimes, apply the anchorTarget matrix, as if the point was a child to the anchorTarget.
+    const anchorTargetMatrixApplied = ignoreTargetTransformation
+        ? stretchedAnchorPoint
+        : Vector3.TransformCoordinates(stretchedAnchorPoint, anchorTarget.originalMatrix);
+    // We use translation as when we anchor things we do not change their orientation,
+    // we only move them to snap to this point
+    return Matrix.Identity().setTranslation(anchorTargetMatrixApplied);
+}
+export function updatedStretchedAnchorPointMatrix(anchorRef, anchorTarget, currentStretchedAnchorPointMatrix, ignoreTargetTransformation) {
+    const stretchedAnchorPointMatrix = getStretchedAnchorPointMatrix(anchorRef, anchorTarget, ignoreTargetTransformation);
+    if (currentStretchedAnchorPointMatrix === undefined &&
+        stretchedAnchorPointMatrix === undefined) {
+        return undefined;
+    }
+    if (currentStretchedAnchorPointMatrix !== undefined &&
+        stretchedAnchorPointMatrix !== undefined &&
+        stretchedAnchorPointMatrix.equals(currentStretchedAnchorPointMatrix)) {
+        return undefined;
+    }
+    return stretchedAnchorPointMatrix;
+}

package/dist/utilities/anchor/anchorMap.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns a map from child to parent guaranteed to be loop free.
+ * The anchor children (keys in the map) will all have a "anchorRef" and there is what
+ * measureParam they are linked on is found.
+ * Sorted so that parents are always before their children
+ * This function is a bit of a "best effort". These things are not well defined in CET - you
+ * can anchor A on B and B on A at the same time for example. You can also anchor B to A
+ * while there exists multiple A:s. The code below is a naive implementation as in it will
+ * not make the solution which allows the most things to be linked. But that is fine as you
+ * should never create a catalogue with strange anchoring anyhow.
+ */
+export declare function makeAnchoredToAnchorMap<A extends {
+    anchorRef: {
+        measureParamCode: string;
+    } | undefined;
+}, T extends {
+    stretchDatas: {
+        measureParam: string;
+    }[];
+}>(nodes: (A | T)[], targetCandidateComparer: (measureParamCode: string, l: T, r: T) => number): Map<A, T>;
+//# sourceMappingURL=anchorMap.d.ts.map

package/dist/utilities/anchor/anchorMap.js

@@ -0,0 +1,111 @@
+// Tests do not work if we have Babylon-imports in the same file, so this has to be a separate file
+/**
+ * Returns a map from child to parent guaranteed to be loop free.
+ * The anchor children (keys in the map) will all have a "anchorRef" and there is what
+ * measureParam they are linked on is found.
+ * Sorted so that parents are always before their children
+ * This function is a bit of a "best effort". These things are not well defined in CET - you
+ * can anchor A on B and B on A at the same time for example. You can also anchor B to A
+ * while there exists multiple A:s. The code below is a naive implementation as in it will
+ * not make the solution which allows the most things to be linked. But that is fine as you
+ * should never create a catalogue with strange anchoring anyhow.
+ */
+export function makeAnchoredToAnchorMap(nodes, targetCandidateComparer) {
+    function isAnchoree(n) {
+        return "anchorRef" in n;
+    }
+    function isTarget(n) {
+        return "stretchDatas" in n;
+    }
+    const anchoredToAnchorMap = new Map();
+    // Step 1: build a legal tree
+    for (const node of nodes) {
+        if (!isAnchoree(node)) {
+            continue;
+        }
+        const anchorRef = node.anchorRef;
+        if (anchorRef === undefined) {
+            continue;
+        }
+        const measureParam = anchorRef.measureParamCode;
+        const targetCandidates = nodes
+            .filter((n) => {
+            // Ignore self
+            if (node === n) {
+                return false;
+            }
+            if (!isTarget(n)) {
+                return false;
+            }
+            // Can we anchor to this node?
+            return n.stretchDatas.some((stretchData) => measureParam === stretchData.measureParam);
+        })
+            .map((t, i) => ({ t, i }))
+            .sort((l, r) => {
+            // As sort is not stable in JS-versions older than EcmaScript 2019 we add the
+            // array original index to have as a fallback when there is a draw
+            const comp = targetCandidateComparer(anchorRef.measureParamCode, l.t, r.t);
+            if (comp === 0) {
+                return l.i - r.i;
+            }
+            return comp;
+        })
+            .map((tt) => tt.t);
+        let okay = true;
+        for (const otherNode of targetCandidates) {
+            okay = true;
+            // Loop control, the candidate can not be a child, then we would get a loop
+            let loopCandidate = otherNode;
+            while (loopCandidate !== undefined) {
+                if (!isAnchoree(loopCandidate)) {
+                    break;
+                }
+                loopCandidate = anchoredToAnchorMap.get(loopCandidate);
+                if (loopCandidate === node) {
+                    okay = false;
+                    break;
+                }
+            }
+            if (okay) {
+                anchoredToAnchorMap.set(node, otherNode);
+                break;
+            }
+        }
+        if (!okay) {
+            console.warn("No SymRootNode to anchor to found.");
+        }
+    }
+    // From anchored to anchor
+    const unplaced = Array.from(anchoredToAnchorMap);
+    // Step 2: Build a sorted map so that parents are before their children
+    const result = [];
+    while (true) {
+        const candidate = unplaced.pop();
+        if (candidate === undefined) {
+            //done
+            break;
+        }
+        const parent = candidate[1];
+        const indexInResult = result.findIndex((otherAnchoredToAnchor) => parent === otherAnchoredToAnchor[0]);
+        if (indexInResult === -1) {
+            // Candidates parent is not in the result, see if it in those waiting
+            const indexInUnplaced = unplaced.findIndex((item) => item[0] === parent);
+            if (indexInUnplaced === -1) {
+                // The parent was not part of the original nodes, so we just add this node.
+                result.push(candidate);
+            }
+            else {
+                const toMoveUp = unplaced.splice(indexInUnplaced, 1)[0];
+                // Put back to candidate
+                unplaced.push(candidate);
+                // Move up the parent
+                unplaced.push(toMoveUp);
+            }
+        }
+        else {
+            // Parent is in result
+            result.splice(indexInResult + 1, 0, candidate);
+        }
+    }
+    return new Map(result);
+}

package/dist/utilities/utilities3D.d.ts

@@ -6,9 +6,24 @@ 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;
+export declare function cmPointToVector3(point: Point): Vector3;
 declare type Axis = "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 declare const getBoundingBoxChangeForAxis: (bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, forMax: boolean, axis: Axis) => number;
+/**
+ * Given an old bounding box and a new tells if the size difference in one component is significant.
+ */
 export declare const boundingBoxChangeIsSignificantForAxis: (bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, forMax: boolean, axis: Axis, acceptableDifferenceShrink: number, acceptableDifferenceGrow: number) => boolean;
+/**
+ * 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 declare function boundingBoxesAreSignificantlyDifferent(bbOld: CfgBoundingBox, bbNew: CfgBoundingBox, acceptableDifferenceShrink: number, acceptableDifferenceGrow: number): boolean;
 export declare function unifyBoundingRect(boundingRect: ClientRect | DOMRect): {
     x: number;
@@ -21,7 +36,36 @@ export declare function modelTransformsEqual(left: ModelTransform, right: ModelT
 export declare function modelTransformToSymTransform(modelTransform: ModelTransform): SymTransform;
 export declare function cloneName(name: string): string;
 export declare function measureLongestDistanceToCorner(bb: CfgBoundingBox, measureComponents: number[]): number;
+/**
+ * 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 declare function aTriMeshSphere(radius?: number, center?: Point, segments?: number): ATriMeshF;
+/**
+ * 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 declare function aTriMeshBox(p0?: Point, p1?: Point): ATriMeshF;
+/**
+ * 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 declare function aTriMeshPlane(normal?: Point, offset?: number, radius?: number, refine?: number): ATriMeshF;
 export {};
 //# sourceMappingURL=utilities3D.d.ts.map