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

package/dist/animation/coordinator/CoordinatorDropAndSpin.js

@@ -36,7 +36,7 @@ export class CoordinatorDropAndSpin extends CoordinatorNodeQueues {
     }
     static getCoordinatorCreator(config) {
         return (view, phaseObservable) => {
-            return new CoordinatorDropAndSpin(view, phaseObservable, config || {});
+            return new this(view, phaseObservable, config || {});
         };
     }
     destroy() {

package/dist/animation/coordinator/CoordinatorPulseBounce.js

@@ -15,7 +15,7 @@ const defaultConfig = Object.assign(Object.assign({}, baseDefaultConfig), { heig
 export class CoordinatorPulseBounce extends CoordinatorPulse {
     static getCoordinatorCreator(config) {
         return (view, phaseObservable) => {
-            return new CoordinatorPulseBounce(view, phaseObservable, config || {});
+            return new this(view, phaseObservable, config || {});
         };
     }
     constructor(view, phaseObservable, config) {

package/dist/animation/coordinator/CoordinatorPulseHighlight.js

@@ -14,7 +14,7 @@ const defaultConfig = Object.assign(Object.assign({}, baseDefaultConfig), animat
 export class CoordinatorPulseHighlight extends CoordinatorPulse {
     static getCoordinatorCreator(config) {
         return (view, phaseObservable) => {
-            return new CoordinatorPulseHighlight(view, phaseObservable, config || {});
+            return new this(view, phaseObservable, config || {});
         };
     }
     constructor(view, phaseObservable, config) {

package/dist/animation/coordinator/CoordinatorPulseInflate.js

@@ -14,7 +14,7 @@ const defaultConfig = Object.assign(Object.assign({}, baseDefaultConfig), { size
 export class CoordinatorPulseInflate extends CoordinatorPulse {
     static getCoordinatorCreator(config) {
         return (view, phaseObservable) => {
-            return new CoordinatorPulseInflate(view, phaseObservable, config || {});
+            return new this(view, phaseObservable, config || {});
         };
     }
     constructor(view, phaseObservable, config) {

package/dist/camera/CfgArcRotateCameraPointersInput.d.ts

@@ -1,5 +1,21 @@
 import { ArcRotateCameraPointersInput } from "@babylonjs/core/Cameras/Inputs/arcRotateCameraPointersInput.js";
 import "@babylonjs/core/Engines/Extensions/engine.webVR.js";
+/**
+ * This class exists to workaround a severe touch input issue that exists on at least iOS 13.4 in
+ * Babylon release 4.1.0 and possibly later.
+ *
+ * The main workaround is marked with "--- START OF WORKAROUND ---" in the source below.
+ *
+ * Most of the code below is copied from the Babylon source class BaseCameraPointersInput.ts,
+ * which ArcRotateCameraPointersInput extends. Some additional private support code from
+ * BaseCameraPointersInput is also included and suffixed with "CfgPatch".
+ *
+ * @warning: DO NOT do any other changes to this file! They WILL be lost when this workaround is no
+ * longer needed.
+ *
+ * @todo Every time the babylon module is updated to a new release, test if the workaround is still
+ * needed. If not, simply remove this file and update CfgOrbitalCamera.ts to not use it.
+ */
 export declare class CfgArcRotateCameraPointersInput extends ArcRotateCameraPointersInput {
     attachControl(noPreventDefault?: boolean): void;
     detachControl(ignored?: any): void;

package/dist/camera/CfgArcRotateCameraPointersInput.js

@@ -1,21 +1,23 @@
-/// This class exists to workaround a severe touch input issue that exists on at least iOS 13.4 in
-/// Babylon release 4.1.0 and possibly later.
-///
-/// The main workaround is marked with "--- START OF WORKAROUND ---" in the source below.
-///
-/// Most of the code below is copied from the Babylon source class BaseCameraPointersInput.ts,
-/// which ArcRotateCameraPointersInput extends. Some additional private support code from
-/// BaseCameraPointersInput is also included and suffixed with "CfgPatch".
-///
-/// WARNING: DO NOT do any other changes to this file! They WILL be lost when this workaround is no
-/// longer needed.
-///
-/// TODO: Every time the babylon module is updated to a new release, test if the workaround is still
-/// needed. If not, simply remove this file and update CfgOrbitalCamera.ts to not use it.
 import { ArcRotateCameraPointersInput } from "@babylonjs/core/Cameras/Inputs/arcRotateCameraPointersInput.js";
 import "@babylonjs/core/Engines/Extensions/engine.webVR.js"; // isInVRExclusivePointerMode
-import { PointerEventTypes } from "@babylonjs/core/Events/pointerEvents.js";
+import { PointerEventTypes, } from "@babylonjs/core/Events/pointerEvents.js";
 import { Tools } from "@babylonjs/core/Misc/tools.js";
+/**
+ * This class exists to workaround a severe touch input issue that exists on at least iOS 13.4 in
+ * Babylon release 4.1.0 and possibly later.
+ *
+ * The main workaround is marked with "--- START OF WORKAROUND ---" in the source below.
+ *
+ * Most of the code below is copied from the Babylon source class BaseCameraPointersInput.ts,
+ * which ArcRotateCameraPointersInput extends. Some additional private support code from
+ * BaseCameraPointersInput is also included and suffixed with "CfgPatch".
+ *
+ * @warning: DO NOT do any other changes to this file! They WILL be lost when this workaround is no
+ * longer needed.
+ *
+ * @todo Every time the babylon module is updated to a new release, test if the workaround is still
+ * needed. If not, simply remove this file and update CfgOrbitalCamera.ts to not use it.
+ */
 export class CfgArcRotateCameraPointersInput extends ArcRotateCameraPointersInput {
     constructor() {
         super(...arguments);

package/dist/camera/CfgOrbitalCamera.d.ts

@@ -41,7 +41,11 @@ export declare class CfgOrbitalCamera extends WorkaroundCfgOrbitalCamera {
     private _currentMinDistanceToFitModelInView;
     private _orbitalCameraControlObservable;
     private _previousOrbitalCameraControlProps;
-    disableSubFloorCam: boolean;
+    _disableSubFloorCam: boolean;
+    set disableSubFloorCam(v: boolean);
+    _lowestAllowedCameraHeight: number | undefined;
+    set lowestAllowedCameraHeight(v: number | undefined);
+    get lowestAllowedCameraHeight(): number | undefined;
     disableAutomaticSizing: boolean;
     disableZoom: boolean;
     private _externalControlHasHappened;

package/dist/camera/CfgOrbitalCamera.js

@@ -29,7 +29,8 @@ export class CfgOrbitalCamera extends WorkaroundCfgOrbitalCamera {
         this._canvas = _canvas;
         this._currentBoundingBox = new CfgBoundingBox();
         this._latestSignificantChangeBoundingBox = new CfgBoundingBox();
-        this.disableSubFloorCam = false;
+        this._disableSubFloorCam = false;
+        this._lowestAllowedCameraHeight = undefined;
         this.disableAutomaticSizing = false;
         this.disableZoom = false;
         this._externalControlHasHappened = false;
@@ -64,6 +65,24 @@ export class CfgOrbitalCamera extends WorkaroundCfgOrbitalCamera {
         this.onViewMatrixChangedObservable.removeCallback(this._boundNotifyCameraControlListeners);
         super.dispose();
     }
+    set disableSubFloorCam(v) {
+        this._disableSubFloorCam = v;
+    }
+    set lowestAllowedCameraHeight(v) {
+        this._lowestAllowedCameraHeight = v;
+    }
+    get lowestAllowedCameraHeight() {
+        if (this._lowestAllowedCameraHeight !== undefined) {
+            if (this._disableSubFloorCam) {
+                return Math.max(0, this._lowestAllowedCameraHeight);
+            }
+            return this._lowestAllowedCameraHeight;
+        }
+        if (this._disableSubFloorCam) {
+            return 0;
+        }
+        return undefined;
+    }
     forceRadius(r) {
         this._radius = r;
     }
@@ -188,10 +207,6 @@ export class CfgOrbitalCamera extends WorkaroundCfgOrbitalCamera {
         this.maxZ = cameraDistance + graceDistance;
     }
     _applyNoSneakPeeking() {
-        if (!this.disableSubFloorCam) {
-            this.upperBetaLimit = MAX_UPPER_BETA_LIMIT;
-            return;
-        }
         //It might be impolite to look at a Cfg models underside
         const noPeekLimit = this._calculateNoPeekingLimit();
         if (noPeekLimit === undefined || !isFinite(noPeekLimit)) {
@@ -222,10 +237,12 @@ export class CfgOrbitalCamera extends WorkaroundCfgOrbitalCamera {
     }
     _calculateNoPeekingLimit() {
         const bb = this._currentBoundingBox;
-        if (bb.isEmpty) {
+        if (bb.isEmpty || this.lowestAllowedCameraHeight === undefined) {
             return undefined;
         }
-        const bottomDepth = bb.minimum.y - this.target.y;
+        const bottomDepth = bb.minimum.y -
+            this.target.y +
+            (bb.maximum.y - bb.minimum.y) * this.lowestAllowedCameraHeight;
         const cameraDistance = this.radius;
         const lowestAngleUnderHorizonRad = Math.asin(bottomDepth / cameraDistance);
         return lowestAngleUnderHorizonRad;

package/dist/engine/EngineCreator.js

@@ -4,7 +4,7 @@ export function getDefaultEngine(canvas, width, height) {
     // see WEB-8493 for additional details. It should be safe to apply to all browsers.
     //
     // TODO: Remove this workaround when upgrading to Babylon.js 5.0
-    const engine = new Engine(canvas, true, { xrCompatible: false }, true);
+    const engine = new Engine(canvas, true, { xrCompatible: false, preserveDrawingBuffer: true }, true);
     engine.setSize(Math.floor(width), Math.floor(height));
     return engine;
 }

package/dist/geometry/CfgGeometry.d.ts

@@ -1,13 +1,30 @@
 import { Geometry } from "@babylonjs/core/Meshes/geometry.js";
-import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
 import { Scene } from "@babylonjs/core/scene.js";
 import { ATriMeshF } from "@configura/web-core/dist/cm/core3D/ATriMeshF.js";
-import { LogObservable, LogProducer } from "@configura/web-utilities";
+import { UVMapper } from "@configura/web-core/dist/cm/core3D/uvmapper/UVMapper";
+import { Logger, LogObservable, LogProducer } from "@configura/web-utilities";
+import { CfgStretchData } from "./stretch/CfgStretchData.js";
+import { CfgMorphTwiceStretchedGeometry } from "./stretch/CfgStretchMorphGeometry.js";
+export declare function makeIndexMap(indices: Uint32Array | number[]): {
+    indexMap: Map<number, number>;
+    packedIndices: Uint32Array;
+};
 export declare class CfgGeometry extends Geometry implements LogProducer {
-    private _aTriMesh;
+    private readonly _ind;
+    private readonly _pos;
+    private readonly _uvs;
+    private readonly _nor;
+    private readonly _tan;
+    private readonly _col;
+    readonly morphGeometries: CfgMorphTwiceStretchedGeometry[];
     logger: LogObservable;
-    constructor(id: string, mesh: ATriMeshF, scene: Scene, indices?: Uint32Array | number[]);
+    static fromATriMeshF(logger: Logger, id: string, mesh: ATriMeshF, scene: Scene, stretchDatas: CfgStretchData[], uvMapper: UVMapper | undefined): CfgGeometry;
+    private constructor();
+    shallowClone(): CfgGeometry;
+    /**
+     * Returns a new CfgGeometry containing a subset of this CfgGeometry based on the given
+     * indices.
+     */
     cloneWithSubset(indices: Uint32Array | number[]): CfgGeometry;
-    releaseForMesh(mesh: Mesh, shouldDispose?: boolean | undefined): void;
 }
 //# sourceMappingURL=CfgGeometry.d.ts.map

package/dist/geometry/CfgGeometry.js

@@ -1,117 +1,146 @@
 import { Geometry } from "@babylonjs/core/Meshes/geometry.js";
 import { VertexData } from "@babylonjs/core/Meshes/mesh.vertexData.js";
 import { LogObservable } from "@configura/web-utilities";
+import { CfgMorphTwiceStretchedGeometry } from "./stretch/CfgStretchMorphGeometry.js";
+export function makeIndexMap(indices) {
+    // Loop through all old index values, creating an index map between each unique old
+    // index value and their corresponding new index into the shorter arrays.
+    const indicesLength = indices.length;
+    const packedIndices = new Uint32Array(indicesLength);
+    const indexMap = new Map();
+    for (let i = 0; i < indicesLength; i++) {
+        const index = indices[i];
+        let newIndex = indexMap.get(index);
+        if (newIndex === undefined) {
+            newIndex = indexMap.size;
+            indexMap.set(index, newIndex);
+        }
+        packedIndices[i] = newIndex;
+    }
+    return { indexMap, packedIndices };
+}
 export class CfgGeometry extends Geometry {
-    constructor(id, mesh, scene, indices) {
+    constructor(id, scene, _ind, _pos, _uvs, _nor, _tan, _col, morphGeometries) {
         super(id, scene);
+        this._ind = _ind;
+        this._pos = _pos;
+        this._uvs = _uvs;
+        this._nor = _nor;
+        this._tan = _tan;
+        this._col = _col;
+        this.morphGeometries = morphGeometries;
         this.logger = new LogObservable();
-        // Hold on to the ATriMeshF if we need to split the geometry later. It should be faster to
-        // do it from the original data than to extract it again from the Geometry object and the
-        // ATriMeshF seems to be kept around anyway in it's SymMesh. This is however something
-        // that we should try to optimize further.
-        this._aTriMesh = mesh;
-        const hasUVs = mesh.uvs.length > 0;
-        const hasNor = mesh.normals.length > 0;
-        const hasCol = mesh.colors.length > 0;
-        const hasTan = mesh.tangents.length > 0;
-        let ind;
-        let pos;
+        const vertexData = new VertexData();
+        vertexData.indices = _ind;
+        vertexData.positions = _pos;
+        vertexData.uvs = _uvs;
+        vertexData.normals = _nor;
+        vertexData.tangents = _tan;
+        vertexData.colors = _col;
+        this.setAllVerticesData(vertexData, false);
+    }
+    static fromATriMeshF(logger, id, mesh, scene, stretchDatas, uvMapper) {
+        const positions = mesh.vertices;
+        const normals = 0 < mesh.normals.length ? mesh.normals : undefined;
+        const meshUvs = mesh.uvs;
         let uvs;
-        let nor;
-        let tan;
-        let col;
-        if (indices === undefined) {
-            ind = mesh.indices;
-            pos = mesh.vertices;
-            uvs = hasUVs ? mesh.uvs : null;
-            nor = hasNor ? mesh.normals : null;
-            tan = hasTan ? mesh.tangents : null;
-            col = hasCol ? mesh.colors : null;
+        if (meshUvs.length > 0) {
+            // Always use pre-baked UVs from CET if they exist.
+            // See comment on UVMapper.createUVCoordinates for more details.
+            uvs = meshUvs;
         }
-        else {
-            const num = indices.length;
-            // Babylon will use all vertex positions in the Geometry (not only the ones referenced
-            // by the indices) to determine the bounding box. As such, we need to go through the
-            // the new subset of indices and only keep the references values in each attribute.
-            // Loop through all old index values, creating an index map between each unique old
-            // index value and their corresponding new index into the shorter arrays.
-            const newIndices = new Uint32Array(num);
-            const indexMap = new Map();
-            for (let i = 0; i < num; i++) {
-                const index = indices[i];
-                let newIndex = indexMap.get(index);
-                if (newIndex === undefined) {
-                    newIndex = indexMap.size;
-                    indexMap.set(index, newIndex);
-                }
-                newIndices[i] = newIndex;
-            }
-            ind = newIndices;
-            // The length of the indexMap tells us how many unique index value we found.
-            const count = indexMap.size;
-            console.log(`Creating CfgGeometry subset (${num / 3}/${mesh.indices.length / 3} triangles, ${count} unique indices)`);
-            pos = new Float32Array(count * 3);
-            uvs = hasUVs ? new Float32Array(count * 2) : null;
-            nor = hasNor ? new Float32Array(count * 3) : null;
-            tan = hasTan ? new Float32Array(count * 4) : null;
-            col = hasCol ? new Float32Array(count * 4) : null;
-            // Use the index map to move only the referenced used values from all the attributes
-            // over to new smaller arrays.
-            //
-            // A note about the code: The code below is "unrolled" by design since it can be a lot
-            // of indexes to process. A more compact version with an inner loop of 0..3 with some
-            // additional if checks turned out to be up to 30 times slower in Chrome (1.5ms vs
-            // 40ms) for the "repack" call when loading and splitting the forklift model.
-            for (const [index, newIndex] of indexMap) {
-                pos[newIndex * 3] = mesh.vertices[index * 3];
-                pos[newIndex * 3 + 1] = mesh.vertices[index * 3 + 1];
-                pos[newIndex * 3 + 2] = mesh.vertices[index * 3 + 2];
-                if (uvs) {
-                    uvs[newIndex * 2] = mesh.uvs[index * 2];
-                    uvs[newIndex * 2 + 1] = mesh.uvs[index * 2 + 1];
-                }
-                if (nor) {
-                    nor[newIndex * 3] = mesh.normals[index * 3];
-                    nor[newIndex * 3 + 1] = mesh.normals[index * 3 + 1];
-                    nor[newIndex * 3 + 2] = mesh.normals[index * 3 + 2];
-                }
-                if (tan) {
-                    tan[newIndex * 4] = mesh.tangents[index * 4];
-                    tan[newIndex * 4 + 1] = mesh.tangents[index * 4 + 1];
-                    tan[newIndex * 4 + 2] = mesh.tangents[index * 4 + 2];
-                    tan[newIndex * 4 + 3] = mesh.tangents[index * 4 + 3];
-                }
-                if (col) {
-                    col[newIndex * 4] = mesh.colors[index * 4];
-                    col[newIndex * 4 + 1] = mesh.colors[index * 4 + 1];
-                    col[newIndex * 4 + 2] = mesh.colors[index * 4 + 2];
-                    col[newIndex * 4 + 3] = mesh.colors[index * 4 + 3];
-                }
+        else if (uvMapper !== undefined && normals !== undefined) {
+            const min = [
+                Number.POSITIVE_INFINITY,
+                Number.POSITIVE_INFINITY,
+                Number.POSITIVE_INFINITY,
+            ];
+            const max = [
+                Number.NEGATIVE_INFINITY,
+                Number.NEGATIVE_INFINITY,
+                Number.NEGATIVE_INFINITY,
+            ];
+            // Calculate the bounds for each axis based on vertex positions
+            let p = 0;
+            let axis = 0;
+            for (let i = 0; i < positions.length; i++) {
+                p = positions[i];
+                axis = i % 3; // x, y, z
+                min[axis] = Math.min(min[axis], p);
+                max[axis] = Math.max(max[axis], p);
             }
+            const size = max.map((m, axis) => m - min[axis]);
+            uvs = uvMapper.createUVCoordinates(logger, positions, {
+                min,
+                max,
+                size,
+            }, normals);
         }
-        const vertexData = new VertexData();
-        vertexData.indices = ind;
-        vertexData.positions = pos;
-        vertexData.uvs = uvs;
-        vertexData.normals = nor;
-        vertexData.tangents = tan;
-        vertexData.colors = col;
-        this.setAllVerticesData(vertexData, false);
+        else if (uvMapper !== undefined) {
+            logger.warn("Mesh uses UV-mapper without mesh normals which is not supported");
+        }
+        return new this(id, scene, mesh.indices, positions, uvs !== undefined && uvs.length > 0 ? uvs : null, normals || null, mesh.tangents.length > 0 ? mesh.tangents : null, mesh.colors.length > 0 ? mesh.colors : null, stretchDatas.map((stretchData) => CfgMorphTwiceStretchedGeometry.make(logger, uvMapper, stretchData, positions, normals, uvs)));
     }
-    /// Returns a new CfgGeometry containing a subset of this CfgGeometry based on the given indices
-    cloneWithSubset(indices) {
-        return new CfgGeometry(this.id + ` (subset ${indices.length})`, this._aTriMesh, this.getScene(), indices);
+    shallowClone() {
+        return new CfgGeometry(this.id, this.getScene(), this._ind, this._pos, this._uvs, this._nor, this._tan, this._col, this.morphGeometries);
     }
-    /* This is a hack to prevent this Geometry subclass to get automatically disposed
-     * when the last associated mesh is disposed, for example when changing options back and
-     * forth.
-     *
-     * IIRC we are using a geometry cache which is probably holding on firmly to this instance
-     * and reusing it for the next time we need the same mesh. If that cache is ever cleared,
-     * it should also dispose the geometry inside it.
-     *
+    /**
+     * Returns a new CfgGeometry containing a subset of this CfgGeometry based on the given
+     * indices.
      */
-    releaseForMesh(mesh, shouldDispose) {
-        super.releaseForMesh(mesh, false);
+    cloneWithSubset(indices) {
+        const thisInd = this._ind;
+        const thisPos = this._pos;
+        const thisUvs = this._uvs;
+        const thisNor = this._nor;
+        const thisCol = this._col;
+        const thisTan = this._tan;
+        const indicesLength = indices.length;
+        // Babylon will use all vertex positions in the Geometry (not only the ones referenced
+        // by the indices) to determine the bounding box. As such, we need to go through the
+        // the new subset of indices and only keep the references values in each attribute.
+        const { indexMap, packedIndices: ind } = makeIndexMap(indices);
+        // The length of the indexMap tells us how many unique index value we found.
+        const count = indexMap.size;
+        console.log(`Creating CfgGeometry subset (${indicesLength / 3}/${thisInd.length / 3} triangles, ${count} unique indices)`);
+        const pos = new Float32Array(count * 3);
+        const uvs = thisUvs && new Float32Array(count * 2);
+        const nor = thisNor && new Float32Array(count * 3);
+        const tan = thisTan && new Float32Array(count * 4);
+        const col = thisCol && new Float32Array(count * 4);
+        // Use the index map to move only the referenced used values from all the attributes
+        // over to new smaller arrays.
+        //
+        // A note about the code: The code below is "unrolled" by design since it can be a lot
+        // of indexes to process. A more compact version with an inner loop of 0..3 with some
+        // additional if checks turned out to be up to 30 times slower in Chrome (1.5ms vs
+        // 40ms) for the "repack" call when loading and splitting the forklift model.
+        for (const [oldIndex, newIndex] of indexMap) {
+            pos[newIndex * 3] = thisPos[oldIndex * 3];
+            pos[newIndex * 3 + 1] = thisPos[oldIndex * 3 + 1];
+            pos[newIndex * 3 + 2] = thisPos[oldIndex * 3 + 2];
+            if (uvs !== null && thisUvs !== null) {
+                uvs[newIndex * 2] = thisUvs[oldIndex * 2];
+                uvs[newIndex * 2 + 1] = thisUvs[oldIndex * 2 + 1];
+            }
+            if (nor !== null && thisNor !== null) {
+                nor[newIndex * 3] = thisNor[oldIndex * 3];
+                nor[newIndex * 3 + 1] = thisNor[oldIndex * 3 + 1];
+                nor[newIndex * 3 + 2] = thisNor[oldIndex * 3 + 2];
+            }
+            if (tan !== null && thisTan !== null) {
+                tan[newIndex * 4] = thisTan[oldIndex * 4];
+                tan[newIndex * 4 + 1] = thisTan[oldIndex * 4 + 1];
+                tan[newIndex * 4 + 2] = thisTan[oldIndex * 4 + 2];
+                tan[newIndex * 4 + 3] = thisTan[oldIndex * 4 + 3];
+            }
+            if (col !== null && thisCol !== null) {
+                col[newIndex * 4] = thisCol[oldIndex * 4];
+                col[newIndex * 4 + 1] = thisCol[oldIndex * 4 + 1];
+                col[newIndex * 4 + 2] = thisCol[oldIndex * 4 + 2];
+                col[newIndex * 4 + 3] = thisCol[oldIndex * 4 + 3];
+            }
+        }
+        return new CfgGeometry(this.id + ` (subset ${indices.length})`, this.getScene(), ind, pos, uvs, nor, tan, col, this.morphGeometries.map((morphTarget) => morphTarget.cloneWithSubset(indices)));
     }
 }

package/dist/geometry/CfgMesh.d.ts

@@ -1,8 +1,11 @@
 import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial.js";
 import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
+import { CfgProductNode } from "../nodes/CfgProductNode.js";
 import { RenderEnv } from "../view/RenderEnv.js";
 import { CfgGeometry } from "./CfgGeometry.js";
 export declare class CfgMesh extends Mesh {
-    constructor(name: string, renderEnvironment: RenderEnv, geometry: CfgGeometry, material: PBRMaterial);
+    private readonly _morphTargets;
+    constructor(name: string, renderEnvironment: RenderEnv, cfgProductNodeParent: CfgProductNode, geometry: CfgGeometry, material: PBRMaterial);
+    refreshStretch(): void;
 }
 //# sourceMappingURL=CfgMesh.d.ts.map

package/dist/geometry/CfgMesh.js

@@ -1,8 +1,38 @@
 import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
+import { MorphTargetManager } from "@babylonjs/core/Morph/morphTargetManager.js";
+import { CfgMorphTarget } from "./stretch/CfgMorphTarget.js";
 export class CfgMesh extends Mesh {
-    constructor(name, renderEnvironment, geometry, material) {
+    constructor(name, renderEnvironment, cfgProductNodeParent, geometry, material) {
         super(name, renderEnvironment.scene);
-        geometry.applyToMesh(this);
+        this._morphTargets = [];
+        // Cloning is a hack to handle two things: the Geometry subclass getting automatically
+        // disposed when the last associated mesh is disposed, for example when changing options
+        // back and forth. This way every CfgMesh has it's own instance so we do not need to worry
+        // about it being disposed.
+        // The other issue being handled is the a short circuit in Babylon between CfgMeshes when
+        // using stretch. Meshes using the same CfgGeometry are affected when one of them is unloaded.
+        // IIRC we are using a geometry cache which is probably holding on firmly to this instance
+        // and reusing it for the next time we need the same mesh. If that cache is ever cleared,
+        // it should also dispose the geometry inside it.
+        const cloneGeometry = geometry.shallowClone();
+        cloneGeometry.applyToMesh(this);
         this.material = material;
+        const morphGeometries = cloneGeometry.morphGeometries;
+        if (morphGeometries.length !== 0) {
+            const manager = new MorphTargetManager();
+            manager.enableNormalMorphing = false;
+            manager.enableTangentMorphing = false;
+            this.morphTargetManager = manager;
+            for (const morphGeometry of morphGeometries) {
+                const morphTarget = new CfgMorphTarget(morphGeometry, cfgProductNodeParent);
+                this._morphTargets.push(morphTarget);
+                manager.addTarget(morphTarget);
+            }
+        }
+    }
+    refreshStretch() {
+        for (const morphTarget of this._morphTargets) {
+            morphTarget.refreshStretch();
+        }
     }
 }

package/dist/geometry/stretch/CfgMorphTarget.d.ts

@@ -0,0 +1,16 @@
+import { MorphTarget } from "@babylonjs/core/Morph/morphTarget.js";
+import { CfgProductNode } from "../../nodes/CfgProductNode.js";
+import { CfgStretchData } from "./CfgStretchData.js";
+import { CfgMorphTwiceStretchedGeometry } from "./CfgStretchMorphGeometry.js";
+/**
+ * Contains geometry which when added to the original geometry will move the vertices to where
+ * they should be when the stretchReference length doubles.
+ */
+export declare class CfgMorphTarget extends MorphTarget {
+    private _morphGeometry;
+    readonly cfgProductNodeParent: CfgProductNode;
+    constructor(_morphGeometry: CfgMorphTwiceStretchedGeometry, cfgProductNodeParent: CfgProductNode);
+    get stretchData(): CfgStretchData;
+    refreshStretch(): void;
+}
+//# sourceMappingURL=CfgMorphTarget.d.ts.map

package/dist/geometry/stretch/CfgMorphTarget.js

@@ -0,0 +1,65 @@
+import { MorphTarget } from "@babylonjs/core/Morph/morphTarget.js";
+/**
+ * Contains geometry which when added to the original geometry will move the vertices to where
+ * they should be when the stretchReference length doubles.
+ */
+export class CfgMorphTarget extends MorphTarget {
+    constructor(_morphGeometry, cfgProductNodeParent) {
+        super(_morphGeometry.id);
+        this._morphGeometry = _morphGeometry;
+        this.cfgProductNodeParent = cfgProductNodeParent;
+        const { pos, uvs } = _morphGeometry;
+        this.setPositions(pos);
+        if (uvs !== undefined) {
+            this.setUVs(uvs);
+        }
+        this.refreshStretch();
+    }
+    get stretchData() {
+        return this._morphGeometry.stretchData;
+    }
+    refreshStretch() {
+        const stretchReferenceLengthsByMeasureParamCode = this.cfgProductNodeParent.product.configuration._internal
+            .stretchReferenceLengthsByMeasureParamCode;
+        const referenceLength = stretchReferenceLengthsByMeasureParamCode.get(this.stretchData.measureParam);
+        const influence = referenceLength === undefined
+            ? 0
+            : this.stretchData.calculateInfluenceGivenTwiceMorphTarget(referenceLength.current);
+        if (this.influence === influence) {
+            return;
+        }
+        /* WORKAROUND for render failure
+         *
+         * Setting an influence to 0 (zero) will actually remove the MorphTarget from the list of
+         * "active" MorphTargets in the MorphTargetManager in Babylon.js.
+         *
+         * This is probably an performance optimization since it means less calculations has to be
+         * done the shaders. Another reason could be a workaround for a technical limitation in
+         * WebGL1 that limits the maximum number of MorphTargets in Babylon.js:
+         * https://doc.babylonjs.com/divingDeeper/mesh/morphTargets#limitations
+         *
+         * For some reason this causes problems for us, at least with the combination of Windows 10
+         * + Chromium + Babylon 4.2, in where disabling a previous active MorphTarget (i.e. setting
+         * influence to 0) will cause the first frame in BaseView.BrowserTick to fail to render,
+         * ending up an empty frame with the following error in the console:
+         *
+         * WebGL: INVALID_OPERATION: drawElements: no buffer is bound to enabled attribute
+         *   ThinEngine.drawElementsType @ thinEngine.ts:1995
+         *   Mesh._draw	                 @ mesh.ts:1542
+         *   Mesh._processRendering      @ mesh.ts:1740
+         *   Mesh.render                 @ mesh.ts:1930
+         *   [...]
+         *
+         * The theory we have is that the change of active MorphTargets needs some time or other
+         * event to properly settle in, perhaps due to it changing the shaders. Digging in the
+         * Babylon.js source code has not reveled anything useful so far.
+         *
+         * As a workaround, set the influence to Number.MIN_VALUE (smallest non-zero value) instead
+         * of 0. This keeps it the actual influence as zero in practice, but keeps the MorphTarget
+         * active and no longer triggers the render failure.
+         *
+         * TODO: Revisit this when we switch to a new major release of Babylon.js, 5.0 is next.
+         */
+        this.influence = influence === 0 ? Number.MIN_VALUE : influence;
+    }
+}