@configura/babylon-view 3.0.2 → 3.2.0-alpha.0

package/dist/nodes/CfgProductNode.js

@@ -215,8 +215,22 @@ export class CfgProductNode extends CfgTransformNode {
             // Make a map of who is anchored to who
             const anchoredToAnchors = makeAnchoredToAnchorMap(anchorableChildren, getAnchorTargetPriorityComparer(this.product._internal.measureDefinitions));
             this._anchoredToAnchors = anchoredToAnchors;
+            const anchorRefKey = (ref) => `${ref.stretchSymNodeId}:${ref.toSp}`;
+            const inheritedAnchorMap = new Map();
             for (const child of anchorableChildren) {
-                child.setAnchorTarget(anchoredToAnchors.get(child));
+                const anchorTarget = anchoredToAnchors.get(child);
+                if (anchorTarget && child.anchorRef) {
+                    child.setAnchorTarget(anchorTarget);
+                    inheritedAnchorMap.set(anchorRefKey(child.anchorRef), anchorTarget);
+                }
+            }
+            for (const child of anchorableChildren) {
+                if (isSymRootNode(child) && child.parentAnchorRef) {
+                    const parentAnchorTarget = inheritedAnchorMap.get(anchorRefKey(child.parentAnchorRef));
+                    if (parentAnchorTarget) {
+                        child.setParentAnchorTarget(parentAnchorTarget);
+                    }
+                }
             }
             this.refreshStretch();
             for (const symRoot of addedSymRoots) {
@@ -592,7 +606,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, this, url, undefined, undefined);
+        const symRootNode = CfgSymRootNode.makeCfgSymRootFromUrl(this.logger, true, this._renderEnvironment, this, url, undefined, undefined, undefined);
         this._applyDebugSymRoots([symRootNode]);
     }
 }

package/dist/nodes/CfgSymRootNode.d.ts

