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

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

package/dist/geometry/stretch/CfgStretchData.js

@@ -0,0 +1,340 @@
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { SymGfxMode } from "@configura/web-core/dist/cm/format/cmsym/components/SymComponent.js";
+import { convertLength, hashCode } from "@configura/web-utilities";
+import { MESH_UNIT } from "../../nodes/CfgSymRootNode.js";
+import { cmPointToVector3 } from "../../utilities/utilities3D.js";
+function calculateNormals(sp, ep) {
+    const normal = ep.subtract(sp);
+    const spToEpLength = normal.length();
+    const normalizedNormal = normal.normalizeToNew();
+    return {
+        spToEpLength,
+        normal,
+        normalizedNormal,
+    };
+}
+/**
+ * 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 function calculateAlongness(p, sp, spToEpLength, normalizedNormal) {
+    const towardTp = p.subtract(sp);
+    return ((normalizedNormal.x * towardTp.x +
+        normalizedNormal.y * towardTp.y +
+        normalizedNormal.z * towardTp.z) /
+        spToEpLength);
+}
+/**
+ * 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 const toStretchedPoint = (p, stretchDatas, stretchReferenceLengthsByMeasureParamCode) => stretchDatas.reduce((acc, stretchData) => {
+    const referenceLength = stretchReferenceLengthsByMeasureParamCode.get(stretchData.measureParam);
+    if (referenceLength === undefined) {
+        return acc;
+    }
+    return acc.add(stretchData
+        .stretchPointToTwice(p)
+        .scale(stretchData.calculateInfluenceGivenTwiceMorphTarget(referenceLength.current)));
+}, p);
+function spOrEpToPoint(node) {
+    const trans = node.symTransform(true);
+    if (trans.scale.x !== 1 || trans.scale.y !== 1 || trans.scale.z !== 1) {
+        throw new Error("We do not expect scale on sp or ep");
+    }
+    if (trans.rot !== undefined) {
+        throw new Error("We do not expect rotation on sp or ep");
+    }
+    if (trans.pivot !== undefined) {
+        throw new Error("We do not expect pivot on sp or ep");
+    }
+    const pos = trans.pos;
+    if (pos === undefined) {
+        return new Vector3();
+    }
+    return cmPointToVector3(pos);
+}
+/**
+ * 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 class CfgStretchData {
+    /**
+     * 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
+     */
+    constructor(detailLevel, measureParam, originalReferenceLength, sp, ep, spToEpLength, originalSpToEpLength, normal, normalNormalized, sections) {
+        this.detailLevel = detailLevel;
+        this.measureParam = measureParam;
+        this.originalReferenceLength = originalReferenceLength;
+        this.sp = sp;
+        this.ep = ep;
+        this.spToEpLength = spToEpLength;
+        this.originalSpToEpLength = originalSpToEpLength;
+        this.normal = normal;
+        this.normalNormalized = normalNormalized;
+        this.sections = sections;
+        /** How far along between sp and ep is p? */
+        this.getAlongness = (p) => calculateAlongness(p, this.sp, this.spToEpLength, this.normalNormalized);
+    }
+    static make(logger, symNode, detailLevel) {
+        const symMeasure = symNode.getMeasure();
+        if (symMeasure === undefined) {
+            throw new Error("No symMeasure found");
+        }
+        const { measureParam, sections, originalLength } = symMeasure;
+        if (measureParam === undefined) {
+            throw new Error("No measureParam");
+        }
+        const children = symNode.children(logger, true, true);
+        let sp;
+        let ep;
+        const detailLevelToDividerNameToPos = new Map();
+        let detailLevelNodeName3D;
+        let detailLevelNodeName2D;
+        for (const [name, node] of children) {
+            const symReps = node.symReps(true);
+            const details = symReps._details;
+            // We relax the requirements on detail-level a bit when it comes to sp and ep.
+            // If we can not find sp and/or ep that is the right detail-level we take the
+            // first one we found.
+            if (sp === undefined && name === "sp") {
+                sp = spOrEpToPoint(node);
+            }
+            else if (ep === undefined && name === "ep") {
+                ep = spOrEpToPoint(node);
+            }
+            // We only handle children which either has no detail-level or has an acceptable
+            // detail-level
+            if (details !== undefined) {
+                const detailMask = details.values().next().value;
+                if (!detailMask.includes(detailLevel)) {
+                    continue;
+                }
+            }
+            if (name.startsWith("divider")) {
+                const nodeChildren = node.children(logger, true, true);
+                for (const [subLevelNodeName, subNode] of nodeChildren) {
+                    const trans = subNode.symTransform(true);
+                    if (trans === undefined) {
+                        continue;
+                    }
+                    const pos = trans.pos;
+                    if (pos === undefined) {
+                        continue;
+                    }
+                    let dividerNameToPos = detailLevelToDividerNameToPos.get(subLevelNodeName);
+                    if (dividerNameToPos === undefined) {
+                        dividerNameToPos = new Map();
+                        detailLevelToDividerNameToPos.set(subLevelNodeName, dividerNameToPos);
+                    }
+                    dividerNameToPos.set(name, cmPointToVector3(pos));
+                }
+            }
+            else if (name.startsWith("3D")) {
+                detailLevelNodeName3D = name;
+            }
+            else if (name.startsWith("2D")) {
+                detailLevelNodeName2D = name;
+            }
+            else if (name === "sp") {
+                sp = spOrEpToPoint(node);
+            }
+            else if (name === "ep") {
+                ep = spOrEpToPoint(node);
+            }
+        }
+        if (sp === undefined) {
+            throw new Error("Start point missing");
+        }
+        if (ep === undefined) {
+            throw new Error("End point missing");
+        }
+        if (sp.equals(ep)) {
+            throw new Error("Start point and End point are equal");
+        }
+        const { spToEpLength, normal, normalizedNormal } = calculateNormals(sp, ep);
+        if (detailLevelToDividerNameToPos.size === 0) {
+            throw new Error("Dividers missing");
+        }
+        if (detailLevelNodeName3D === undefined && detailLevelNodeName2D === undefined) {
+            throw new Error("Details level node name missing");
+        }
+        let detailLevelGfxMode = SymGfxMode.undefined;
+        let dividerNameToPos;
+        if (detailLevelNodeName3D !== undefined) {
+            dividerNameToPos = detailLevelToDividerNameToPos.get(detailLevelNodeName3D);
+            if (dividerNameToPos !== undefined) {
+                detailLevelGfxMode = SymGfxMode.x3D;
+            }
+        }
+        if (dividerNameToPos === undefined && detailLevelNodeName2D !== undefined) {
+            dividerNameToPos = detailLevelToDividerNameToPos.get(detailLevelNodeName2D);
+            if (dividerNameToPos !== undefined) {
+                detailLevelGfxMode = SymGfxMode.x2D;
+            }
+        }
+        if (dividerNameToPos === undefined) {
+            throw new Error("Dividers for detail level missing");
+        }
+        const processedSections = CfgStretchData.processSections(sections, detailLevel, detailLevelGfxMode, dividerNameToPos, sp, spToEpLength, normalizedNormal);
+        return new this(detailLevel, measureParam, originalLength, sp, ep, spToEpLength, spToEpLength, normal, normalizedNormal, processedSections);
+    }
+    static processSections(sections, detailLevel, detailLevelGfxMode, dividerNameToPos, sp, spToEpLength, normalizedNormal) {
+        // The morph target shall morph to making the morphed thing
+        // twice as long as before morph, that is, 100% increase.
+        // The sizeChange parameters are assumed to aggregate to 1.
+        // The alongness goes from 0 at sp to 1 at ep. So summing these
+        // should make the postStretchEndAlongness of the last one be 2.
+        let accumulatedSizeChange = 0;
+        let startAlongness = 0;
+        let atTwiceStartAlongness = 0;
+        return sections.map((section, sectionIndex) => {
+            const { move, sizeChange, gfxModeToDetailLevelToMultiSelector } = section;
+            const sectionsLength = sections.length;
+            if (sectionsLength < 1) {
+                throw new Error("At lease one section needed for stretch");
+            }
+            const first = sectionIndex === 0;
+            const last = sectionIndex === sectionsLength - 1;
+            const detailLevelToMultiSelector = gfxModeToDetailLevelToMultiSelector.get(detailLevelGfxMode);
+            if (detailLevelToMultiSelector === undefined) {
+                throw new Error("No x3D or x2D for section");
+            }
+            const multiSelector = detailLevelToMultiSelector.get(detailLevel);
+            if (multiSelector === undefined) {
+                throw new Error("No multiSelector for detail level");
+            }
+            const selectors = multiSelector.selectors;
+            const selectorsLength = selectors.length;
+            if ((first || last ? 1 : 2) !== selectorsLength) {
+                throw new Error("Divider plane count expected to be 1 for first or last and 2 for others");
+            }
+            let endAlongness;
+            if (last) {
+                endAlongness = 1;
+            }
+            else {
+                const dividerId = selectors[selectorsLength - 1].dividerId;
+                const pos = dividerNameToPos.get(dividerId);
+                if (pos === undefined) {
+                    throw new Error("No position found for symDividerSelector");
+                }
+                endAlongness = calculateAlongness(pos, sp, spToEpLength, normalizedNormal);
+            }
+            accumulatedSizeChange += sizeChange;
+            const atTwiceEndAlongness = endAlongness + accumulatedSizeChange;
+            const result = {
+                last,
+                move,
+                sizeChange,
+                startAlongness,
+                endAlongness,
+                atTwiceTranslation: move && 0 < sectionIndex
+                    ? atTwiceEndAlongness - endAlongness
+                    : atTwiceStartAlongness - startAlongness,
+                atTwiceScale: move
+                    ? 0
+                    : (atTwiceEndAlongness - atTwiceStartAlongness) /
+                        (endAlongness - startAlongness) -
+                        1,
+            };
+            startAlongness = endAlongness;
+            atTwiceStartAlongness = atTwiceEndAlongness;
+            return result;
+        });
+    }
+    get hash() {
+        if (this._hash === undefined) {
+            this._hash = hashCode(`${this.detailLevel}-${this.measureParam}-${this.sp.asArray()}-${this.ep.asArray()}-${this.originalSpToEpLength}-${this.sections.map((section) => `${section.startAlongness}-${section.endAlongness}-${section.move}-${section.sizeChange}`)}`);
+        }
+        return this._hash;
+    }
+    /**
+     * 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) {
+        if (matrix.isIdentity()) {
+            return this;
+        }
+        const sp = Vector3.TransformCoordinates(this.sp, matrix);
+        const ep = Vector3.TransformCoordinates(this.ep, matrix);
+        const { spToEpLength, normal, normalizedNormal } = calculateNormals(sp, ep);
+        return new CfgStretchData(this.detailLevel, this.measureParam, this.originalReferenceLength, sp, ep, spToEpLength, this.spToEpLength, normal, normalizedNormal, this.sections);
+    }
+    /**
+     * 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) {
+        const alongness = this.getAlongness(p);
+        const { sections, normal } = this;
+        for (const section of sections) {
+            const endAlongness = section.endAlongness;
+            if (section.last || alongness <= endAlongness) {
+                let translation = section.atTwiceTranslation;
+                if (!section.move) {
+                    translation += (alongness - section.startAlongness) * section.atTwiceScale;
+                }
+                return normal.scale(translation);
+            }
+        }
+        throw new Error("Should not be possible");
+    }
+    /**
+     * 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) {
+        const { originalSpToEpLength } = this;
+        if (referenceLength.length === 0) {
+            // CET considers 0 as a no-value and will return the stretch to the default value.
+            // If this changes, remove this workaround.
+            return 0;
+        }
+        return ((convertLength(referenceLength.length, referenceLength.unit, MESH_UNIT) -
+            originalSpToEpLength) /
+            originalSpToEpLength);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { UVMapper } from "@configura/web-core/dist/cm/core3D/uvmapper/UVMapper";
+import { Logger } from "@configura/web-utilities";
+import { CfgStretchData } from "./CfgStretchData.js";
+/**
+ * Contains positions which are where stretching to twice the referenceLength would place them.
+ * This is raw data for CfgMorphTarget.
+ */
+export declare class CfgMorphTwiceStretchedGeometry {
+    readonly id: string;
+    readonly stretchData: CfgStretchData;
+    readonly pos: Float32Array;
+    readonly uvs: Float32Array | undefined;
+    static make(logger: Logger, uvMapper: UVMapper | undefined, stretchData: CfgStretchData, pos: Float32Array, normals: Float32Array | undefined, uvs: Float32Array | undefined): CfgMorphTwiceStretchedGeometry;
+    private constructor();
+    cloneWithSubset(indices: Uint32Array | number[]): CfgMorphTwiceStretchedGeometry;
+}
+//# sourceMappingURL=CfgStretchMorphGeometry.d.ts.map

