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

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;