@@ -14,15 +14,17 @@ export declare class CfgSymRootNode extends CfgSymNode {
     private _isForDebug;
     _identifier: string;
     readonly anchorRef: CfgAnchorRef | undefined;
+    readonly parentAnchorRef: 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 makeCfgSymRootFromUrl(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, cfgProductNodeParent: CfgProductNode, symUrl: string, transform: ModelTransform | undefined, anchorRef: CfgAnchorRef | undefined, parentAnchorRef: 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, cfgProductNodeParent: CfgProductNode, isForDebug: boolean, identifier: string, transform: ModelTransform | undefined, anchorRef: CfgAnchorRef | undefined, symNode: SymNode): Promise<CfgSymRootNode | undefined>;
+    static makeCfgSymRootFromSymNode(logger: Logger, renderEnvironment: RenderEnv, cfgProductNodeParent: CfgProductNode, isForDebug: boolean, identifier: string, transform: ModelTransform | undefined, anchorRef: CfgAnchorRef | undefined, parentAnchorRef: CfgAnchorRef | undefined, symNode: SymNode): Promise<CfgSymRootNode | undefined>;
     private _destroyed;
     private _originalMatrixWithModelTransform;
     private _stretchDatas;
     private _anchorTarget;
+    private _parentAnchorTarget;
     private _stretchedAnchorPointMatrix;
     private constructor();
     get isForDebug(): boolean;
@@ -39,6 +41,7 @@ export declare class CfgSymRootNode extends CfgSymNode {
     get stretchDatas(): CfgStretchData[];
     get accumulatedStretchDatas(): CfgStretchData[];
     setAnchorTarget(anchorTarget: CfgAnchorTargetNode | undefined): void;
+    setParentAnchorTarget(parentAnchorTarget: CfgAnchorTargetNode | undefined): void;
     refreshStretch(): void;
     protected addInspectorProperties(): void;
     private get _inspectorIsForDebug();

package/dist/nodes/CfgSymRootNode.js

@@ -50,11 +50,12 @@ function getBestMatchingDetailLevel(logger, symNode, allowedLevels) {
     return detailLevel || DetailLevel.undefined;
 }
 export class CfgSymRootNode extends CfgSymNode {
-    constructor(renderEnvironment, cfgProductNodeParent, _isForDebug, detailLevel, symNode, _identifier, modelTransform, anchorRef) {
+    constructor(renderEnvironment, cfgProductNodeParent, _isForDebug, detailLevel, symNode, _identifier, modelTransform, anchorRef, parentAnchorRef) {
         super(renderEnvironment, cfgProductNodeParent, undefined, detailLevel, symNode);
         this._isForDebug = _isForDebug;
         this._identifier = _identifier;
         this.anchorRef = anchorRef;
+        this.parentAnchorRef = parentAnchorRef;
         this._destroyed = false;
         this.name = "(SymRoot) " + symNode.id;
         this.modelTransform = modelTransform;
@@ -63,11 +64,11 @@ export class CfgSymRootNode extends CfgSymNode {
     static makeCfgSymRootFromRootNodeSource(logger, isForDebug, renderEnvironment, cfgProductNodeParent, rootNodeSource) {
         return __awaiter(this, void 0, void 0, function* () {
             return isModel(rootNodeSource)
-                ? this.makeCfgSymRootFromUrl(logger, isForDebug, renderEnvironment, cfgProductNodeParent, rootNodeSource.uri, rootNodeSource.t, CfgAnchorRef.make(rootNodeSource.anchor))
+                ? this.makeCfgSymRootFromUrl(logger, isForDebug, renderEnvironment, cfgProductNodeParent, rootNodeSource.uri, rootNodeSource.t, CfgAnchorRef.make(rootNodeSource.anchor), CfgAnchorRef.make(rootNodeSource.parentAnchor))
                 : this.makeCfgSymRootFromFile(logger, isForDebug, renderEnvironment, cfgProductNodeParent, rootNodeSource);
         });
     }
-    static makeCfgSymRootFromUrl(logger, isForDebug, renderEnvironment, cfgProductNodeParent, symUrl, transform, anchorRef) {
+    static makeCfgSymRootFromUrl(logger, isForDebug, renderEnvironment, cfgProductNodeParent, symUrl, transform, anchorRef, parentAnchorRef) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!/.cmsym$/i.test(symUrl)) {
                 renderEnvironment.notifyError(logger.errorAsObject("Unsupported model URL (not cmsym format): ", symUrl));
@@ -75,7 +76,7 @@ export class CfgSymRootNode extends CfgSymNode {
             }
             try {
                 const symNode = yield loadCachedSymNode(logger, symUrl, renderEnvironment);
-                return this.makeCfgSymRootFromSymNode(logger, renderEnvironment, cfgProductNodeParent, isForDebug, makeIdentifier("uri", symUrl), transform, anchorRef, symNode);
+                return this.makeCfgSymRootFromSymNode(logger, renderEnvironment, cfgProductNodeParent, isForDebug, makeIdentifier("uri", symUrl), transform, anchorRef, parentAnchorRef, symNode);
             }
             catch (e) {
                 logger.errorFromCaught(e);
@@ -88,20 +89,20 @@ export class CfgSymRootNode extends CfgSymNode {
             const arrayBuffer = yield readFileToArrayBuffer(file);
             const dexObj = renderEnvironment.dexManager.arrayBufferToDexObj(logger, "", arrayBuffer.buffer);
             const symNode = makeSymFromDex(logger, dexObj);
-            return this.makeCfgSymRootFromSymNode(logger, renderEnvironment, cfgProductNodeParent, isForDebug, makeIdentifier("file", file.name), undefined, undefined, symNode);
+            return this.makeCfgSymRootFromSymNode(logger, renderEnvironment, cfgProductNodeParent, isForDebug, makeIdentifier("file", file.name), undefined, undefined, undefined, symNode);
         });
     }
     get cfgClassName() {
         return "CfgSymRootNode";
     }
-    static makeCfgSymRootFromSymNode(logger, renderEnvironment, cfgProductNodeParent, isForDebug, identifier, transform, anchorRef, symNode) {
+    static makeCfgSymRootFromSymNode(logger, renderEnvironment, cfgProductNodeParent, isForDebug, identifier, transform, anchorRef, parentAnchorRef, 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 this(renderEnvironment, cfgProductNodeParent, isForDebug, detailLevel, symNode, identifier, transform, anchorRef);
+            const node = new this(renderEnvironment, cfgProductNodeParent, isForDebug, detailLevel, symNode, identifier, transform, anchorRef, parentAnchorRef);
             yield this.initCfgSymNode(node);
             return node;
         });
@@ -110,7 +111,7 @@ export class CfgSymRootNode extends CfgSymNode {
         return this._isForDebug;
     }
     isSameIdentifierTransformAndAnchor(rootNodeSource) {
-        return isSameIdentifierTransformAndAnchor(this._identifier, this.modelTransform, this.anchorRef, makeIdentifierFromRootNodeSource(rootNodeSource), isModel(rootNodeSource) ? rootNodeSource.t : undefined, isModel(rootNodeSource) ? CfgAnchorRef.make(rootNodeSource.anchor) : undefined);
+        return isSameIdentifierTransformAndAnchor(this._identifier, this.modelTransform, this.anchorRef, this.parentAnchorRef, makeIdentifierFromRootNodeSource(rootNodeSource), isModel(rootNodeSource) ? rootNodeSource.t : undefined, isModel(rootNodeSource) ? CfgAnchorRef.make(rootNodeSource.anchor) : undefined, isModel(rootNodeSource) ? CfgAnchorRef.make(rootNodeSource.parentAnchor) : undefined);
     }
     destroy() {
         this._destroyed = true;
@@ -211,9 +212,17 @@ export class CfgSymRootNode extends CfgSymNode {
     setAnchorTarget(anchorTarget) {
         this._anchorTarget = anchorTarget;
     }
+    setParentAnchorTarget(parentAnchorTarget) {
+        this._parentAnchorTarget = parentAnchorTarget;
+    }
     refreshStretch() {
         super.refreshStretch();
-        const updated = updatedStretchedAnchorPointMatrix(this.anchorRef, this._anchorTarget, this._stretchedAnchorPointMatrix);
+        // Apply transformation relative to the parent anchor if it exists; otherwise, use this node's own anchor.
+        // Note: If both parent and own anchors exist, this may cause unexpected transformation results.
+        const [anchorRef, anchorTarget] = this.parentAnchorRef
+            ? [this.parentAnchorRef, this._parentAnchorTarget]
+            : [this.anchorRef, this._anchorTarget];
+        const updated = updatedStretchedAnchorPointMatrix(anchorRef, anchorTarget, this._stretchedAnchorPointMatrix);
         if (updated === undefined) {
             return;
         }

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

@@ -46,6 +46,6 @@ export declare function getRawAnchorPoint(anchorTarget: CfgAnchorTargetNode | un
  * Application of anchoring happens from anchor tree root and out, so that originalMatrix of
  * anchorTarget will already have any anchoring and stretch applied.
  */
-export declare function getStretchedAnchorPointMatrix(anchorRef: CfgAnchorRef | undefined, anchorTarget: CfgAnchorTargetNode | undefined): Matrix | undefined;
+export declare function getStretchedAnchorPointMatrix(anchorRef: CfgAnchorRef | undefined, anchorTarget: CfgSymRootNode | undefined): Matrix | undefined;
 export declare function updatedStretchedAnchorPointMatrix(anchorRef: CfgAnchorRef | undefined, anchorTarget: CfgAnchorTargetNode | undefined, currentStretchedAnchorPointMatrix: Matrix | undefined): Matrix | undefined;
 //# sourceMappingURL=anchor.d.ts.map

package/dist/utilities/anchor/anchor.js

@@ -104,6 +104,14 @@ export function getRawAnchorPoint(anchorTarget, anchorRef) {
  * Application of anchoring happens from anchor tree root and out, so that originalMatrix of
  * anchorTarget will already have any anchoring and stretch applied.
  */
+/// Calculate a matrix which is the translation that makes this
+/// 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-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.
 export function getStretchedAnchorPointMatrix(anchorRef, anchorTarget) {
     const rawAnchorPoint = getRawAnchorPoint(anchorTarget, anchorRef);
     if (rawAnchorPoint === undefined || anchorTarget === undefined) {
@@ -112,7 +120,8 @@ export function getStretchedAnchorPointMatrix(anchorRef, anchorTarget) {
     // 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.
+    // Apply the anchorTarget matrix. Move the point as if it was
+    // a child to the anchorTarget.
     const anchorTargetMatrixApplied = 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

package/dist/utilities/utilitiesSymRootIdentifier.d.ts

@@ -3,6 +3,6 @@ import { CfgAnchorRef } from "./anchor/anchor.js";
 export declare function makeIdentifier(type: "uri" | "file", v: string): string;
 export declare function identifierIsUri(identifier: string): boolean;
 export declare function makeIdentifierFromRootNodeSource(source: RootNodeSource): string;
-export declare function isSameIdentifierTransformAndAnchor(identifier1: string, transform1: ModelTransform | undefined, anchor1: CfgAnchorRef | undefined, identifier2: string, transform2: ModelTransform | undefined, anchor2: CfgAnchorRef | undefined): boolean;
+export declare function isSameIdentifierTransformAndAnchor(identifier1: string, transform1: ModelTransform | undefined, anchor1: CfgAnchorRef | undefined, parentAnchor1: CfgAnchorRef | undefined, identifier2: string, transform2: ModelTransform | undefined, anchor2: CfgAnchorRef | undefined, parentAnchor2: CfgAnchorRef | undefined): boolean;
 export declare function isSameRootNodeSource(source1: RootNodeSource, source2: RootNodeSource): boolean;
 //# sourceMappingURL=utilitiesSymRootIdentifier.d.ts.map

package/dist/utilities/utilitiesSymRootIdentifier.js

@@ -12,15 +12,19 @@ export function makeIdentifierFromRootNodeSource(source) {
         ? makeIdentifier("uri", source.uri)
         : makeIdentifier("file", source.name);
 }
-export function isSameIdentifierTransformAndAnchor(identifier1, transform1, anchor1, identifier2, transform2, anchor2) {
+export function isSameIdentifierTransformAndAnchor(identifier1, transform1, anchor1, parentAnchor1, identifier2, transform2, anchor2, parentAnchor2) {
     return (identifier1 === identifier2 &&
         ((transform1 === undefined && transform2 === undefined) ||
             (transform1 !== undefined &&
                 transform2 !== undefined &&
                 modelTransformsEqual(transform1, transform2))) &&
         ((anchor1 === undefined && anchor2 === undefined) ||
-            (anchor1 !== undefined && anchor2 !== undefined && anchor1.equal(anchor2))));
+            (anchor1 !== undefined && anchor2 !== undefined && anchor1.equal(anchor2))) &&
+        ((parentAnchor1 === undefined && parentAnchor2 === undefined) ||
+            (parentAnchor1 !== undefined &&
+                parentAnchor2 !== undefined &&
+                parentAnchor1.equal(parentAnchor2))));
 }
 export function isSameRootNodeSource(source1, source2) {
-    return isSameIdentifierTransformAndAnchor(makeIdentifierFromRootNodeSource(source1), isModel(source1) ? source1.t : undefined, isModel(source1) ? CfgAnchorRef.make(source1.anchor) : undefined, makeIdentifierFromRootNodeSource(source2), isModel(source2) ? source2.t : undefined, isModel(source2) ? CfgAnchorRef.make(source2.anchor) : undefined);
+    return isSameIdentifierTransformAndAnchor(makeIdentifierFromRootNodeSource(source1), isModel(source1) ? source1.t : undefined, isModel(source1) ? CfgAnchorRef.make(source1.anchor) : undefined, isModel(source1) ? CfgAnchorRef.make(source1.parentAnchor) : undefined, makeIdentifierFromRootNodeSource(source2), isModel(source2) ? source2.t : undefined, isModel(source2) ? CfgAnchorRef.make(source2.anchor) : undefined, isModel(source2) ? CfgAnchorRef.make(source2.parentAnchor) : undefined);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@configura/babylon-view",
-	"version": "3.0.2",
+	"version": "3.2.0-alpha.0",
 	"license": "Apache-2.0",
 	"type": "module",
 	"main": "dist/index.js",
@@ -22,13 +22,13 @@
 		"@babylonjs/loaders": "5.52.0",
 		"@babylonjs/materials": "5.52.0",
 		"@babylonjs/serializers": "5.52.0",
-		"@configura/web-core": "3.0.2",
-		"@configura/web-utilities": "3.0.2",
+		"@configura/web-core": "3.2.0-alpha.0",
+		"@configura/web-utilities": "3.2.0-alpha.0",
 		"babylonjs-gltf2interface": "5.22.0",
 		"exifr": "^7.1.3"
 	},
 	"devDependencies": {
-		"@configura/web-api": "3.0.2",
+		"@configura/web-api": "3.2.0-alpha.0",
 		"@types/react": "17.0.9",
 		"@types/react-dom": "17.0.6",
 		"del-cli": "^3.0.0",
@@ -37,5 +37,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "9ea683f4211086478270c3f41c0e49f28c408ffc"
+	"gitHead": "7a79fdef61d85c6ac8a1f84be9070c12ea37ffe2"
 }