@configura/babylon-view 1.3.0-alpha.3 → 1.3.0

package/dist/geometry/geoSplitter.js

@@ -1,192 +1,192 @@
-import { VertexBuffer } from "@babylonjs/core/Meshes/buffer.js";
-// Will try to split the geometry along planes on the xy, yz and xz-planes for
-// a total of maximum 8 groups. If a triangle straddles a plane those groups
-// will be merged
-export function splitIndexQuick(logger, geo) {
-    const indexArray = geo.getIndices();
-    if (!indexArray) {
-        logger.info("No index array, could not try split geo");
-        return;
-    }
-    const indexCount = geo.getTotalIndices();
-    if (indexCount === 0) {
-        logger.warn("Empty geo index");
-        return;
-    }
-    const positionArray = geo.getVerticesData(VertexBuffer.PositionKind);
-    if (!positionArray) {
-        logger.info("No position array, could not try split geo");
-        return;
-    }
-    // Three axis, so max potential resultGroups 2^3
-    const resultGroups = [[], [], [], [], [], [], [], []];
-    for (let triIndex = 0; triIndex < indexCount; triIndex += 3) {
-        const belongsInGroups = [];
-        // For each triangle
-        for (let i = triIndex; i < triIndex + 3; i++) {
-            const offset = indexArray[i] * 3;
-            let belongsIndex = 0;
-            for (let c = 0; c < 3; c++) {
-                belongsIndex += 0 <= positionArray[offset + c] ? 1 << c : 0;
-            }
-            if (!belongsInGroups.some((g) => g === belongsIndex)) {
-                belongsInGroups.push(belongsIndex);
-            }
-        }
-        const targetGroup = resultGroups[belongsInGroups[0]];
-        // Merge groups straddled by this triangle (if needed)
-        for (let i = 1; i < belongsInGroups.length; i++) {
-            const resultGroupIndex = belongsInGroups[i];
-            const otherGroup = resultGroups[resultGroupIndex];
-            // Let this position in the result groups array point to the same group as they share
-            // at least one triangle
-            if (targetGroup !== otherGroup) {
-                // The group can be in multiple positions
-                let j = resultGroups.length;
-                while (j--) {
-                    if (otherGroup === resultGroups[j]) {
-                        resultGroups[j] = targetGroup;
-                    }
-                }
-                const otherGroupLength = otherGroup.length;
-                for (let j = 0; j < otherGroupLength; j++) {
-                    targetGroup.push(otherGroup[j]);
-                }
-            }
-        }
-        for (let i = triIndex; i < triIndex + 3; i++) {
-            targetGroup.push(indexArray[i]);
-        }
-    }
-    // Filter so that we only get one instance of each group and no empty groups
-    let i = resultGroups.length;
-    while (i--) {
-        const group = resultGroups[i];
-        if (group.length === 0) {
-            resultGroups.splice(i, 1);
-            continue;
-        }
-        let j = i;
-        while (j--) {
-            if (group === resultGroups[j]) {
-                resultGroups.splice(i, 1);
-                break;
-            }
-        }
-    }
-    return resultGroups;
-}
-export function splitIndexComplete(logger, geo, conf) {
-    const { maxProgressGroups, maxFinalGroups, acceptCoordinateMatch } = conf;
-    const indexArray = geo.getIndices();
-    if (!indexArray) {
-        logger.info("No index array, could not try split geo");
-        return;
-    }
-    const indexCount = geo.getTotalIndices();
-    if (indexCount === 0) {
-        logger.warn("Empty geo index");
-        return;
-    }
-    const positionArray = geo.getVerticesData(VertexBuffer.PositionKind);
-    if (!positionArray) {
-        logger.info("No position array, could not try split geo");
-        return;
-    }
-    const resultGroups = [];
-    let targetGroup;
-    // Loop over each triangle in the index
-    for (let triIndex = 0; triIndex < indexCount; triIndex += 3) {
-        // Groups that neighbor this triangle
-        const intersectingGroupIndices = [];
-        const resultGroupsCount = resultGroups.length;
-        if (maxProgressGroups < resultGroupsCount) {
-            logger.info(`Geo split into too many groups while in progress`, `(max allowed ${maxProgressGroups})`);
-            return;
-        }
-        // Loop over each group.
-        for (let resultGroupIndex = 0; resultGroupIndex < resultGroupsCount; resultGroupIndex++) {
-            const group = resultGroups[resultGroupIndex];
-            const groupLength = group.length;
-            let found = false;
-            // For nodes in the current triangle
-            for (let i = triIndex; i < triIndex + 3; i++) {
-                let j = groupLength;
-                // Loop backwards through indices in the group. Backwards since it's likely new
-                // nodes will be close to previous ones
-                while (j--) {
-                    if (indexArray[i] === group[j]) {
-                        intersectingGroupIndices.push(resultGroupIndex);
-                        found = true;
-                        break;
-                    }
-                }
-                if (found) {
-                    break;
-                }
-            }
-            if (!found && acceptCoordinateMatch) {
-                // For nodes in the current triangle
-                for (let i = triIndex; i < triIndex + 3; i++) {
-                    let j = groupLength;
-                    // Loop backwards through indices in the group. Backwards since it's likely new
-                    // nodes will be close to previous ones
-                    while (j--) {
-                        const offset1 = indexArray[i] * 3;
-                        const offset2 = group[j] * 3;
-                        let c = 3;
-                        while (c--) {
-                            if (positionArray[offset1 + c] !== positionArray[offset2 + c]) {
-                                break;
-                            }
-                        }
-                        if (c === -1) {
-                            intersectingGroupIndices.push(resultGroupIndex);
-                            found = true;
-                            break;
-                        }
-                    }
-                    if (found) {
-                        break;
-                    }
-                }
-            }
-        }
-        targetGroup = undefined;
-        const intersectingGroupIndicesCount = intersectingGroupIndices.length;
-        if (intersectingGroupIndicesCount === 0) {
-            // The triangle is not adjacent to any existing node in any group
-            targetGroup = [];
-            resultGroups.push(targetGroup);
-        }
-        else {
-            let i = intersectingGroupIndicesCount - 1;
-            // Pick one (probably not important which one) to merge the other groups into. If this
-            // was the only one it will skip the loop
-            targetGroup = resultGroups[intersectingGroupIndices[i]];
-            // The nodes are sorted in ascending order. So we back through to nodes to allow us to
-            // use splice without disturbing unbroken ground.
-            while (i--) {
-                // Move all nodes to the target group and remove this one, as the latest triangle
-                // is adjacent to both
-                const resultGroupIndex = intersectingGroupIndices[i];
-                const group = resultGroups[resultGroupIndex];
-                resultGroups.splice(resultGroupIndex, 1);
-                const resultGroupCount = group.length;
-                for (let j = 0; j < resultGroupCount; j++) {
-                    targetGroup.push(group[j]);
-                }
-            }
-        }
-        // Add the latest triangle to the target group
-        for (let i = triIndex; i < triIndex + 3; i++) {
-            targetGroup.push(indexArray[i]);
-        }
-    }
-    const resultGroupsCount = resultGroups.length;
-    if (resultGroupsCount > maxFinalGroups) {
-        logger.info(`Geo split into too many final groups`, `(actual ${resultGroupsCount}, max allowed ${maxFinalGroups})`);
-        return;
-    }
-    return resultGroups;
-}
+import { VertexBuffer } from "@babylonjs/core/Meshes/buffer.js";
+// Will try to split the geometry along planes on the xy, yz and xz-planes for
+// a total of maximum 8 groups. If a triangle straddles a plane those groups
+// will be merged
+export function splitIndexQuick(logger, geo) {
+    const indexArray = geo.getIndices();
+    if (!indexArray) {
+        logger.info("No index array, could not try split geo");
+        return;
+    }
+    const indexCount = geo.getTotalIndices();
+    if (indexCount === 0) {
+        logger.warn("Empty geo index");
+        return;
+    }
+    const positionArray = geo.getVerticesData(VertexBuffer.PositionKind);
+    if (!positionArray) {
+        logger.info("No position array, could not try split geo");
+        return;
+    }
+    // Three axis, so max potential resultGroups 2^3
+    const resultGroups = [[], [], [], [], [], [], [], []];
+    for (let triIndex = 0; triIndex < indexCount; triIndex += 3) {
+        const belongsInGroups = [];
+        // For each triangle
+        for (let i = triIndex; i < triIndex + 3; i++) {
+            const offset = indexArray[i] * 3;
+            let belongsIndex = 0;
+            for (let c = 0; c < 3; c++) {
+                belongsIndex += 0 <= positionArray[offset + c] ? 1 << c : 0;
+            }
+            if (!belongsInGroups.some((g) => g === belongsIndex)) {
+                belongsInGroups.push(belongsIndex);
+            }
+        }
+        const targetGroup = resultGroups[belongsInGroups[0]];
+        // Merge groups straddled by this triangle (if needed)
+        for (let i = 1; i < belongsInGroups.length; i++) {
+            const resultGroupIndex = belongsInGroups[i];
+            const otherGroup = resultGroups[resultGroupIndex];
+            // Let this position in the result groups array point to the same group as they share
+            // at least one triangle
+            if (targetGroup !== otherGroup) {
+                // The group can be in multiple positions
+                let j = resultGroups.length;
+                while (j--) {
+                    if (otherGroup === resultGroups[j]) {
+                        resultGroups[j] = targetGroup;
+                    }
+                }
+                const otherGroupLength = otherGroup.length;
+                for (let j = 0; j < otherGroupLength; j++) {
+                    targetGroup.push(otherGroup[j]);
+                }
+            }
+        }
+        for (let i = triIndex; i < triIndex + 3; i++) {
+            targetGroup.push(indexArray[i]);
+        }
+    }
+    // Filter so that we only get one instance of each group and no empty groups
+    let i = resultGroups.length;
+    while (i--) {
+        const group = resultGroups[i];
+        if (group.length === 0) {
+            resultGroups.splice(i, 1);
+            continue;
+        }
+        let j = i;
+        while (j--) {
+            if (group === resultGroups[j]) {
+                resultGroups.splice(i, 1);
+                break;
+            }
+        }
+    }
+    return resultGroups;
+}
+export function splitIndexComplete(logger, geo, conf) {
+    const { maxProgressGroups, maxFinalGroups, acceptCoordinateMatch } = conf;
+    const indexArray = geo.getIndices();
+    if (!indexArray) {
+        logger.info("No index array, could not try split geo");
+        return;
+    }
+    const indexCount = geo.getTotalIndices();
+    if (indexCount === 0) {
+        logger.warn("Empty geo index");
+        return;
+    }
+    const positionArray = geo.getVerticesData(VertexBuffer.PositionKind);
+    if (!positionArray) {
+        logger.info("No position array, could not try split geo");
+        return;
+    }
+    const resultGroups = [];
+    let targetGroup;
+    // Loop over each triangle in the index
+    for (let triIndex = 0; triIndex < indexCount; triIndex += 3) {
+        // Groups that neighbor this triangle
+        const intersectingGroupIndices = [];
+        const resultGroupsCount = resultGroups.length;
+        if (maxProgressGroups < resultGroupsCount) {
+            logger.info(`Geo split into too many groups while in progress`, `(max allowed ${maxProgressGroups})`);
+            return;
+        }
+        // Loop over each group.
+        for (let resultGroupIndex = 0; resultGroupIndex < resultGroupsCount; resultGroupIndex++) {
+            const group = resultGroups[resultGroupIndex];
+            const groupLength = group.length;
+            let found = false;
+            // For nodes in the current triangle
+            for (let i = triIndex; i < triIndex + 3; i++) {
+                let j = groupLength;
+                // Loop backwards through indices in the group. Backwards since it's likely new
+                // nodes will be close to previous ones
+                while (j--) {
+                    if (indexArray[i] === group[j]) {
+                        intersectingGroupIndices.push(resultGroupIndex);
+                        found = true;
+                        break;
+                    }
+                }
+                if (found) {
+                    break;
+                }
+            }
+            if (!found && acceptCoordinateMatch) {
+                // For nodes in the current triangle
+                for (let i = triIndex; i < triIndex + 3; i++) {
+                    let j = groupLength;
+                    // Loop backwards through indices in the group. Backwards since it's likely new
+                    // nodes will be close to previous ones
+                    while (j--) {
+                        const offset1 = indexArray[i] * 3;
+                        const offset2 = group[j] * 3;
+                        let c = 3;
+                        while (c--) {
+                            if (positionArray[offset1 + c] !== positionArray[offset2 + c]) {
+                                break;
+                            }
+                        }
+                        if (c === -1) {
+                            intersectingGroupIndices.push(resultGroupIndex);
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (found) {
+                        break;
+                    }
+                }
+            }
+        }
+        targetGroup = undefined;
+        const intersectingGroupIndicesCount = intersectingGroupIndices.length;
+        if (intersectingGroupIndicesCount === 0) {
+            // The triangle is not adjacent to any existing node in any group
+            targetGroup = [];
+            resultGroups.push(targetGroup);
+        }
+        else {
+            let i = intersectingGroupIndicesCount - 1;
+            // Pick one (probably not important which one) to merge the other groups into. If this
+            // was the only one it will skip the loop
+            targetGroup = resultGroups[intersectingGroupIndices[i]];
+            // The nodes are sorted in ascending order. So we back through to nodes to allow us to
+            // use splice without disturbing unbroken ground.
+            while (i--) {
+                // Move all nodes to the target group and remove this one, as the latest triangle
+                // is adjacent to both
+                const resultGroupIndex = intersectingGroupIndices[i];
+                const group = resultGroups[resultGroupIndex];
+                resultGroups.splice(resultGroupIndex, 1);
+                const resultGroupCount = group.length;
+                for (let j = 0; j < resultGroupCount; j++) {
+                    targetGroup.push(group[j]);
+                }
+            }
+        }
+        // Add the latest triangle to the target group
+        for (let i = triIndex; i < triIndex + 3; i++) {
+            targetGroup.push(indexArray[i]);
+        }
+    }
+    const resultGroupsCount = resultGroups.length;
+    if (resultGroupsCount > maxFinalGroups) {
+        logger.info(`Geo split into too many final groups`, `(actual ${resultGroupsCount}, max allowed ${maxFinalGroups})`);
+        return;
+    }
+    return resultGroups;
+}

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