@configura/babylon-view 2.1.0-alpha.0 → 2.1.0-alpha.1

package/dist/camera/GradingApplier.js

@@ -1,48 +1,48 @@
-import { ColorCurves } from "@babylonjs/core/Materials/colorCurves.js";
-import { ImageProcessingConfiguration } from "@babylonjs/core/Materials/imageProcessingConfiguration.js";
-import { DefaultRenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline.js";
-export const getDefaultGradingApplier = () => (camera) => {
-    const scene = camera.getScene();
-    // The second parameter below is HDR which is supposed to be enabled "as long as possible"
-    // according to the documentation. However, doing so causes problems with rendering against
-    // our transparent background:
-    // - Anti-aliasing breaks for very white colors (BanquetChair2 in ConfiguraKitchenAccessories)
-    // - Transparent objects gets rendered very differently against the transparent background
-    //   compared to over a opaque surface (Electric Cart in ConfiguraIndustrialEquipment)
-    // - Transparent objects gets a very bright and color shifting results (ConfiguraHumans)
-    //
-    // The last point can be fixed by disabling premultipliedAlpha in the EngineConstructor,
-    // resulting in a bit better subjective colors compared to CET for "ConfiguraHumans".
-    //
-    // TODO Babylon: Figure out how we can enable the "hdr" flag again. Since we are using
-    // PBR we really should be using "hdr" to do things the right way, see this discussion:
-    // https://forum.babylonjs.com/t/enabling-hdr-in-defaultpipeline-disables-aa/14656/9
-    //
-    const pipeline = new DefaultRenderingPipeline("defaultPipeline", false, scene, [camera]);
-    // FXAA is not enabled since it causes excessive blur in detailed textures
-    // pipeline.fxaaEnabled = true;
-    // This affects anti-aliasing, more samples is better but also slower.
-    // Note that this does not seem to do anything unless HDR is enabled in the
-    // DefaultRenderingPipeline call.
-    pipeline.samples = 4;
-    pipeline.imageProcessingEnabled = true;
-    pipeline.imageProcessing.toneMappingEnabled = true;
-    pipeline.imageProcessing.toneMappingType = ImageProcessingConfiguration.TONEMAPPING_ACES;
-    // ACES tone mapping needs manual exposure adjustment in Babylon to look good on a normal
-    // monitor. More information can be found in the links below, note that "model-viewer" (in
-    // their "Fidelity" test) ended up using "1 / 0.6" rather than the value of 2.0 that was first
-    // decided upon in their pull request.
-    //
-    // https://github.com/google/model-viewer/pull/1340
-    // https://github.com/mrdoob/three.js/pull/19621
-    // https://modelviewer.dev/fidelity/
-    pipeline.imageProcessing.exposure = 1 / 0.6;
-    // We add a bit of extra contrast to make the image more appealing. This is highly subjective.
-    pipeline.imageProcessing.contrast = 1.2;
-    // The ACES color correction is quite desaturating, add back a bit of punch to the colors.
-    const curve = new ColorCurves();
-    curve.midtonesSaturation = 5;
-    curve.highlightsSaturation = 15;
-    pipeline.imageProcessing.colorCurves = curve;
-    pipeline.imageProcessing.colorCurvesEnabled = true;
-};
+import { ColorCurves } from "@babylonjs/core/Materials/colorCurves.js";
+import { ImageProcessingConfiguration } from "@babylonjs/core/Materials/imageProcessingConfiguration.js";
+import { DefaultRenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline.js";
+export const getDefaultGradingApplier = () => (camera) => {
+    const scene = camera.getScene();
+    // The second parameter below is HDR which is supposed to be enabled "as long as possible"
+    // according to the documentation. However, doing so causes problems with rendering against
+    // our transparent background:
+    // - Anti-aliasing breaks for very white colors (BanquetChair2 in ConfiguraKitchenAccessories)
+    // - Transparent objects gets rendered very differently against the transparent background
+    //   compared to over a opaque surface (Electric Cart in ConfiguraIndustrialEquipment)
+    // - Transparent objects gets a very bright and color shifting results (ConfiguraHumans)
+    //
+    // The last point can be fixed by disabling premultipliedAlpha in the EngineConstructor,
+    // resulting in a bit better subjective colors compared to CET for "ConfiguraHumans".
+    //
+    // TODO Babylon: Figure out how we can enable the "hdr" flag again. Since we are using
+    // PBR we really should be using "hdr" to do things the right way, see this discussion:
+    // https://forum.babylonjs.com/t/enabling-hdr-in-defaultpipeline-disables-aa/14656/9
+    //
+    const pipeline = new DefaultRenderingPipeline("defaultPipeline", false, scene, [camera]);
+    // FXAA is not enabled since it causes excessive blur in detailed textures
+    // pipeline.fxaaEnabled = true;
+    // This affects anti-aliasing, more samples is better but also slower.
+    // Note that this does not seem to do anything unless HDR is enabled in the
+    // DefaultRenderingPipeline call.
+    pipeline.samples = 4;
+    pipeline.imageProcessingEnabled = true;
+    pipeline.imageProcessing.toneMappingEnabled = true;
+    pipeline.imageProcessing.toneMappingType = ImageProcessingConfiguration.TONEMAPPING_ACES;
+    // ACES tone mapping needs manual exposure adjustment in Babylon to look good on a normal
+    // monitor. More information can be found in the links below, note that "model-viewer" (in
+    // their "Fidelity" test) ended up using "1 / 0.6" rather than the value of 2.0 that was first
+    // decided upon in their pull request.
+    //
+    // https://github.com/google/model-viewer/pull/1340
+    // https://github.com/mrdoob/three.js/pull/19621
+    // https://modelviewer.dev/fidelity/
+    pipeline.imageProcessing.exposure = 1 / 0.6;
+    // We add a bit of extra contrast to make the image more appealing. This is highly subjective.
+    pipeline.imageProcessing.contrast = 1.2;
+    // The ACES color correction is quite desaturating, add back a bit of punch to the colors.
+    const curve = new ColorCurves();
+    curve.midtonesSaturation = 5;
+    curve.highlightsSaturation = 15;
+    pipeline.imageProcessing.colorCurves = curve;
+    pipeline.imageProcessing.colorCurvesEnabled = true;
+};

package/dist/engine/EngineCreator.d.ts

@@ -1,4 +1,4 @@
-import { Engine } from "@babylonjs/core/Engines/engine.js";
-export declare type EngineCreator = (canvas: HTMLCanvasElement, width: number, height: number) => Engine;
-export declare function getDefaultEngine(canvas: HTMLCanvasElement, width: number, height: number): Engine;
+import { Engine } from "@babylonjs/core/Engines/engine.js";
+export declare type EngineCreator = (canvas: HTMLCanvasElement, width: number, height: number) => Engine;
+export declare function getDefaultEngine(canvas: HTMLCanvasElement, width: number, height: number): Engine;
 //# sourceMappingURL=EngineCreator.d.ts.map

package/dist/engine/EngineCreator.js

@@ -1,10 +1,10 @@
-import { Engine } from "@babylonjs/core/Engines/engine.js";
-export function getDefaultEngine(canvas, width, height) {
-    // The xrCompatible flag below is used as a workaround for Babylon.js 4.2 crashing in Safari 15
-    // see WEB-8493 for additional details. It should be safe to apply to all browsers.
-    //
-    // TODO: Remove this workaround when upgrading to Babylon.js 5.0
-    const engine = new Engine(canvas, true, { xrCompatible: false, preserveDrawingBuffer: true }, true);
-    engine.setSize(Math.floor(width), Math.floor(height));
-    return engine;
-}
+import { Engine } from "@babylonjs/core/Engines/engine.js";
+export function getDefaultEngine(canvas, width, height) {
+    // The xrCompatible flag below is used as a workaround for Babylon.js 4.2 crashing in Safari 15
+    // see WEB-8493 for additional details. It should be safe to apply to all browsers.
+    //
+    // TODO: Remove this workaround when upgrading to Babylon.js 5.0
+    const engine = new Engine(canvas, true, { xrCompatible: false, preserveDrawingBuffer: true }, true);
+    engine.setSize(Math.floor(width), Math.floor(height));
+    return engine;
+}

package/dist/geometry/CfgGeometry.d.ts

@@ -1,30 +1,30 @@
-import { Geometry } from "@babylonjs/core/Meshes/geometry.js";
-import { Scene } from "@babylonjs/core/scene.js";
-import { ATriMeshF } from "@configura/web-core/dist/cm/core3D/ATriMeshF.js";
-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 readonly _ind;
-    private readonly _pos;
-    private readonly _uvs;
-    private readonly _nor;
-    private readonly _tan;
-    private readonly _col;
-    readonly morphGeometries: CfgMorphTwiceStretchedGeometry[];
-    logger: LogObservable;
-    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;
-}
+import { Geometry } from "@babylonjs/core/Meshes/geometry.js";
+import { Scene } from "@babylonjs/core/scene.js";
+import { ATriMeshF } from "@configura/web-core/dist/cm/core3D/ATriMeshF.js";
+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 readonly _ind;
+    private readonly _pos;
+    private readonly _uvs;
+    private readonly _nor;
+    private readonly _tan;
+    private readonly _col;
+    readonly morphGeometries: CfgMorphTwiceStretchedGeometry[];
+    logger: LogObservable;
+    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;
+}
 //# sourceMappingURL=CfgGeometry.d.ts.map

