@configura/babylon-view 1.3.0-alpha.1 → 1.3.0-alpha.5

package/dist/material/CfgMaterial.js

@@ -16,14 +16,16 @@ function findTexture(textures, texture) {
 const DBL = 1;
 const BTF = 2;
 const FLP = 4;
-/// A wrapper around Babylon.js PBRMaterial class.
-///
-/// Also contains logic to create light weight "variants" of the main PBRMaterial to take into
-/// account that CmSym allows the meshes to have properties that affects the material currently
-/// applied to the mesh, such as double doubled sided or flipping the textures along the y-axis.
-///
-/// The variants are created on demand if the request to getPBRMaterial specifies properties that
-/// does not match the main PBRMaterial. The variants are then cached.
+/**
+ * A wrapper around Babylon.js PBRMaterial class.
+ *
+ * Also contains logic to create light weight "variants" of the main PBRMaterial to take into
+ * account that CmSym allows the meshes to have properties that affects the material currently
+ * applied to the mesh, such as double doubled sided or flipping the textures along the y-axis.
+ *
+ * The variants are created on demand if the request to getPBRMaterial specifies properties that
+ * does not match the main PBRMaterial. The variants are then cached.
+ */
 export class CfgMaterial {
     constructor(material, maxSimultaneousLights) {
         this.isTransparent = false;
@@ -41,13 +43,13 @@ export class CfgMaterial {
         this._variants = new Array(8);
         this._variants[this.indexFromMaterial(material)] = material;
     }
-    /// This material is supposed to be rendered as double sided by default
+    /** This material is supposed to be rendered as double sided by default. */
     isDoubleSided() {
         return !this._material.backFaceCulling;
     }
-    static fromTexture(renderEnvironment, texture, sourcePath) {
+    static makeFromTexture(renderEnvironment, texture, sourcePath) {
         var _a, _b;
-        sourcePath.push("fromTexture");
+        sourcePath.push("makeFromTexture");
         let name = "(Img)";
         const fileName = (_b = (_a = texture.name) === null || _a === void 0 ? void 0 : _a.split("\\").pop()) === null || _b === void 0 ? void 0 : _b.split("/").pop();
         if (fileName) {
@@ -58,9 +60,9 @@ export class CfgMaterial {
         material.roughness = 1;
         material.metallic = 0;
         // TODO Babylon: What happens if the texture has an alpha map? Compare to Three.js and CET
-        return new CfgMaterial(material, renderEnvironment.lightRig.lightCount);
+        return new this(material, renderEnvironment.lightRig.lightCount);
     }
-    static compileFromGm(renderEnvironment, meta, gMaterial, textures) {
+    static makeFromGm(renderEnvironment, meta, gMaterial, textures) {
         var _a, _b;
         // Use the materials given name or fallback to the materialKey, if any.
         const miscName = (_a = gMaterial.misc) === null || _a === void 0 ? void 0 : _a.get("name");
@@ -68,16 +70,16 @@ export class CfgMaterial {
             ? miscName
             : (_b = gMaterial.materialKey) !== null && _b !== void 0 ? _b : "";
         const { material, transparent, doubleSided } = gMaterial instanceof GMaterialPBR
-            ? this.compileFromGmPBR(renderEnvironment, meta, gMaterial, textures, name)
-            : this.compileFromGmClassic(renderEnvironment, meta, gMaterial, textures, name);
+            ? this.makeFromGmPBR(renderEnvironment, meta, gMaterial, textures, name)
+            : this.makeFromGmClassic(renderEnvironment, meta, gMaterial, textures, name);
         makeMaterialDoubleSided(material, doubleSided);
-        const cfgMaterial = new CfgMaterial(material, renderEnvironment.lightRig.lightCount);
+        const cfgMaterial = new this(material, renderEnvironment.lightRig.lightCount);
         cfgMaterial.isTransparent = transparent;
         return cfgMaterial;
     }
-    static compileFromGmPBR(renderEnvironment, meta, gMaterial, textures, name) {
+    static makeFromGmPBR(renderEnvironment, meta, gMaterial, textures, name) {
         var _a;
-        meta.sourcePath.push("compileFromGmPBR");
+        meta.sourcePath.push("makeFromGmPBR");
         name = "(PBR) " + name;
         const { doubleSided, base, emissive, metallic, normal, occlusion, opacity, refraction, roughness, } = gMaterial;
         const material = new PBRMaterial(name, renderEnvironment.scene);
@@ -225,8 +227,8 @@ export class CfgMaterial {
         }
         return { material, transparent, doubleSided };
     }
-    static compileFromGmClassic(renderEnvironment, meta, gMaterial, textures, name) {
-        meta.sourcePath.push("compileFromGmClassic");
+    static makeFromGmClassic(renderEnvironment, meta, gMaterial, textures, name) {
+        meta.sourcePath.push("makeFromGmClassic");
         name = "(GM) " + name;
         const { doubleSided, redCustomProperties: redEngineCustomProperties, reflection, bump, diffuse, specular, transparency, } = gMaterial;
         const bumpTexture = findTexture(textures, bump);
@@ -397,8 +399,10 @@ export class CfgMaterial {
         return clone;
     }
 }
-/// The exact changes this method makes depends on the material's separateCullingPass setting, so
-/// make sure make any changes to that property before calling this method.
+/**
+ * The exact changes this method makes depends on the material's separateCullingPass setting, so
+ * make sure make any changes to that property before calling this method.
+ */
 export function makeMaterialDoubleSided(material, doubleSided) {
     if (doubleSided) {
         // SeparateCullingPass breaks twoSidedLightning by not flipping the normals when
@@ -414,11 +418,13 @@ export function makeMaterialDoubleSided(material, doubleSided) {
         material.forceNormalForward = false; // Don't change the normals to front facing
     }
 }
-/// Clones all the textures used in the material and flips them along the y-axis by inverting the
-/// texture's vScale, vOffset and wRotation.
-///
-/// @note: The flipped state is not stored in the material it self, so calling this method twice on
-/// the same material will undo the flip.
+/**
+ * Clones all the textures used in the material and flips them along the y-axis by inverting the
+ * texture's vScale, vOffset and wRotation.
+ *
+ * @note: The flipped state is not stored in the material it self, so calling this method twice on
+ * the same material will undo the flip.
+ */
 function flipMaterialTextures(material) {
     material.albedoTexture = cloneAndFlipTexture(material.albedoTexture);
     material.bumpTexture = cloneAndFlipTexture(material.bumpTexture);
@@ -438,9 +444,11 @@ function flipMaterialTextures(material) {
     material.reflectivityTexture = cloneAndFlipTexture(material.reflectivityTexture);
     material.microSurfaceTexture = cloneAndFlipTexture(material.microSurfaceTexture);
 }
-/// Returns undefined if texture is undefined.
-/// Returns original texture if it isn't of type "Texture".
-/// Otherwise, Clones and flips the texture along the y-axis by inverting vScale, vOffset and wAng.
+/**
+ * Returns undefined if texture is undefined.
+ * Returns original texture if it isn't of type "Texture".
+ * Otherwise, Clones and flips the texture along the y-axis by inverting vScale, vOffset and wAng.
+ */
 function cloneAndFlipTexture(texture) {
     if (texture instanceof Texture) {
         texture = texture.clone();

package/dist/material/material.js

@@ -58,7 +58,7 @@ function mtrlSourceUrlToCachedCfgMaterial(meta, renderEnvironment, mtrl) {
             if (getFileExtension(url) !== "gm") {
                 const texture = yield loadTextureFromURL(url, renderEnvironment);
                 innerMeta.sourcePath.push("image");
-                result.material = CfgMaterial.fromTexture(renderEnvironment, texture, innerMeta.sourcePath);
+                result.material = CfgMaterial.makeFromTexture(renderEnvironment, texture, innerMeta.sourcePath);
                 return result;
             }
             const multiGMaterial = yield loadMaterialFromUrl(innerMeta.logger, url, renderEnvironment.dexManager);
@@ -82,7 +82,7 @@ function bufferToCfgMaterial(renderEnvironment, meta, mtrl) {
             }
             meta.sourcePath.push("image");
             const texture = yield loadTextureFromURL(`data:image/${fileExtension};base64,${btoa(String.fromCharCode(...new Uint8Array(buffer)))}`, renderEnvironment);
-            return CfgMaterial.fromTexture(renderEnvironment, texture, meta.sourcePath);
+            return CfgMaterial.makeFromTexture(renderEnvironment, texture, meta.sourcePath);
         }
         const multiGMaterial = makeMaterialFromBuffer(meta.logger, mtrl.buffer, renderEnvironment.dexManager);
         meta.sourcePath.push("gm");
@@ -100,7 +100,7 @@ export function gMaterialToCfgMaterial(meta, renderEnvironment, gMaterial) {
             innerMeta.sourcePath.push("cache_gMaterial");
             innerMeta.gMaterial = gMaterial;
             const textures = yield getTextures(innerMeta.logger, renderEnvironment, gMaterial);
-            const material = CfgMaterial.compileFromGm(renderEnvironment, innerMeta, gMaterial, textures);
+            const material = CfgMaterial.makeFromGm(renderEnvironment, innerMeta, gMaterial, textures);
             return {
                 material: material,
                 meta: innerMeta,

package/dist/material/texture.js

@@ -116,12 +116,14 @@ export function loadTextureFromURL(url, renderEnvironment) {
         }, reject);
     });
 }
-/// Derives a normal map from a supplied height map. Both are used in CET for bump-maps but Babylon
-/// only supports normal maps.
-///
-/// The derived normal map and the effect from `scale` is carefully crafted to be as similar to how
-/// the RedSDK 3D renderer in CET operates and match it's final output. Do not change this code to
-/// make it visually "better", the goal is instead to be as similar as possible.
+/**
+ * Derives a normal map from a supplied height map (aka bump-map). Classic materials in CET can use
+ * both height maps and normal maps but Babylon.js only supports normal maps.
+ *
+ * The derived normal map and the effect from `scale` is carefully crafted to be as similar to how
+ * the RedSDK 3D renderer in CET operates and match it's final output. Do not change this code to
+ * make it visually "better", the goal is instead to be as similar as possible.
+ */
 function deriveNormalMapFromHeightMap(image, amount, logger) {
     const w = image.width;
     const h = image.height;
@@ -136,7 +138,7 @@ function deriveNormalMapFromHeightMap(image, amount, logger) {
         const data = imgData.data;
         // The scale conversion and default value comes from the CET source code.
         const scale = amount ? 15 * amount : 0.1;
-        /// Number of components, canvas returns RGBA
+        // Number of components, canvas returns RGBA
         const c = 4;
         // Go through the image and calculate a gray scale version, storing it in the A channel.
         // Since this is legacy support code, we might as well support non-gray scale height maps,
@@ -186,7 +188,7 @@ function deriveNormalMapFromHeightMap(image, amount, logger) {
         context.putImageData(imgData, 0, 0);
         const convertedImage = new Image();
         convertedImage.src = canvas.toDataURL("image/png");
-        logger.info(`Converting height based bump map`, `of size ${w}x${h} took ${Math.round(performance.now() - tick)}ms. For optimal performance, update all materials to use normal maps rather than height maps.`);
+        logger.info(`Converting height based bump map`, `of size ${w}x${h} took ${Math.round(performance.now() - tick)}ms. For optimal performance, update all classic materials to use normal maps rather than height maps or switch to PBR materials.`);
         return convertedImage;
     }
     return image;

package/dist/nodes/CfgDeferredMeshNode.d.ts

@@ -6,17 +6,22 @@ import { DetailLevel, DetailMask } from "@configura/web-core/dist/cm/geometry/De
 import { Logger, LogObservable, LogProducer } from "@configura/web-utilities";
 import { AnimatableObject } from "../animation/AnimatableObject.js";
 import { CoordinatorWithMeta } from "../animation/coordinator/Coordinator.js";
+import { CfgMesh } from "../geometry/CfgMesh.js";
+import { CfgStretchData } from "../geometry/stretch/CfgStretchData.js";
 import { MaterialMetaData } from "../material/material.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 CfgDeferredMeshNode extends CfgTransformNode implements LogProducer, AnimatableObject {
+    readonly cfgProductNodeParent: CfgProductNode;
     lod: DetailMask;
     private _gMaterial;
     private _meshDoubleSided;
     private _lowerLeftTextureOrigin;
     private _geo;
-    static makeCfgDeferredMesh(logger: Logger, renderEnvironment: RenderEnv, detailLevel: DetailLevel, symNode: SymNode, gMaterial: SymGMaterial | undefined): Promise<CfgDeferredMeshNode | undefined>;
+    private _stretchDatas;
+    static makeCfgDeferredMesh(logger: Logger, renderEnvironment: RenderEnv, cfgProductNodeParent: CfgProductNode, detailLevel: DetailLevel, symNode: SymNode, gMaterial: SymGMaterial | undefined, stretchDatas: CfgStretchData[]): Promise<CfgDeferredMeshNode | undefined>;
     get cfgClassName(): string;
     private _material;
     private _dummyMaterial;
@@ -36,6 +41,8 @@ export declare class CfgDeferredMeshNode extends CfgTransformNode implements Log
     isAllMeshMaterialsReady: () => boolean;
     startSplitGeo: (force?: boolean) => Promise<void>;
     get boundingBox(): CfgBoundingBox;
+    getChildCfgMeshes(): CfgMesh[];
+    refreshStretch(): void;
     protected addInspectorProperties(): void;
     private get _inspectorLodLevels();
     private get _inspectorSourcePath();

package/dist/nodes/CfgDeferredMeshNode.js

@@ -13,6 +13,7 @@ import { logMtrlSourceWithMetaDataToConsole } from "@configura/web-api";
 import { SymBox } from "@configura/web-core/dist/cm/format/cmsym/components/SymBox.js";
 import { SymGfxMode } from "@configura/web-core/dist/cm/format/cmsym/components/SymComponent.js";
 import { SymMesh } from "@configura/web-core/dist/cm/format/cmsym/components/SymMesh.js";
+import { SymPlane } from "@configura/web-core/dist/cm/format/cmsym/components/SymPlane.js";
 import { SymReps } from "@configura/web-core/dist/cm/format/cmsym/components/SymReps.js";
 import { SymSphere } from "@configura/web-core/dist/cm/format/cmsym/components/SymSphere.js";
 import { DetailMask } from "@configura/web-core/dist/cm/geometry/DetailMask.js";
@@ -20,9 +21,10 @@ import { LogObservable } from "@configura/web-utilities";
 import { CfgGeometry } from "../geometry/CfgGeometry.js";
 import { CfgMesh } from "../geometry/CfgMesh.js";
 import { splitIndexComplete, splitIndexQuick } from "../geometry/geoSplitter.js";
+import { toStretchedPoint } from "../geometry/stretch/CfgStretchData.js";
 import { gMaterialToCfgMaterial, mtrlSourceToCfgMaterial, } from "../material/material.js";
 import { CfgBoundingBox } from "../utilities/CfgBoundingBox.js";
-import { aTriMeshBox, aTriMeshSphere } from "../utilities/utilities3D.js";
+import { aTriMeshBox, aTriMeshPlane, aTriMeshSphere } from "../utilities/utilities3D.js";
 import { GeometryCacheEntry } from "../view/RenderEnv.js";
 import { CfgTransformNode } from "./CfgTransformNode.js";
 const QUICK_SPLIT_INDEX_SIZE_LIMIT = 20000;
@@ -50,9 +52,15 @@ function getDetailMask(symNode) {
     }
     return lod;
 }
-function symComponentToGeometry(logger, renderEnvironment, component) {
+function symComponentToGeometry(logger, renderEnvironment, component, stretchDatas, uvMapper) {
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
-        return renderEnvironment.geometryCache.get(component, () => __awaiter(this, void 0, void 0, function* () {
+        const identifierObject = {
+            component,
+            stretchDatasHash: stretchDatas.reduce((acc, stretchData) => acc + stretchData.hash, 0),
+            uvMapperHash: (_a = uvMapper === null || uvMapper === void 0 ? void 0 : uvMapper.env) === null || _a === void 0 ? void 0 : _a.hash,
+        };
+        return renderEnvironment.geometryCache.get(identifierObject, () => __awaiter(this, void 0, void 0, function* () {
             let mesh = undefined;
             if (component instanceof SymMesh) {
                 mesh = component.mesh(logger, renderEnvironment.symMeshEnv);
@@ -63,22 +71,27 @@ function symComponentToGeometry(logger, renderEnvironment, component) {
             else if (component instanceof SymBox) {
                 mesh = aTriMeshBox(component.p0, component.p1);
             }
+            else if (component instanceof SymPlane) {
+                mesh = aTriMeshPlane(component.vector, component.distance, 1);
+            }
             if (mesh === undefined) {
                 logger.error("SymComponent did not return a mesh", component);
                 return undefined;
             }
-            return new GeometryCacheEntry(new CfgGeometry("(Geo) " + component.id, mesh, renderEnvironment.scene), mesh.doubleSided, mesh.lowerLeftTextureOrigin);
+            return new GeometryCacheEntry(CfgGeometry.fromATriMeshF(logger, "(Geo) " + component.id, mesh, renderEnvironment.scene, stretchDatas, uvMapper), mesh.doubleSided, mesh.lowerLeftTextureOrigin);
         }));
     });
 }
 export class CfgDeferredMeshNode extends CfgTransformNode {
-    constructor(renderEnvironment, name, lod, _gMaterial, _meshDoubleSided, _lowerLeftTextureOrigin, _geo) {
+    constructor(renderEnvironment, cfgProductNodeParent, name, lod, _gMaterial, _meshDoubleSided, _lowerLeftTextureOrigin, _geo, _stretchDatas) {
         super(renderEnvironment, name);
+        this.cfgProductNodeParent = cfgProductNodeParent;
         this.lod = lod;
         this._gMaterial = _gMaterial;
         this._meshDoubleSided = _meshDoubleSided;
         this._lowerLeftTextureOrigin = _lowerLeftTextureOrigin;
         this._geo = _geo;
+        this._stretchDatas = _stretchDatas;
         this._materialIsDirty = false;
         this._mtrlSourceWithMetaData = null;
         this._splitGeoStatus = SplitGeoStatus.Idle;
@@ -127,7 +140,7 @@ export class CfgDeferredMeshNode extends CfgTransformNode {
             const material = this._material.getPBRMaterial(doubleSided, backToFront, flipTexture);
             this.clear(true);
             for (const geo of geos) {
-                const mesh = new CfgMesh(labelSuffix, this._renderEnvironment, geo, material);
+                const mesh = new CfgMesh(labelSuffix, this._renderEnvironment, this.cfgProductNodeParent, geo, material);
                 this.add(mesh);
             }
         };
@@ -147,9 +160,11 @@ export class CfgDeferredMeshNode extends CfgTransformNode {
             let groups;
             if (doCompleteSplit) {
                 groups = splitIndexComplete(this.logger, geo, {
-                    maxFinalGroups: force ? Number.MAX_VALUE : COMPLETE_SPLIT_FINAL_GROUPS_COUNT_LIMIT,
+                    maxFinalGroups: force
+                        ? Number.POSITIVE_INFINITY
+                        : COMPLETE_SPLIT_FINAL_GROUPS_COUNT_LIMIT,
                     maxProgressGroups: force
-                        ? Number.MAX_VALUE
+                        ? Number.POSITIVE_INFINITY
                         : COMPLETE_SPLIT_PROGRESS_GROUPS_COUNT_LIMIT,
                     acceptCoordinateMatch: true,
                 });
@@ -175,22 +190,26 @@ export class CfgDeferredMeshNode extends CfgTransformNode {
         this._dummyMaterial = renderEnvironment.dummyMaterial;
         this.resetMaterial();
     }
-    static makeCfgDeferredMesh(logger, renderEnvironment, detailLevel, symNode, gMaterial) {
-        var _a, _b;
+    static makeCfgDeferredMesh(logger, renderEnvironment, cfgProductNodeParent, detailLevel, symNode, gMaterial, stretchDatas) {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const lod = getDetailMask(symNode);
             if (lod === undefined || !lod.includes(detailLevel)) {
                 return;
             }
-            const component = (_b = (_a = symNode.symMesh()) !== null && _a !== void 0 ? _a : symNode.symSphere()) !== null && _b !== void 0 ? _b : symNode.symBox();
+            const component = (_c = (_b = (_a = symNode.symMesh()) !== null && _a !== void 0 ? _a : symNode.symSphere()) !== null && _b !== void 0 ? _b : symNode.symBox()) !== null && _c !== void 0 ? _c : symNode.symPlane();
             if (component === undefined) {
                 return;
             }
-            const entry = yield symComponentToGeometry(logger, renderEnvironment, component);
-            if ((entry === null || entry === void 0 ? void 0 : entry.geometry) === undefined) {
+            const entry = yield symComponentToGeometry(logger, renderEnvironment, component, stretchDatas, symNode.symUVMapper(true).mapper);
+            if (entry === undefined) {
+                return undefined;
+            }
+            let geo = entry.geometry;
+            if (geo === undefined) {
                 return undefined;
             }
-            return new CfgDeferredMeshNode(renderEnvironment, "(Deferred Mesh) " + symNode.id, lod, gMaterial, entry.doubleSided, entry.lowerLeftTextureOrigin, entry.geometry);
+            return new this(renderEnvironment, cfgProductNodeParent, "(Deferred Mesh) " + symNode.id, lod, gMaterial, entry.doubleSided, entry.lowerLeftTextureOrigin, geo, stretchDatas);
         });
     }
     get cfgClassName() {
@@ -265,15 +284,26 @@ export class CfgDeferredMeshNode extends CfgTransformNode {
         });
     }
     get boundingBox() {
+        const stretchDatas = this._stretchDatas;
+        const stretchReferenceLengthsByMeasureParamCode = this.cfgProductNodeParent.product.configuration._internal
+            .stretchReferenceLengthsByMeasureParamCode;
         return this.getChildMeshes().reduce((a, m) => {
             const bb = m.getBoundingInfo().boundingBox;
-            // Here we strip away the world matrix as we handle the transforms
-            // manually, and the world matrix changes depending on if the has
-            // been rendered to screen yet
-            a.expand(new CfgBoundingBox(bb.minimum, bb.maximum));
+            const cfgBb = new CfgBoundingBox(bb.minimum, bb.maximum);
+            cfgBb.corners
+                .map((c) => toStretchedPoint(c, stretchDatas, stretchReferenceLengthsByMeasureParamCode))
+                .forEach((c) => {
+                a.expandWithPoint(c);
+            });
             return a;
         }, new CfgBoundingBox());
     }
+    getChildCfgMeshes() {
+        return this.getChildMeshes().filter((f) => f instanceof CfgMesh);
+    }
+    refreshStretch() {
+        this.getChildCfgMeshes().map((childMesh) => childMesh.refreshStretch());
+    }
     addInspectorProperties() {
         super.addInspectorProperties();
         this.addInspectableCustomProperty({

package/dist/nodes/CfgProductNode.d.ts

@@ -3,47 +3,112 @@ import { CfgMaterialMapping, CfgMtrlApplication, CfgProduct } from "@configura/w
 import { LogObservable, LogProducer } from "@configura/web-utilities";
 import { AnimatableObject } from "../animation/AnimatableObject.js";
 import { CoordinatorWithMeta } from "../animation/coordinator/Coordinator.js";
+import { CfgAnchorableNode, CfgAnchorRef, CfgAnchorTargetNode } from "../utilities/anchor/anchor.js";
 import { CfgBoundingBox } from "../utilities/CfgBoundingBox.js";
 import { RenderEnv } from "../view/RenderEnv.js";
 import { CfgSymRootNode } from "./CfgSymRootNode.js";
 import { CfgTransformNode } from "./CfgTransformNode.js";
 export declare function isProductNode(value: unknown): value is CfgProductNode;
 export declare function isCfgSymRootNode(value: unknown): value is CfgSymRootNode;
+export declare function isCfgAnchorableNode(value: unknown): value is CfgAnchorableNode;
 export declare class CfgProductNode extends CfgTransformNode implements AnimatableObject, LogProducer {
     private readonly _product;
     static make(renderEnvironment: RenderEnv, product: CfgProduct): CfgProductNode;
-    logger: LogObservable;
+    readonly logger: LogObservable;
     private _destroyed;
     readonly key: string;
     _applicationAreas: CfgMtrlApplication[];
     private _mtrlApplications;
     private _configuration;
-    private _debugMtrlApplications;
+    private readonly _debugMtrlApplications;
     _areasToMaterials: CfgMaterialMapping | undefined;
     _scheduledForRemoval: (CfgSymRootNode | CfgProductNode)[];
+    private _anchoredToAnchors;
     private _symRootLoadings;
+    private _modelMatrix;
+    private _originalMatrixWithModelTransform;
+    private _anchorTarget;
+    private _stretchedAnchorPointMatrix;
+    readonly anchorRef: CfgAnchorRef | undefined;
     private constructor();
     get cfgClassName(): string;
     destroy(): void;
     get product(): CfgProduct;
+    /**
+     * We want to be able to animate nodes that are on the way out.
+     * So we do not immediately remove them from the tree.
+     */
     private scheduleForRemoval;
     isDestroyed(): boolean;
+    /**
+     * The passed function is recursively applied on every descendant CfgProductNode in the tree.
+     * This node is included. Destroyed products are not included.
+     */
     _applyOnDescendantProductNodes: <T>(fn: (p: CfgProductNode) => T) => T[];
+    /**
+     * 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.
+     */
     private _syncAdditionalProductNodes;
+    /**
+     * Application areas are essentially catalogue level material mappings.
+     * This function is recursively applied on additional products.
+     */
     setApplicationAreas(applicationAreas: CfgMtrlApplication[]): void;
+    /**
+     * Start loading the geometry, but do not yet show it.
+     * This function is recursively applied on additional products.
+     */
     loadGeo(coordinatorWithMeta?: CoordinatorWithMeta): Promise<void>;
     private _loadAdditionalProducts;
+    /**
+     * Run any animations and then permanently removes the nodes from the tree
+     * This function is recursively applied on additional products.
+     */
     flushScheduledForRemove(animationCoordinator?: CoordinatorWithMeta): Promise<void>;
+    /**
+     * Are all materials currently needed loaded and ready to be applied?
+     * This function does not take additional products into account.
+     */
     private _isAllMeshMaterialsReady;
+    /**
+     * Resolves when all materials currently needed have been loaded and are ready to be applied.
+     * This function does not take additional products into account.
+     */
     private _awaitAllMeshMaterialsReady;
+    /**
+     * Loads the materials needed.
+     * This function is recursively applied on additional products.
+     */
     loadMaterials(animationCoordinator?: CoordinatorWithMeta): Promise<void>;
+    /**
+     * Update the tag (area) to material mapping and gives them to sym children
+     * This function does not take additional products into account.
+     */
     private _aggregateMaterialsPushToChildrenAndLoad;
+    /**
+     * Starts loading the materials on the sym children (but does not apply)
+     * This function does not take additional products into account.
+     */
     private _pushMaterialToSymRootChildrenAndLoad;
     private _getSymRootChildren;
     private _getAdditionalProductNodes;
+    private _getAnchorableNodes;
+    /**
+     * Applies and thereby shows the geometry. Finally flushes scheduled for remove.
+     * This function is recursively applied on additional products.
+     */
     applyGeo(animationCoordinator?: CoordinatorWithMeta): Promise<void>;
+    /**
+     * Applies and thereby shows the right materials.
+     * This function is recursively applied on additional products.
+     */
     applyMaterials(): Promise<void>;
-    readonly originalMatrix: Matrix;
+    setAnchorTarget(anchorTarget: CfgAnchorTargetNode | undefined): void;
+    refreshStretch(): void;
+    get originalMatrix(): Matrix;
+    protected initTransform(): void;
     _applyDebugSymRoots(symRootPromises: Promise<CfgSymRootNode | undefined>[]): Promise<void>;
     _addDebugMtrlApplication(debugMtrlApplication: CfgMtrlApplication): Promise<void>;
     get boundingBox(): CfgBoundingBox;