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

package/dist/nodes/CfgProductNode.js

@@ -11,6 +11,8 @@ import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
 import { InspectableType } from "@babylonjs/core/Misc/iInspectable.js";
 import { aggregateAllMaterialApplications, CfgMtrlApplication, CfgMtrlApplicationSource, logMaterialMappingToConsole, } from "@configura/web-api";
 import { LogObservable, readFileToArrayBuffer } from "@configura/web-utilities";
+import { CfgAnchorRef, getAnchorTargetPriorityComparer, updatedStretchedAnchorPointMatrix, } from "../utilities/anchor/anchor.js";
+import { makeAnchoredToAnchorMap } from "../utilities/anchor/anchorMap.js";
 import { CfgBoundingBox } from "../utilities/CfgBoundingBox.js";
 import { modelTransformToSymTransform, symTransformToMatrix } from "../utilities/utilities3D.js";
 import { isSameRootNodeSource } from "../utilities/utilitiesSymRootIdentifier.js";
@@ -22,6 +24,9 @@ export function isProductNode(value) {
 export function isCfgSymRootNode(value) {
     return value instanceof CfgSymRootNode;
 }
+export function isCfgAnchorableNode(value) {
+    return isProductNode(value) || isCfgSymRootNode(value);
+}
 export class CfgProductNode extends CfgTransformNode {
     constructor(renderEnvironment, _product) {
         super(renderEnvironment, `(Product) ${_product.sku}`);
@@ -32,9 +37,12 @@ export class CfgProductNode extends CfgTransformNode {
         this._mtrlApplications = [];
         this._debugMtrlApplications = [];
         this._scheduledForRemoval = [];
+        this._anchoredToAnchors = new Map();
         this._symRootLoadings = [];
-        /// The passed function is recursively applied on every descendant CfgProductNode in
-        /// the tree. This node is included. Destroyed products are not included.
+        /**
+         * The passed function is recursively applied on every descendant CfgProductNode in the tree.
+         * This node is included. Destroyed products are not included.
+         */
         this._applyOnDescendantProductNodes = (fn) => {
             const result = [];
             result.push(fn(this));
@@ -44,17 +52,21 @@ export class CfgProductNode extends CfgTransformNode {
             return result;
         };
         this.key = _product.key;
+        // Useful debug tool:
+        if (false) {
+            window.product = this;
+            console.log(`Use "window.product" to access "${this.key}" product node.`);
+        }
+        this.anchorRef = CfgAnchorRef.make(this._product._internal.anchor);
         const modelTransform = _product.transform;
-        let modelMatrix = Matrix.Identity();
         if (modelTransform !== undefined) {
             const modelSymTransform = modelTransformToSymTransform(modelTransform);
-            modelMatrix = symTransformToMatrix(modelSymTransform.transform());
+            this._modelMatrix = symTransformToMatrix(modelSymTransform.transform());
         }
-        this.originalMatrix = modelMatrix;
-        this.setPreTransformMatrix(modelMatrix);
+        this.initTransform();
     }
     static make(renderEnvironment, product) {
-        return new CfgProductNode(renderEnvironment, product);
+        return new this(renderEnvironment, product);
     }
     get cfgClassName() {
         return "CfgProductNode";
@@ -69,8 +81,10 @@ export class CfgProductNode extends CfgTransformNode {
     get product() {
         return this._product;
     }
-    /// We want to be able to animate nodes that are on the way out.
-    /// So we do not immediately remove them from the tree
+    /**
+     * We want to be able to animate nodes that are on the way out.
+     * So we do not immediately remove them from the tree.
+     */
     scheduleForRemoval(node) {
         node.destroy();
         this._scheduledForRemoval.push(node);
@@ -78,9 +92,11 @@ export class CfgProductNode extends CfgTransformNode {
     isDestroyed() {
         return this._destroyed;
     }
-    /// This function will apply either of tree passed functions on the additional products
-    /// in the passed CfgProduct and the additional products in the CfgProductNode.
-    /// It is not applied recursively.
+    /**
+     * This function will apply either of tree passed functions on the additional products/ in the
+     * passed CfgProduct and the additional products in the CfgProductNode.
+     * It is not applied recursively.
+     */
     _syncAdditionalProductNodes(parentProduct, fn) {
         const { both, productNodeButNoProduct, productButNoProductNode } = fn;
         const additionalProducts = parentProduct.additionalProducts.filter((c) => c.selected);
@@ -108,15 +124,19 @@ export class CfgProductNode extends CfgTransformNode {
             productButNoProductNode(additionalProduct);
         }
     }
-    /// Application areas are essentially catalogue level material mappings
-    /// This function is recursively applied on additional products.
+    /**
+     * Application areas are essentially catalogue level material mappings.
+     * This function is recursively applied on additional products.
+     */
     setApplicationAreas(applicationAreas) {
         this._applyOnDescendantProductNodes((p) => {
             p._applicationAreas = applicationAreas;
         });
     }
-    /// Start loading the geometry, but do not yet show it
-    /// This function is recursively applied on additional products.
+    /**
+     * Start loading the geometry, but do not yet show it.
+     * This function is recursively applied on additional products.
+     */
     loadGeo(coordinatorWithMeta) {
         return __awaiter(this, void 0, void 0, function* () {
             const product = this._product;
@@ -134,7 +154,7 @@ export class CfgProductNode extends CfgTransformNode {
                 }
             }
             for (const symRootChild of this._getSymRootChildren().filter((c) => !c.isForDebug)) {
-                const updateIndex = updateRootNodeSources.findIndex((m) => symRootChild.isSameIdentifierAndTransform(m));
+                const updateIndex = updateRootNodeSources.findIndex((m) => symRootChild.isSameIdentifierTransformAndAnchor(m));
                 if (updateIndex === -1) {
                     // Not found, remove
                     this.scheduleForRemoval(symRootChild);
@@ -149,7 +169,7 @@ export class CfgProductNode extends CfgTransformNode {
                 if (symRootLoading === undefined) {
                     symRootLoading = {
                         rootNodeSource,
-                        rootNodePromise: CfgSymRootNode.makeCfgSymRootFromRootNodeSource(this.logger, false, this._renderEnvironment, rootNodeSource),
+                        rootNodePromise: CfgSymRootNode.makeCfgSymRootFromRootNodeSource(this.logger, false, this._renderEnvironment, this, rootNodeSource),
                     };
                     allSymRootLoadings.push(symRootLoading);
                 }
@@ -162,7 +182,7 @@ export class CfgProductNode extends CfgTransformNode {
             const addedSymRoots = (yield Promise.all(batchSymRootLoadings.map((s) => s.rootNodePromise)))
                 .filter((symRoot) => symRoot !== undefined)
                 .filter((symRoot) => {
-                const loadInProgressIndex = allSymRootLoadings.findIndex((symRootLoadInProgress) => symRoot.isSameIdentifierAndTransform(symRootLoadInProgress.rootNodeSource));
+                const loadInProgressIndex = allSymRootLoadings.findIndex((symRootLoadInProgress) => symRoot.isSameIdentifierTransformAndAnchor(symRootLoadInProgress.rootNodeSource));
                 if (loadInProgressIndex === -1) {
                     // This node no longer shall be added
                     return false;
@@ -172,6 +192,15 @@ export class CfgProductNode extends CfgTransformNode {
                 this.add(symRoot);
                 return true;
             });
+            // Updated symRootChildren
+            const anchorableChildren = this._getAnchorableNodes();
+            // Make a map of who is anchored to who
+            const anchoredToAnchors = makeAnchoredToAnchorMap(anchorableChildren, getAnchorTargetPriorityComparer(this.product._internal.measureDefinitions));
+            this._anchoredToAnchors = anchoredToAnchors;
+            for (const child of anchorableChildren) {
+                child.setAnchorTarget(anchoredToAnchors.get(child));
+            }
+            this.refreshStretch();
             for (const symRoot of addedSymRoots) {
                 if (coordinatorWithMeta === undefined) {
                     continue;
@@ -200,8 +229,10 @@ export class CfgProductNode extends CfgTransformNode {
             yield Promise.all(additionalProductLoadPromises);
         });
     }
-    /// Run any animations and then permanently removes the nodes from the tree
-    /// This function is recursively applied on additional products.
+    /**
+     * Run any animations and then permanently removes the nodes from the tree
+     * This function is recursively applied on additional products.
+     */
     flushScheduledForRemove(animationCoordinator) {
         return __awaiter(this, void 0, void 0, function* () {
             const thisBatch = this._scheduledForRemoval.slice();
@@ -218,14 +249,17 @@ export class CfgProductNode extends CfgTransformNode {
             }))()));
         });
     }
-    /// Are all materials currently needed loaded and ready to be applied?
-    /// This function does not take additional products into account.
+    /**
+     * Are all materials currently needed loaded and ready to be applied?
+     * This function does not take additional products into account.
+     */
     _isAllMeshMaterialsReady() {
         return this._getSymRootChildren().reduce((a, c) => a && c.isAllMeshMaterialsReady(), true);
     }
-    /// Resolves when all materials currently needed have been loaded and are
-    /// ready to be applied.
-    /// This function does not take additional products into account.
+    /**
+     * Resolves when all materials currently needed have been loaded and are ready to be applied.
+     * This function does not take additional products into account.
+     */
     _awaitAllMeshMaterialsReady() {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
@@ -246,8 +280,10 @@ export class CfgProductNode extends CfgTransformNode {
             });
         });
     }
-    /// Loads the materials needed.
-    /// This function is recursively applied on additional products.
+    /**
+     * Loads the materials needed.
+     * This function is recursively applied on additional products.
+     */
     loadMaterials(animationCoordinator) {
         return __awaiter(this, void 0, void 0, function* () {
             const product = this._product;
@@ -260,8 +296,10 @@ export class CfgProductNode extends CfgTransformNode {
             ]);
         });
     }
-    /// Update the tag (area) to material mapping and gives them to sym children
-    /// This function does not take additional products into account.
+    /**
+     * Update the tag (area) to material mapping and gives them to sym children
+     * This function does not take additional products into account.
+     */
     _aggregateMaterialsPushToChildrenAndLoad(animationCoordinator) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this._applicationAreas === undefined || this._configuration === undefined) {
@@ -272,8 +310,10 @@ export class CfgProductNode extends CfgTransformNode {
             yield this._pushMaterialToSymRootChildrenAndLoad(animationCoordinator);
         });
     }
-    /// Starts loading the materials on the sym children (but does not apply)
-    /// This function does not take additional products into account.
+    /**
+     * Starts loading the materials on the sym children (but does not apply)
+     * This function does not take additional products into account.
+     */
     _pushMaterialToSymRootChildrenAndLoad(animationCoordinator) {
         return __awaiter(this, void 0, void 0, function* () {
             const areasToMaterials = this._areasToMaterials;
@@ -293,8 +333,15 @@ export class CfgProductNode extends CfgTransformNode {
             .filter(isProductNode)
             .filter((c) => includeDestroyed || !c.isDestroyed());
     }
-    /// Applies and thereby shows the geometry. Finally flushes scheduled for remove.
-    /// This function is recursively applied on additional products.
+    _getAnchorableNodes() {
+        return this.getChildren()
+            .filter(isCfgAnchorableNode)
+            .filter((c) => !c.isDestroyed());
+    }
+    /**
+     * Applies and thereby shows the geometry. Finally flushes scheduled for remove.
+     * This function is recursively applied on additional products.
+     */
     applyGeo(animationCoordinator) {
         return __awaiter(this, void 0, void 0, function* () {
             yield Promise.all(this._applyOnDescendantProductNodes((p) => (() => __awaiter(this, void 0, void 0, function* () {
@@ -309,8 +356,10 @@ export class CfgProductNode extends CfgTransformNode {
             this.flushScheduledForRemove(animationCoordinator);
         });
     }
-    /// Applies and thereby shows the right materials.
-    /// This function is recursively applied on additional products.
+    /**
+     * Applies and thereby shows the right materials.
+     * This function is recursively applied on additional products.
+     */
     applyMaterials() {
         return __awaiter(this, void 0, void 0, function* () {
             yield Promise.all(this._applyOnDescendantProductNodes((p) => (() => __awaiter(this, void 0, void 0, function* () {
@@ -324,6 +373,49 @@ export class CfgProductNode extends CfgTransformNode {
             }))()));
         });
     }
+    setAnchorTarget(anchorTarget) {
+        this._anchorTarget = anchorTarget;
+    }
+    refreshStretch() {
+        const updated = updatedStretchedAnchorPointMatrix(this.anchorRef, this._anchorTarget, this._stretchedAnchorPointMatrix, true);
+        if (updated !== undefined) {
+            this._stretchedAnchorPointMatrix = updated;
+            this._originalMatrixWithModelTransform = undefined; // Reset the matrix
+            this.initTransform();
+        }
+        // anchoredToAnchors is sorted so that anchors always are before what
+        // is anchored to them. That way we know that if we refreshStretch on
+        // them first anchor-on-anchor will work correctly.
+        const anchorableChildren = this._getAnchorableNodes().slice();
+        for (const anchor of this._anchoredToAnchors.values()) {
+            const i = anchorableChildren.indexOf(anchor);
+            if (i === -1) {
+                // As multiple anchors can anchor to the same anchor this will happen
+                continue;
+            }
+            anchor.refreshStretch();
+            anchorableChildren.splice(i, 1);
+        }
+        // Refresh for the un-anchored
+        for (const child of anchorableChildren) {
+            child.refreshStretch();
+        }
+    }
+    get originalMatrix() {
+        var _a;
+        if (this._originalMatrixWithModelTransform === undefined) {
+            let originalMatrix = (_a = this._modelMatrix) !== null && _a !== void 0 ? _a : Matrix.Identity();
+            const stretchedAnchorPointMatrix = this._stretchedAnchorPointMatrix;
+            if (stretchedAnchorPointMatrix !== undefined) {
+                originalMatrix = originalMatrix.multiply(stretchedAnchorPointMatrix);
+            }
+            this._originalMatrixWithModelTransform = originalMatrix;
+        }
+        return this._originalMatrixWithModelTransform;
+    }
+    initTransform() {
+        this.setPreTransformMatrix(this.originalMatrix);
+    }
     _applyDebugSymRoots(symRootPromises) {
         return __awaiter(this, void 0, void 0, function* () {
             const allSymRoots = yield Promise.all(symRootPromises);
@@ -463,7 +555,7 @@ export class CfgProductNode extends CfgTransformNode {
             const files = fileUpload.files;
             if (files !== null) {
                 const symRootPromises = Array.from(files).map((file) => {
-                    return CfgSymRootNode.makeCfgSymRootFromFile(logger, true, renderEnvironment, file);
+                    return CfgSymRootNode.makeCfgSymRootFromFile(logger, true, renderEnvironment, this, file);
                 });
                 this._applyDebugSymRoots(symRootPromises);
             }
@@ -480,7 +572,7 @@ export class CfgProductNode extends CfgTransformNode {
             alert("You must provide an URL to a CmSym-file");
             return;
         }
-        const symRootNode = CfgSymRootNode.makeCfgSymRootFromUrl(this.logger, true, this._renderEnvironment, url, undefined);
+        const symRootNode = CfgSymRootNode.makeCfgSymRootFromUrl(this.logger, true, this._renderEnvironment, this, url, undefined, undefined);
         this._applyDebugSymRoots([symRootNode]);
     }
 }

package/dist/nodes/CfgSymNode.d.ts

@@ -5,27 +5,35 @@ import { DetailLevel } from "@configura/web-core/dist/cm/geometry/DetailMask.js"
 import { LogObservable, LogProducer } from "@configura/web-utilities";
 import { AnimatableObject } from "../animation/AnimatableObject.js";
 import { CoordinatorWithMeta } from "../animation/coordinator/Coordinator.js";
+import { CfgStretchData } from "../geometry/stretch/CfgStretchData.js";
 import { CfgBoundingBox } from "../utilities/CfgBoundingBox.js";
 import { RenderEnv } from "../view/RenderEnv.js";
+import { CfgProductNode } from "./CfgProductNode.js";
 import { CfgTransformNode } from "./CfgTransformNode.js";
 export declare class CfgSymNode extends CfgTransformNode implements LogProducer, AnimatableObject {
-    _detailLevel: DetailLevel;
-    _symNode: SymNode;
-    private _symNodeParent?;
-    static makeCfgSymNode(renderEnvironment: RenderEnv, detailLevel: DetailLevel, symNode: SymNode, symNodeParent?: CfgSymNode): Promise<CfgSymNode | undefined>;
+    readonly cfgProductNode: CfgProductNode;
+    private readonly _cfgSymNodeParent;
+    readonly _detailLevel: DetailLevel;
+    readonly _symNode: SymNode;
+    static makeCfgSymNode(renderEnvironment: RenderEnv, cfgProductNode: CfgProductNode, cfgSymNodeParent: CfgSymNode, detailLevel: DetailLevel, symNode: SymNode): Promise<CfgSymNode | undefined>;
     get cfgClassName(): string;
-    static initCfgSymNode(node: CfgSymNode): Promise<void>;
+    protected static initCfgSymNode(node: CfgSymNode): Promise<void>;
     logger: LogObservable;
     _tag: string | undefined;
     private _gMaterial;
     private _symNodeChildren;
     private _deferredMesh;
     private _originalMatrix;
-    protected constructor(renderEnvironment: RenderEnv, _detailLevel: DetailLevel, _symNode: SymNode, _symNodeParent?: CfgSymNode | undefined);
+    private _invertedOriginalMatrix;
+    private _accumulatedStretchDatas;
+    protected constructor(renderEnvironment: RenderEnv, cfgProductNode: CfgProductNode, _cfgSymNodeParent: CfgSymNode | undefined, _detailLevel: DetailLevel, _symNode: SymNode);
+    get accumulatedStretchDatas(): CfgStretchData[];
+    refreshStretch(): void;
     getChildrenForAnimation(): CfgTransformNode[];
     private initTag;
     private initGMaterial;
     get originalMatrix(): Matrix;
+    get invertedOriginalMatrix(): Matrix;
     protected initTransform(): void;
     private initChildren;
     get isEmpty(): boolean;

package/dist/nodes/CfgSymNode.js

@@ -16,27 +16,35 @@ import { symTransformToMatrix } from "../utilities/utilities3D.js";
 import { CfgDeferredMeshNode } from "./CfgDeferredMeshNode.js";
 import { CfgTransformNode } from "./CfgTransformNode.js";
 function isNoRender(symNode) {
-    var _a;
-    const symTags = symNode.symTags();
-    return symTags instanceof SymTags && !!((_a = symTags.node) === null || _a === void 0 ? void 0 : _a.components.has("symConnector"));
+    var _a, _b;
+    // Do not render SymPlanes. Disable to debug Stretch. Search for aTriMeshPlane to set radius.
+    if (symNode.symPlane() !== undefined) {
+        return true;
+    }
+    // Do not render connectors. Disable to debug connectors, only boxes will show up for now.
+    if (((_b = (_a = symNode.symTags()) === null || _a === void 0 ? void 0 : _a.node) === null || _b === void 0 ? void 0 : _b.components.has("symConnector")) === true) {
+        return true;
+    }
+    return false;
 }
 export class CfgSymNode extends CfgTransformNode {
-    constructor(renderEnvironment, _detailLevel, _symNode, _symNodeParent) {
+    constructor(renderEnvironment, cfgProductNode, _cfgSymNodeParent, _detailLevel, _symNode) {
         super(renderEnvironment, "(SymNode) " + _symNode.id);
+        this.cfgProductNode = cfgProductNode;
+        this._cfgSymNodeParent = _cfgSymNodeParent;
         this._detailLevel = _detailLevel;
         this._symNode = _symNode;
-        this._symNodeParent = _symNodeParent;
         this.logger = new LogObservable();
         this._symNodeChildren = [];
         this.initTransform();
     }
-    static makeCfgSymNode(renderEnvironment, detailLevel, symNode, symNodeParent) {
+    static makeCfgSymNode(renderEnvironment, cfgProductNode, cfgSymNodeParent, detailLevel, symNode) {
         return __awaiter(this, void 0, void 0, function* () {
             if (isNoRender(symNode)) {
                 return undefined;
             }
-            const node = new CfgSymNode(renderEnvironment, detailLevel, symNode, symNodeParent);
-            yield CfgSymNode.initCfgSymNode(node);
+            const node = new this(renderEnvironment, cfgProductNode, cfgSymNodeParent, detailLevel, symNode);
+            yield this.initCfgSymNode(node);
             if (node.isEmpty) {
                 if (renderEnvironment.cullEmptyNodes) {
                     node.dispose();
@@ -61,6 +69,21 @@ export class CfgSymNode extends CfgTransformNode {
             yield node.loadGeo();
         });
     }
+    get accumulatedStretchDatas() {
+        var _a;
+        if (this._accumulatedStretchDatas === undefined) {
+            this._accumulatedStretchDatas = (((_a = this._cfgSymNodeParent) === null || _a === void 0 ? void 0 : _a.accumulatedStretchDatas) || []).map((stretchData) => stretchData.applyMatrix(this.invertedOriginalMatrix));
+        }
+        return this._accumulatedStretchDatas;
+    }
+    refreshStretch() {
+        if (this._deferredMesh !== undefined) {
+            this._deferredMesh.refreshStretch();
+        }
+        for (const child of this._symNodeChildren) {
+            child.refreshStretch();
+        }
+    }
     getChildrenForAnimation() {
         const target = super.getChildrenForAnimation();
         if (this._deferredMesh !== undefined) {
@@ -84,7 +107,7 @@ export class CfgSymNode extends CfgTransformNode {
             }
         }
         if ((material === null || material === void 0 ? void 0 : material.gm) === undefined) {
-            const parentMaterial = (_b = this._symNodeParent) === null || _b === void 0 ? void 0 : _b._gMaterial;
+            const parentMaterial = (_b = this._cfgSymNodeParent) === null || _b === void 0 ? void 0 : _b._gMaterial;
             if ((parentMaterial === null || parentMaterial === void 0 ? void 0 : parentMaterial.gm) !== undefined) {
                 material = parentMaterial;
             }
@@ -104,15 +127,25 @@ export class CfgSymNode extends CfgTransformNode {
         }
         return this._originalMatrix;
     }
+    get invertedOriginalMatrix() {
+        if (this._invertedOriginalMatrix === undefined) {
+            this._invertedOriginalMatrix = this.originalMatrix.clone().invert();
+        }
+        return this._invertedOriginalMatrix;
+    }
     initTransform() {
         this.setPreTransformMatrix(this.originalMatrix);
     }
     initChildren() {
         return __awaiter(this, void 0, void 0, function* () {
             const promises = [];
+            const { logger, _detailLevel: detailLevel } = this;
             for (const childNode of (this._symNode.children(this.logger, false, true) || []).values()) {
+                if (childNode.isStretch(logger, detailLevel)) {
+                    continue;
+                }
                 promises.push((() => __awaiter(this, void 0, void 0, function* () {
-                    const childSymNode = yield CfgSymNode.makeCfgSymNode(this._renderEnvironment, this._detailLevel, childNode, this);
+                    const childSymNode = yield CfgSymNode.makeCfgSymNode(this._renderEnvironment, this.cfgProductNode, this, this._detailLevel, childNode);
                     if (childSymNode === undefined) {
                         return;
                     }
@@ -130,14 +163,14 @@ export class CfgSymNode extends CfgTransformNode {
         if (this._tag !== undefined && areasToMaterials.has(this._tag)) {
             return areasToMaterials.get(this._tag);
         }
-        if (this._symNodeParent !== undefined) {
-            return this._symNodeParent.findMaterial(areasToMaterials);
+        if (this._cfgSymNodeParent !== undefined) {
+            return this._cfgSymNodeParent.findMaterial(areasToMaterials);
         }
         return undefined;
     }
     loadGeo() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._deferredMesh = yield CfgDeferredMeshNode.makeCfgDeferredMesh(this.logger, this._renderEnvironment, this._detailLevel, this._symNode, this._gMaterial);
+            this._deferredMesh = yield CfgDeferredMeshNode.makeCfgDeferredMesh(this.logger, this._renderEnvironment, this.cfgProductNode, this._detailLevel, this._symNode, this._gMaterial, this.accumulatedStretchDatas);
             if (this._deferredMesh === undefined) {
                 return;
             }
@@ -179,10 +212,10 @@ export class CfgSymNode extends CfgTransformNode {
         });
     }
     get boundingBox() {
-        const bb = this._symNodeChildren.reduce((a, m) => {
-            a.expand(m.boundingBox);
-            return a;
-        }, new CfgBoundingBox());
+        const bb = new CfgBoundingBox();
+        for (const symNodeChild of this._symNodeChildren) {
+            bb.expand(symNodeChild.boundingBox);
+        }
         if (this._deferredMesh !== undefined) {
             bb.expand(this._deferredMesh.boundingBox);
         }

package/dist/nodes/CfgSymRootNode.d.ts

@@ -1,24 +1,32 @@
 import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
 import { CfgMaterialMapping, RootNodeSource, Transform as ModelTransform } from "@configura/web-api";
 import { SymNode } from "@configura/web-core/dist/cm/format/cmsym/SymNode.js";
-import { Logger } from "@configura/web-utilities";
+import { LengthUnit, Logger } from "@configura/web-utilities";
 import { CoordinatorWithMeta } from "../animation/coordinator/Coordinator.js";
+import { CfgStretchData } from "../geometry/stretch/CfgStretchData.js";
+import { CfgAnchorRef, CfgAnchorTargetNode } from "../utilities/anchor/anchor.js";
 import { RenderEnv } from "../view/RenderEnv.js";
+import { CfgProductNode } from "./CfgProductNode.js";
 import { CfgSymNode } from "./CfgSymNode.js";
+export declare const MESH_UNIT: LengthUnit;
 export declare function isSymRootNode(value: unknown): value is CfgSymRootNode;
 export declare class CfgSymRootNode extends CfgSymNode {
     private _isForDebug;
     _identifier: string;
-    static makeCfgSymRootFromRootNodeSource(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, rootNodeSource: RootNodeSource): Promise<CfgSymRootNode | undefined>;
-    static makeCfgSymRootFromUrl(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, symUrl: string, transform: ModelTransform | undefined): Promise<CfgSymRootNode | undefined>;
-    static makeCfgSymRootFromFile(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, file: File): Promise<CfgSymRootNode | undefined>;
+    readonly anchorRef: CfgAnchorRef | undefined;
+    static makeCfgSymRootFromRootNodeSource(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, cfgProductNodeParent: CfgProductNode, rootNodeSource: RootNodeSource): Promise<CfgSymRootNode | undefined>;
+    static makeCfgSymRootFromUrl(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, cfgProductNodeParent: CfgProductNode, symUrl: string, transform: ModelTransform | undefined, anchorRef: CfgAnchorRef | undefined): Promise<CfgSymRootNode | undefined>;
+    static makeCfgSymRootFromFile(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, cfgProductNodeParent: CfgProductNode, file: File): Promise<CfgSymRootNode | undefined>;
     get cfgClassName(): string;
-    static makeCfgSymRootFromSymNode(logger: Logger, renderEnvironment: RenderEnv, isForDebug: boolean, identifier: string, transform: ModelTransform | undefined, symNode: SymNode): Promise<CfgSymRootNode | undefined>;
+    static makeCfgSymRootFromSymNode(logger: Logger, renderEnvironment: RenderEnv, cfgProductNodeParent: CfgProductNode, isForDebug: boolean, identifier: string, transform: ModelTransform | undefined, anchorRef: CfgAnchorRef | undefined, symNode: SymNode): Promise<CfgSymRootNode | undefined>;
     private _destroyed;
     private _originalMatrixWithModelTransform;
+    private _stretchDatas;
+    private _anchorTarget;
+    private _stretchedAnchorPointMatrix;
     private constructor();
     get isForDebug(): boolean;
-    isSameIdentifierAndTransform(rootNodeSource: RootNodeSource): boolean;
+    isSameIdentifierTransformAndAnchor(rootNodeSource: RootNodeSource): boolean;
     destroy(): void;
     isDestroyed(): boolean;
     applyGeo(): void;
@@ -28,6 +36,10 @@ export declare class CfgSymRootNode extends CfgSymNode {
     private get modelTransform();
     private set modelTransform(value);
     get originalMatrix(): Matrix;
+    get stretchDatas(): CfgStretchData[];
+    get accumulatedStretchDatas(): CfgStretchData[];
+    setAnchorTarget(anchorTarget: CfgAnchorTargetNode | undefined): void;
+    refreshStretch(): void;
     protected addInspectorProperties(): void;
     private get _inspectorIsForDebug();
 }