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

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/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;
+    }
+}

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

@@ -0,0 +1,115 @@
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { LengthValue, StretchMap } from "@configura/web-api";
+import { SymNode } from "@configura/web-core/dist/cm/format/cmsym/SymNode.js";
+import { DetailLevel } from "@configura/web-core/dist/cm/geometry/DetailMask.js";
+import { Logger } from "@configura/web-utilities";
+/**
+ * How far along from sp to ep is a point on a plane crossing the sp to ep line?
+ * 1 means at ep, 0 means at sp.
+ */
+export declare function calculateAlongness(p: Vector3, sp: Vector3, spToEpLength: number, normalizedNormal: Vector3): number;
+/**
+ * Where does the point p end up given the CfgStretchDatas and the StretchMap.
+ * This is the same equations that Babylon uses for stretching, only Babylon does it in the
+ * shaders during rendering and is thus GPU accelerated.
+ * This version is much slower, but that is okay as long as this function is sparingly used.
+ */
+export declare const toStretchedPoint: (p: Vector3, stretchDatas: CfgStretchData[], stretchReferenceLengthsByMeasureParamCode: StretchMap) => Vector3;
+/**
+ * The end of a section is the beginning of the next.
+ * Start/end are redundant, but both are kept for ease of access.
+ * The first section will have startAlongness 0. This does not mean that things can't be outside.
+ * The start section should be thought of as endless in the sp-direction.
+ * The last section will have endAlongness 0. This does not mean that things can't be outside.
+ * The end section should be thought of as endless in the ep-direction.
+ */
+export declare type StretchSection = {
+    last: boolean;
+    sizeChange: number;
+    move: boolean;
+    startAlongness: number;
+    endAlongness: number;
+    atTwiceTranslation: number;
+    atTwiceScale: number;
+};
+/**
+ * Please note that stretch is not bound to be contained between sp and ep.
+ *
+ * The thinking in the equations in CfgStretchData is that we want to support MorphTargets in an as
+ * efficient manner as possible. As MorphTargets work by morphing between pre-compiled meshes we
+ * calculate what happens if you stretch to twice the referenceLength, to make MorphTargets for
+ * twice the referenceLength, and then calculate how these MorphTargets should be applied to
+ * achieve to requested referenceLength.
+ *
+ * This adaption to MorphTargets might make the code for stretching points for other purposes look
+ * (be) a bit complicated. However, as a mesh often contains millions of vertices that needs to be
+ * moved and calculating for bounding boxes, and anchor points and such moves very few vertices,
+ * this is okay.
+ *
+ * Using "Twice" as the precomputed target is arbitrarily, we just chose it because it makes
+ * equations simple.
+ */
+export declare class CfgStretchData {
+    readonly detailLevel: DetailLevel;
+    readonly measureParam: string;
+    readonly originalReferenceLength: number | undefined;
+    readonly sp: Vector3;
+    readonly ep: Vector3;
+    readonly spToEpLength: number;
+    readonly originalSpToEpLength: number;
+    readonly normal: Vector3;
+    readonly normalNormalized: Vector3;
+    readonly sections: StretchSection[];
+    static make(logger: Logger, symNode: SymNode, detailLevel: DetailLevel): CfgStretchData;
+    private static processSections;
+    /**
+     * It is assumed that the symNode passed really is stretch (symNodeIsStretch has been run)
+     * so any data missing for stretch will be an Exception.
+     *
+     * @param detailLevel
+     * @param measureParam Name of the parameter controlling the stretch
+     * @param originalReferenceLength Server-side calculated original referenceLength. We do not
+     * actually use this for anything, but it can be handy for debug.
+     * @param sp Start Point, the start anchor of the stretch line.
+     * @param ep End Point, the end anchor of the stretch line.
+     * @param spToEpLength Distance from sp to ep.
+     * @param originalSpToEpLength spToEpLength before transforms.
+     * @param normal The normal is from sp to ep and is the normal of every plane that divides this
+     * stretch.
+     * @param normalNormalized Normalized version of normal
+     * @param sections The slices the model is sliced into
+     */
+    private constructor();
+    private _hash;
+    get hash(): number;
+    /** How far along between sp and ep is p? */
+    getAlongness: (p: Vector3) => number;
+    /**
+     * If the Matrix is identity the original CfgStretchData is returned.
+     * If not a new CfgStretchData will be created.
+     * sp, ep, spToEpLength, normal, normalNormalized, scale will be cloned and transformed
+     * The rest will still reference the original objects
+     */
+    applyMatrix(matrix: Matrix): CfgStretchData;
+    /**
+     * Calculates the translation of a point which moves it from its original position to where it
+     * would be if we stretched to twice the reference length. Please note: this gives the
+     * translation, not the new location. The new location will be p.add(stretchPointToTwice(p))
+     */
+    stretchPointToTwice(p: Vector3): Vector3;
+    /**
+     * Given a reference length calculates the influence that should be applied to a MorphTarget to
+     * achieve the requested length, given that these MorphTargets are constructed so that they
+     * will double the length when the influence 1 is applied.
+     *
+     * Please note that the referenceLength is the wanted length between sp and ep, that is, the
+     * stretch line. This line does not have to be span the entire model. Also, there can be
+     * multiple stretch lines that are not orthogonal to this, and the will also affect the actual
+     * size. Finally there can be transforms applied in the tree. So, the referenceLength will only
+     * be the actual length of the model in specific cases. However, we believe that models with
+     * stretch are often constructed in such a way that in real use cases the referenceLength is
+     * the actual real length.
+     */
+    calculateInfluenceGivenTwiceMorphTarget(referenceLength: LengthValue): number;
+}
+//# sourceMappingURL=CfgStretchData.d.ts.map