package/dist/geometry/stretch/CfgStretchMorphGeometry.js

@@ -0,0 +1,95 @@
+import { Vector3 } from "@babylonjs/core";
+import { makeIndexMap } from "../CfgGeometry.js";
+/**
+ * CET has a built in error in how bounds are calculated. I will add 1mm to each side of the
+ * bounding box. This gives pronounced errors on small objects, less so on larger objects. To be
+ * consistent with CET we also add 1 mm. Remove this when this is corrected in CET.
+ */
+const CET_COMPENSATION = 0.001;
+/**
+ * Contains positions which are where stretching to twice the referenceLength would place them.
+ * This is raw data for CfgMorphTarget.
+ */
+export class CfgMorphTwiceStretchedGeometry {
+    constructor(id, stretchData, pos, uvs) {
+        this.id = id;
+        this.stretchData = stretchData;
+        this.pos = pos;
+        this.uvs = uvs;
+    }
+    static make(logger, uvMapper, stretchData, pos, normals, uvs) {
+        const posLength = pos.length;
+        const stretchedPos = new Float32Array(posLength);
+        const min = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+        const max = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+        const stretchedMin = [
+            Number.POSITIVE_INFINITY,
+            Number.POSITIVE_INFINITY,
+            Number.POSITIVE_INFINITY,
+        ];
+        const stretchedMax = [
+            Number.NEGATIVE_INFINITY,
+            Number.NEGATIVE_INFINITY,
+            Number.NEGATIVE_INFINITY,
+        ];
+        const c = new Vector3();
+        let p = 0;
+        for (let i = 0; i < posLength; i += 3) {
+            for (let axis = 0; axis < 3; axis++) {
+                p = pos[i + axis];
+                min[axis] = Math.min(min[axis], p);
+                max[axis] = Math.max(max[axis], p);
+            }
+            c.fromArray(pos, i);
+            c.addInPlace(stretchData.stretchPointToTwice(c));
+            c.toArray(stretchedPos, i);
+            for (let axis = 0; axis < 3; axis++) {
+                p = stretchedPos[i + axis];
+                stretchedMin[axis] = Math.min(stretchedMin[axis], p);
+                stretchedMax[axis] = Math.max(stretchedMax[axis], p);
+            }
+        }
+        for (let axis = 0; axis < 3; axis++) {
+            min[axis] = min[axis] - CET_COMPENSATION;
+            max[axis] = max[axis] + CET_COMPENSATION;
+            stretchedMin[axis] = stretchedMin[axis] - CET_COMPENSATION;
+            stretchedMax[axis] = stretchedMax[axis] + CET_COMPENSATION;
+        }
+        const size = max.map((m, axis) => m - min[axis]);
+        const stretchedSize = stretchedMax.map((m, axis) => m - stretchedMin[axis]);
+        let stretchedUvs = uvs;
+        if (uvMapper !== undefined && normals !== undefined && uvs !== undefined) {
+            stretchedUvs = uvMapper.createUVCoordinatesForStretched(logger, stretchedPos, {
+                min: stretchedMin,
+                max: stretchedMax,
+                size: stretchedSize,
+            }, normals, pos, {
+                min,
+                max,
+                size,
+            }, uvs);
+        }
+        return new this(stretchData.measureParam, stretchData, stretchedPos, stretchedUvs);
+    }
+    cloneWithSubset(indices) {
+        const { indexMap } = makeIndexMap(indices);
+        const count = indexMap.size;
+        const thisPos = this.pos;
+        const newPos = new Float32Array(count * 3);
+        for (const [oldIndex, newIndex] of indexMap) {
+            newPos[newIndex * 3] = thisPos[oldIndex * 3];
+            newPos[newIndex * 3 + 1] = thisPos[oldIndex * 3 + 1];
+            newPos[newIndex * 3 + 2] = thisPos[oldIndex * 3 + 2];
+        }
+        const thisUvs = this.uvs;
+        let newUvs = undefined;
+        if (thisUvs !== undefined) {
+            newUvs = new Float32Array(count * 2);
+            for (const [oldIndex, newIndex] of indexMap) {
+                newUvs[newIndex * 2] = thisUvs[oldIndex * 2];
+                newUvs[newIndex * 2 + 1] = thisUvs[oldIndex * 2 + 1];
+            }
+        }
+        return new CfgMorphTwiceStretchedGeometry(this.id + ` (subset ${indices.length})`, this.stretchData, newPos, newUvs);
+    }
+}

