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

package/dist/camera/CfgOrbitalCameraControlProps.d.ts

@@ -1,7 +1,7 @@
-export interface CfgOrbitalCameraControlProps {
-    distance?: number;
-    yaw?: number;
-    pitch?: number;
-}
-export declare function orbitalCameraControlPropsEquals(left: CfgOrbitalCameraControlProps, right: CfgOrbitalCameraControlProps): boolean;
+export interface CfgOrbitalCameraControlProps {
+    distance?: number;
+    yaw?: number;
+    pitch?: number;
+}
+export declare function orbitalCameraControlPropsEquals(left: CfgOrbitalCameraControlProps, right: CfgOrbitalCameraControlProps): boolean;
 //# sourceMappingURL=CfgOrbitalCameraControlProps.d.ts.map

package/dist/camera/CfgOrbitalCameraControlProps.js

@@ -1,3 +1,3 @@
-export function orbitalCameraControlPropsEquals(left, right) {
-    return left.distance === right.distance && left.yaw === right.yaw && left.pitch === right.pitch;
-}
+export function orbitalCameraControlPropsEquals(left, right) {
+    return left.distance === right.distance && left.yaw === right.yaw && left.pitch === right.pitch;
+}

package/dist/camera/GradingApplier.d.ts

@@ -1,4 +1,4 @@
-import { Camera } from "@babylonjs/core/Cameras/camera.js";
-export declare type GradingApplier = (camera: Camera) => void;
-export declare const getDefaultGradingApplier: () => (camera: Camera) => void;
+import { Camera } from "@babylonjs/core/Cameras/camera.js";
+export declare type GradingApplier = (camera: Camera) => void;
+export declare const getDefaultGradingApplier: () => (camera: Camera) => void;
 //# sourceMappingURL=GradingApplier.d.ts.map

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
-    //
-    var 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.
-    var 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
+    //
+    var 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.
+    var 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 }, 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,13 +1,13 @@
-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";
-export declare class CfgGeometry extends Geometry implements LogProducer {
-    private _aTriMesh;
-    logger: LogObservable;
-    constructor(id: string, mesh: ATriMeshF, scene: Scene, indices?: Uint32Array | number[]);
-    cloneWithSubset(indices: Uint32Array | number[]): CfgGeometry;
-    releaseForMesh(mesh: Mesh, shouldDispose?: boolean | undefined): void;
-}
+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";
+export declare class CfgGeometry extends Geometry implements LogProducer {
+    private _aTriMesh;
+    logger: LogObservable;
+    constructor(id: string, mesh: ATriMeshF, scene: Scene, indices?: Uint32Array | number[]);
+    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,117 @@
-import { Geometry } from "@babylonjs/core/Meshes/geometry.js";
-import { VertexData } from "@babylonjs/core/Meshes/mesh.vertexData.js";
-import { LogObservable } from "@configura/web-utilities";
-export class CfgGeometry extends Geometry {
-    constructor(id, mesh, scene, indices) {
-        super(id, scene);
-        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;
-        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;
-        }
-        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];
-                }
-            }
-        }
-        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);
-    }
-    /// 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);
-    }
-    /* 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.
-     *
-     */
-    releaseForMesh(mesh, shouldDispose) {
-        super.releaseForMesh(mesh, false);
-    }
-}
+import { Geometry } from "@babylonjs/core/Meshes/geometry.js";
+import { VertexData } from "@babylonjs/core/Meshes/mesh.vertexData.js";
+import { LogObservable } from "@configura/web-utilities";
+export class CfgGeometry extends Geometry {
+    constructor(id, mesh, scene, indices) {
+        super(id, scene);
+        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;
+        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;
+        }
+        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];
+                }
+            }
+        }
+        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);
+    }
+    /// 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);
+    }
+    /* 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.
+     *
+     */
+    releaseForMesh(mesh, shouldDispose) {
+        super.releaseForMesh(mesh, false);
+    }
+}

package/dist/geometry/CfgMesh.d.ts

@@ -1,8 +1,8 @@
-import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial.js";
-import { Mesh } from "@babylonjs/core/Meshes/mesh.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);
-}
+import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial.js";
+import { Mesh } from "@babylonjs/core/Meshes/mesh.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);
+}
 //# sourceMappingURL=CfgMesh.d.ts.map

package/dist/geometry/CfgMesh.js

@@ -1,8 +1,8 @@
-import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
-export class CfgMesh extends Mesh {
-    constructor(name, renderEnvironment, geometry, material) {
-        super(name, renderEnvironment.scene);
-        geometry.applyToMesh(this);
-        this.material = material;
-    }
-}
+import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
+export class CfgMesh extends Mesh {
+    constructor(name, renderEnvironment, geometry, material) {
+        super(name, renderEnvironment.scene);
+        geometry.applyToMesh(this);
+        this.material = material;
+    }
+}

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