package/dist/geometry/CfgGeometry.js

@@ -1,146 +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, 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();
-        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;
-        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 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);
-        }
-        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)));
-    }
-    shallowClone() {
-        return new CfgGeometry(this.id, this.getScene(), this._ind, this._pos, this._uvs, this._nor, this._tan, this._col, this.morphGeometries);
-    }
-    /**
-     * Returns a new CfgGeometry containing a subset of this CfgGeometry based on the given
-     * indices.
-     */
-    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)));
-    }
-}
+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, 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();
+        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;
+        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 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);
+        }
+        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)));
+    }
+    shallowClone() {
+        return new CfgGeometry(this.id, this.getScene(), this._ind, this._pos, this._uvs, this._nor, this._tan, this._col, this.morphGeometries);
+    }
+    /**
+     * Returns a new CfgGeometry containing a subset of this CfgGeometry based on the given
+     * indices.
+     */
+    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,11 +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 {
-    private readonly _morphTargets;
-    constructor(name: string, renderEnvironment: RenderEnv, cfgProductNodeParent: CfgProductNode, geometry: CfgGeometry, material: PBRMaterial);
-    refreshStretch(): void;
-}
+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 {
+    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,38 +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, cfgProductNodeParent, geometry, material) {
-        super(name, renderEnvironment.scene);
-        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();
-        }
-    }
-}
+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, cfgProductNodeParent, geometry, material) {
+        super(name, renderEnvironment.scene);
+        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/geoSplitter.d.ts

@@ -1,9 +1,9 @@
-import { Logger } from "@configura/web-utilities";
-import { CfgGeometry } from "./CfgGeometry.js";
-export declare function splitIndexQuick(logger: Logger, geo: CfgGeometry): number[][] | undefined;
-export declare function splitIndexComplete(logger: Logger, geo: CfgGeometry, conf: {
-    maxFinalGroups: number;
-    maxProgressGroups: number;
-    acceptCoordinateMatch?: boolean;
-}): number[][] | undefined;
+import { Logger } from "@configura/web-utilities";
+import { CfgGeometry } from "./CfgGeometry.js";
+export declare function splitIndexQuick(logger: Logger, geo: CfgGeometry): number[][] | undefined;
+export declare function splitIndexComplete(logger: Logger, geo: CfgGeometry, conf: {
+    maxFinalGroups: number;
+    maxProgressGroups: number;
+    acceptCoordinateMatch?: boolean;
+}): number[][] | undefined;
 //# sourceMappingURL=geoSplitter.d.ts.map