package/dist/material/CfgMaterial.d.ts

@@ -7,21 +7,32 @@ import { LogObservable, LogProducer } from "@configura/web-utilities";
 import { RenderEnv } from "../view/RenderEnv.js";
 import { MaterialMetaData } from "./material.js";
 import { GMAndTexture } from "./texture.js";
+/**
+ * A wrapper around Babylon.js PBRMaterial class.
+ *
+ * Also contains logic to create light weight "variants" of the main PBRMaterial to take into
+ * account that CmSym allows the meshes to have properties that affects the material currently
+ * applied to the mesh, such as double doubled sided or flipping the textures along the y-axis.
+ *
+ * The variants are created on demand if the request to getPBRMaterial specifies properties that
+ * does not match the main PBRMaterial. The variants are then cached.
+ */
 export declare class CfgMaterial implements LogProducer {
     private _material;
     private _variants;
     isTransparent: boolean;
     logger: LogObservable;
     constructor(material: PBRMaterial, maxSimultaneousLights: number);
+    /** This material is supposed to be rendered as double sided by default. */
     isDoubleSided(): boolean;
-    static fromTexture(renderEnvironment: RenderEnv, texture: Texture, sourcePath: string[]): CfgMaterial;
-    static compileFromGm(renderEnvironment: RenderEnv, meta: MaterialMetaData, gMaterial: GMaterial3D, textures: GMAndTexture[]): CfgMaterial;
-    static compileFromGmPBR(renderEnvironment: RenderEnv, meta: MaterialMetaData, gMaterial: GMaterialPBR, textures: GMAndTexture[], name: string): {
+    static makeFromTexture(renderEnvironment: RenderEnv, texture: Texture, sourcePath: string[]): CfgMaterial;
+    static makeFromGm(renderEnvironment: RenderEnv, meta: MaterialMetaData, gMaterial: GMaterial3D, textures: GMAndTexture[]): CfgMaterial;
+    static makeFromGmPBR(renderEnvironment: RenderEnv, meta: MaterialMetaData, gMaterial: GMaterialPBR, textures: GMAndTexture[], name: string): {
         material: PBRMaterial;
         transparent: boolean;
         doubleSided: boolean;
     };
-    static compileFromGmClassic(renderEnvironment: RenderEnv, meta: MaterialMetaData, gMaterial: GMaterialClassic, textures: GMAndTexture[], name: string): {
+    static makeFromGmClassic(renderEnvironment: RenderEnv, meta: MaterialMetaData, gMaterial: GMaterialClassic, textures: GMAndTexture[], name: string): {
         material: PBRMaterial;
         transparent: boolean;
         doubleSided: boolean;
@@ -50,5 +61,9 @@ export declare class CfgMaterial implements LogProducer {
      */
     getPBRMaterial(doubleSided?: boolean, backThenFront?: boolean, flipTextures?: boolean): PBRMaterial;
 }
+/**
+ * The exact changes this method makes depends on the material's separateCullingPass setting, so
+ * make sure make any changes to that property before calling this method.
+ */
 export declare function makeMaterialDoubleSided(material: PBRMaterial, doubleSided: boolean): void;
 //# sourceMappingURL=CfgMaterial.d.ts.map