vim-web 0.3.23 → 0.3.24

package/dist/types/webgl-viewer/vim-loader/progressive/g3dOffsets.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @module vim-loader
+ */
+import { MeshSection } from 'vim-format';
+import { G3dSubset } from './g3dSubset';
+export declare class G3dMeshCounts {
+    instances: number;
+    meshes: number;
+    indices: number;
+    vertices: number;
+}
+/**
+ * Holds the offsets needed to preallocate geometry for a given meshIndexSubset
+ */
+export declare class G3dMeshOffsets {
+    readonly subset: G3dSubset;
+    readonly section: MeshSection;
+    readonly counts: G3dMeshCounts;
+    private readonly _indexOffsets;
+    private readonly _vertexOffsets;
+    /**
+     * Computes geometry offsets for given subset and section
+     * @param subset subset for which to compute offsets
+     * @param section 'opaque' | 'transparent' | 'all'
+     */
+    constructor(subset: G3dSubset, section: MeshSection);
+    private computeOffsets;
+    /**
+     * Returns the index offset for given mesh and its instances.
+     * @param mesh subset-based mesh index
+     */
+    getIndexOffset(mesh: number): number;
+    /**
+     * Returns the vertex offset for given mesh and its instances.
+     * @param mesh subset-based mesh index
+     */
+    getVertexOffset(mesh: number): number;
+    /**
+     * Returns instance counts of given mesh.
+     * @param mesh subset-based mesh index
+     */
+    getMeshInstanceCount(mesh: number): number;
+    /**
+     * Returns source-based instance for given mesh and index.
+     * @mesh subset-based mesh index
+     * @index mesh-based instance index
+     */
+    getMeshInstance(mesh: number, index: number): number;
+    /**
+     * Returns the source-based mesh index at given index
+     */
+    getSourceMesh(index: number): number;
+}

package/dist/types/webgl-viewer/vim-loader/progressive/g3dSubset.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @module vim-loader
+ */
+import { G3d, MeshSection, G3dScene, FilterMode } from 'vim-format';
+import { G3dMeshOffsets, G3dMeshCounts } from './g3dOffsets';
+import * as THREE from 'three';
+/**
+ * Represents a subset of a complete scene definition.
+ * Allows for further filtering or to get offsets needed to build the scene.
+ */
+export declare class G3dSubset {
+    private _source;
+    private _instances;
+    /** Source-based mesh indices */
+    private _meshes;
+    /** Source-based instances aligned with corresponding mesh */
+    private _meshInstances;
+    /**
+     * @param source Underlying data source for the subset
+     * @param instances source-based instance indices of included instances.
+     */
+    constructor(source: G3dScene | G3d, instances?: number[]);
+    /**
+     * Returns total instance count in subset.
+     */
+    getInstanceCount(): number;
+    /**
+     * Returns the vim-based instance (node) for given subset-based instance.
+     */
+    getVimInstance(subsetIndex: number): number;
+    /**
+     * Returns the vim-based instances (nodes) for current subset.
+     */
+    getVimInstances(): number[];
+    /**
+     * Returns source-based mesh index.
+     * @param index subset-based mesh index
+     */
+    getSourceMesh(index: number): number;
+    /**
+     * Returns total mesh count in subset.
+     */
+    getMeshCount(): number;
+    /**
+     * Returns total index count for given mesh and section.
+     * @param mesh subset-based mesh index
+     * @param section sections to include based on opacity
+     */
+    getMeshIndexCount(mesh: number, section: MeshSection): number;
+    /**
+     * Returns total vertex count for given mesh and section.
+     * @param mesh subset-based mesh index
+     * @param section sections to include based on opacity
+     */
+    getMeshVertexCount(mesh: number, section: MeshSection): number;
+    /**
+     * Returns instance count for given mesh.
+     * @param mesh subset-based mesh index.
+     */
+    getMeshInstanceCount(mesh: number): number;
+    /**
+     * Returns a list of source-based instance indices for given mesh.
+     * @param mesh subset-based mesh index.
+     */
+    getMeshInstances(mesh: number): number[];
+    /**
+     * Returns the source-based instance index for given mesh and index.
+     * @param mesh subset-based mesh index.
+     * @param index mesh-based instance index
+     */
+    getMeshInstance(mesh: number, index: number): number;
+    /**
+     * Returns a new subset that only contains unique meshes.
+     */
+    filterUniqueMeshes(): G3dSubset;
+    /**
+     * Returns a new subset that contains only the N largest meshes sorted by largest
+     */
+    filterLargests(count: number): G3dSubset;
+    /**
+     * Returns a new subset that only contains non-unique meshes.
+     */
+    filterNonUniqueMeshes(): G3dSubset;
+    private filterByCount;
+    /**
+     * Returns offsets needed to build geometry.
+     */
+    getOffsets(section: MeshSection): G3dMeshOffsets;
+    /**
+     * Returns the count of each mesh attribute.
+     */
+    getAttributeCounts(section?: MeshSection): G3dMeshCounts;
+    /**
+     * Returns a new subset where the order of meshes is inverted.
+     */
+    reverse(): G3dSubset;
+    /**
+     * Returns a new subset with instances not included in given filter.
+     * @param mode Defines which field the filter will be applied to.
+     * @param filter Array of all values to match for.
+     */
+    except(mode: FilterMode, filter: number[] | Set<number>): G3dSubset;
+    /**
+     * Returns a new subset with instances matching given filter.
+     * @param mode Defines which field the filter will be applied to.
+     * @param filter Array of all values to match for.
+     */
+    filter(mode: FilterMode, filter: number[] | Set<number>): G3dSubset;
+    private _filter;
+    private filterOnArray;
+    /**
+     * Return the bounding box of the current subset or undefined if subset is empty.
+     */
+    getBoundingBox(): THREE.Box3;
+}

package/dist/types/webgl-viewer/vim-loader/progressive/insertableGeometry.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @module vim-loader
+ */
+import * as THREE from 'three';
+import { G3d, G3dMesh, G3dMaterial } from 'vim-format';
+import { Scene } from '../scene';
+import { G3dMeshOffsets } from './g3dOffsets';
+export declare class GeometrySubmesh {
+    instance: number;
+    start: number;
+    end: number;
+    boundingBox: THREE.Box3;
+    expandBox(point: THREE.Vector3): void;
+}
+export declare class InsertableGeometry {
+    _scene: Scene;
+    materials: G3dMaterial;
+    offsets: G3dMeshOffsets;
+    geometry: THREE.BufferGeometry;
+    submeshes: GeometrySubmesh[];
+    boundingBox: THREE.Box3;
+    private _computeBoundingBox;
+    private _indexAttribute;
+    private _vertexAttribute;
+    private _colorAttribute;
+    private _updateStartMesh;
+    private _updateEndMesh;
+    private _meshToUpdate;
+    constructor(offsets: G3dMeshOffsets, materials: G3dMaterial, transparent: boolean);
+    get progress(): number;
+    insert(mesh: G3dMesh, at: number): number[];
+    float32ArraysAreEqual(array1: Float32Array, array2: Float32Array): boolean;
+    insertFromG3d(g3d: G3d, mesh: number): number[];
+    private setIndex;
+    private setVertex;
+    private setColor;
+    private expandBox;
+    flushUpdate(): void;
+    update(): void;
+}

package/dist/types/webgl-viewer/vim-loader/progressive/insertableMesh.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @module vim-loader
+ */
+import * as THREE from 'three';
+import { G3d, G3dMesh, G3dMaterial } from 'vim-format';
+import { InsertableGeometry } from './insertableGeometry';
+import { InsertableSubmesh } from './insertableSubmesh';
+import { G3dMeshOffsets } from './g3dOffsets';
+import { Vim } from '../vim';
+export declare class InsertableMesh {
+    offsets: G3dMeshOffsets;
+    mesh: THREE.Mesh;
+    vim: Vim;
+    /**
+     * Whether the mesh is merged or not.
+     */
+    get merged(): boolean;
+    /**
+     * Whether the mesh is transparent or not.
+     */
+    transparent: boolean;
+    /**
+     * Total bounding box for this mesh.
+     */
+    get boundingBox(): THREE.Box3;
+    /**
+     * Set to true to ignore SetMaterial calls.
+     */
+    ignoreSceneMaterial: boolean;
+    /**
+     * initial material.
+     */
+    private _material;
+    geometry: InsertableGeometry;
+    constructor(offsets: G3dMeshOffsets, materials: G3dMaterial, transparent: boolean);
+    get progress(): number;
+    insert(g3d: G3dMesh, mesh: number): void;
+    insertFromVim(g3d: G3d, mesh: number): void;
+    update(): void;
+    clearUpdate(): void;
+    /**
+     * Returns submesh corresponding to given face on a merged mesh.
+     */
+    getSubmeshFromFace(faceIndex: number): InsertableSubmesh;
+    /**
+     *
+     * @returns Returns all submeshes
+     */
+    getSubmeshes(): InsertableSubmesh[];
+    /**
+     *
+     * @returns Returns submesh for given index.
+     */
+    getSubmesh(index: number): InsertableSubmesh;
+    /**
+     * Overrides mesh material, set to undefine to restore initial material.
+     */
+    setMaterial(value: THREE.Material): void;
+}

package/dist/types/webgl-viewer/vim-loader/progressive/insertableSubmesh.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @module vim-loader
+ */
+import { Submesh } from '../mesh';
+import { InsertableMesh } from './insertableMesh';
+export declare class InsertableSubmesh {
+    mesh: InsertableMesh;
+    index: number;
+    private _colors;
+    constructor(mesh: InsertableMesh, index: number);
+    equals(other: Submesh): boolean;
+    /**
+     * Returns parent three mesh.
+     */
+    get three(): import("three").Mesh<import("three").BufferGeometry, import("three").Material | import("three").Material[]>;
+    /**
+     * True if parent mesh is merged.
+     */
+    get merged(): boolean;
+    private get submesh();
+    /**
+     * Returns vim instance associated with this submesh.
+     */
+    get instance(): number;
+    /**
+     * Returns bounding box for this submesh.
+     */
+    get boundingBox(): import("three").Box3;
+    /**
+     * Returns starting position in parent mesh for merged mesh.
+     */
+    get meshStart(): number;
+    /**
+     * Returns ending position in parent mesh for merged mesh.
+     */
+    get meshEnd(): number;
+    /**
+     * Returns vim object for this submesh.
+     */
+    get object(): import("../object3D").Object3D;
+    saveColors(colors: Float32Array): void;
+    popColors(): Float32Array<ArrayBufferLike>;
+}

package/dist/types/webgl-viewer/vim-loader/progressive/instancedMesh.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module vim-loader
+ */
+import * as THREE from 'three';
+import { Vim } from '../vim';
+import { InstancedSubmesh } from './instancedSubmesh';
+import { G3d, G3dMesh } from 'vim-format';
+export declare class InstancedMesh {
+    g3dMesh: G3dMesh | G3d;
+    vim: Vim;
+    mesh: THREE.InstancedMesh;
+    bimInstances: ArrayLike<number>;
+    meshInstances: ArrayLike<number>;
+    boundingBox: THREE.Box3;
+    boxes: THREE.Box3[];
+    ignoreSceneMaterial: boolean;
+    private _material;
+    constructor(g3d: G3dMesh | G3d, mesh: THREE.InstancedMesh, instances: Array<number>);
+    get merged(): boolean;
+    /**
+     * Returns submesh for given index.
+     */
+    getSubMesh(index: number): InstancedSubmesh;
+    /**
+     * Returns all submeshes for given index.
+     */
+    getSubmeshes(): InstancedSubmesh[];
+    setMaterial(value: THREE.Material): void;
+    private computeBoundingBoxes;
+    private importBoundingBoxes;
+    computeBoundingBox(boxes: THREE.Box3[]): THREE.Box3;
+}

package/dist/types/webgl-viewer/vim-loader/progressive/instancedMeshFactory.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module vim-loader
+ */
+import { G3d, G3dMesh, G3dMaterial, MeshSection } from 'vim-format';
+import { InstancedMesh } from './instancedMesh';
+export declare class InstancedMeshFactory {
+    materials: G3dMaterial;
+    constructor(materials: G3dMaterial);
+    createTransparent(mesh: G3dMesh, instances: number[]): InstancedMesh;
+    createOpaque(mesh: G3dMesh, instances: number[]): InstancedMesh;
+    createOpaqueFromVim(g3d: G3d, mesh: number, instances: number[]): InstancedMesh;
+    createTransparentFromVim(g3d: G3d, mesh: number, instances: number[]): InstancedMesh;
+    createFromVimx(mesh: G3dMesh, instances: number[], section: MeshSection, transparent: boolean): InstancedMesh;
+    createFromVim(g3d: G3d, mesh: number, instances: number[] | undefined, section: MeshSection, transparent: boolean): InstancedMesh;
+    private createGeometry;
+    private computeIndices;
+    private computeVertices;
+    private computeColors;
+    private setMatricesFromVimx;
+}

package/dist/types/webgl-viewer/vim-loader/progressive/instancedSubmesh.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @module vim-loader
+ */
+import { Submesh } from '../mesh';
+import { InstancedMesh } from './instancedMesh';
+export declare class InstancedSubmesh {
+    mesh: InstancedMesh;
+    index: number;
+    constructor(mesh: InstancedMesh, index: number);
+    equals(other: Submesh): boolean;
+    /**
+     * Returns parent three mesh.
+     */
+    get three(): import("three").InstancedMesh<import("three").BufferGeometry, import("three").Material | import("three").Material[]>;
+    /**
+     * True if parent mesh is merged.
+     */
+    get merged(): boolean;
+    /**
+     * Returns vim instance associated with this submesh.
+     */
+    get instance(): number;
+    /**
+     * Returns bounding box for this submesh.
+     */
+    get boundingBox(): import("three").Box3;
+    /**
+     * Returns vim object for this submesh.
+     */
+    get object(): import("../object3D").Object3D;
+}

package/dist/types/webgl-viewer/vim-loader/progressive/legacyMeshFactory.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module vim-loader
+ */
+import { Scene } from '../scene';
+import { G3dMaterial, G3d } from 'vim-format';
+import { G3dSubset } from './g3dSubset';
+/**
+ * Mesh factory to load a standard vim using the progressive pipeline.
+ */
+export declare class VimMeshFactory {
+    readonly g3d: G3d;
+    private _materials;
+    private _instancedFactory;
+    private _scene;
+    constructor(g3d: G3d, materials: G3dMaterial, scene: Scene);
+    /**
+     * Adds all instances from subset to the scene
+     */
+    add(subset: G3dSubset): void;
+    private addMergedMesh;
+    private createMergedMesh;
+    private addInstancedMeshes;
+}

package/dist/types/webgl-viewer/vim-loader/progressive/loadingSynchronizer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @module vim-loader
+ */
+import { G3dMesh } from 'vim-format';
+import { G3dSubset } from './g3dSubset';
+/**
+ * Makes sure both instanced meshes and merged meshes are requested in the right order
+ * Also decouples downloads and processing.
+ */
+export declare class LoadingSynchronizer {
+    done: boolean;
+    uniques: G3dSubset;
+    nonUniques: G3dSubset;
+    getMesh: (mesh: number) => Promise<G3dMesh>;
+    mergeAction: (mesh: G3dMesh, index: number) => void;
+    instanceAction: (mesh: G3dMesh, index: number) => void;
+    mergeQueue: (() => void)[];
+    instanceQueue: (() => void)[];
+    constructor(uniques: G3dSubset, nonUniques: G3dSubset, getMesh: (mesh: number) => Promise<G3dMesh>, mergeAction: (mesh: G3dMesh, index: number) => void, instanceAction: (mesh: G3dMesh, index: number) => void);
+    get isDone(): boolean;
+    abort(): void;
+    loadAll(): Promise<void>;
+    private consumeQueues;
+    private getSortedPromises;
+    merge(mesh: number, index: number): Promise<void>;
+    instance(mesh: number, index: number): Promise<void>;
+}

package/dist/types/webgl-viewer/vim-loader/progressive/open.d.ts

@@ -0,0 +1,12 @@
+import { VimPartialSettings } from '../vimSettings';
+import { Vim } from '../vim';
+import { VimSource } from '../../index';
+import { BFast, IProgressLogs } from 'vim-format';
+/**
+ * Asynchronously opens a vim object from a given source with the provided settings.
+ * @param {string | BFast} source - The source of the vim object, either a string or a BFast.
+ * @param {VimPartialSettings} settings - The settings to configure the behavior of the vim object.
+ * @param {(p: IProgressLogs) => void} [onProgress] - Optional callback function to track progress logs.
+ * @returns {Promise<void>} A Promise that resolves when the vim object is successfully opened.
+ */
+export declare function open(source: VimSource | BFast, settings: VimPartialSettings, onProgress?: (p: IProgressLogs) => void): Promise<Vim>;

package/dist/types/webgl-viewer/vim-loader/progressive/subsetBuilder.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @module vim-loader
+ */
+import { VimMeshFactory } from './legacyMeshFactory';
+import { LoadPartialSettings, LoadSettings } from './subsetRequest';
+import { G3dSubset } from './g3dSubset';
+import { ISignal, ISignalHandler } from 'ste-signals';
+import { ISubscribable, SubscriptionChangeEventHandler } from 'ste-core';
+import { Vimx } from './vimx';
+import { Scene } from '../scene';
+export interface SubsetBuilder {
+    /** Dispatched whenever a subset begins or finishes loading. */
+    onUpdate: ISignal;
+    /** Returns true when some subset is being loaded. */
+    isLoading: boolean;
+    /** Returns all instances as a subset */
+    getFullSet(): G3dSubset;
+    /** Loads given subset with given options */
+    loadSubset(subset: G3dSubset, settings?: LoadPartialSettings): any;
+    /** Stops and clears all loading processes */
+    clear(): any;
+    dispose(): any;
+}
+/**
+ * Loads and builds subsets from a Vim file.
+ */
+export declare class VimSubsetBuilder implements SubsetBuilder {
+    factory: VimMeshFactory;
+    private _onUpdate;
+    get onUpdate(): ISignal;
+    get isLoading(): boolean;
+    constructor(factory: VimMeshFactory);
+    getFullSet(): G3dSubset;
+    loadSubset(subset: G3dSubset, settings?: LoadPartialSettings): void;
+    clear(): void;
+    dispose(): void;
+}
+/**
+ * Loads and builds subsets from a VimX file.
+ */
+export declare class VimxSubsetBuilder {
+    private _localVimx;
+    private _scene;
+    private _set;
+    private _onUpdate;
+    get onUpdate(): ISignal;
+    get isLoading(): boolean;
+    constructor(localVimx: Vimx, scene: Scene);
+    getFullSet(): G3dSubset;
+    loadSubset(subset: G3dSubset, settings?: LoadPartialSettings): Promise<void>;
+    clear(): void;
+    dispose(): void;
+}
+export declare class DummySubsetBuilder implements SubsetBuilder {
+    get onUpdate(): AlwaysTrueSignal;
+    get isLoading(): boolean;
+    getFullSet(): G3dSubset;
+    loadSubset(subset: G3dSubset, settings?: Partial<LoadSettings>): void;
+    clear(): void;
+    dispose(): void;
+}
+declare class AlwaysTrueSignal implements ISignal {
+    count: number;
+    subscribe(fn: ISignalHandler): () => void;
+    sub(fn: ISignalHandler): () => void;
+    unsubscribe(fn: ISignalHandler): void;
+    unsub(fn: ISignalHandler): void;
+    one(fn: ISignalHandler): () => void;
+    has(fn: ISignalHandler): boolean;
+    clear(): void;
+    onSubscriptionChange: ISubscribable<SubscriptionChangeEventHandler>;
+}
+export {};

package/dist/types/webgl-viewer/vim-loader/progressive/subsetRequest.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @module vim-loader
+ */
+import { Vimx, Scene } from '../..';
+import { G3dSubset } from './g3dSubset';
+export type LoadSettings = {
+    /** Delay in ms between each rendering list update. @default: 400ms */
+    updateDelayMs: number;
+    /** If true, will wait for geometry to be ready before it is added to the renderer. @default: false */
+    delayRender: boolean;
+};
+export type LoadPartialSettings = Partial<LoadSettings>;
+/**
+ * Manages geometry downloads and loads it into a scene for rendering.
+ */
+export declare class SubsetRequest {
+    private _subset;
+    private _uniques;
+    private _nonUniques;
+    private _opaqueMesh;
+    private _transparentMesh;
+    private _synchronizer;
+    private _meshFactory;
+    private _meshes;
+    private _pushedMesh;
+    private _disposed;
+    private _started;
+    private _scene;
+    getBoundingBox(): import("three").Box3;
+    constructor(scene: Scene, localVimx: Vimx, subset: G3dSubset);
+    dispose(): void;
+    start(settings: LoadPartialSettings): Promise<void>;
+    private nextFrame;
+    private mergeMesh;
+    private instanceMesh;
+    private updateMeshes;
+}

package/dist/types/webgl-viewer/vim-loader/progressive/vimRequest.d.ts

@@ -0,0 +1,44 @@
+import { VimPartialSettings } from '../vimSettings';
+import { Vim } from '../vim';
+import { RequestResult } from '../../utils/requestResult';
+import { VimSource } from '../../index';
+import { IProgressLogs } from 'vim-format';
+export type RequestSource = {
+    url?: string;
+    buffer?: ArrayBuffer;
+    headers?: Record<string, string>;
+};
+/**
+ * Initiates a request to load a VIM object from a given source.
+ * @param options a url where to find the vim file or a buffer of a vim file.
+ * @param settings the settings to configure how the vim will be loaded.
+ * @returns a request object that can be used to track progress and get the result.
+ */
+export declare function request(options: RequestSource, settings?: VimPartialSettings): VimRequest;
+/**
+ * A class that represents a request to load a VIM object from a given source.
+ */
+export declare class VimRequest {
+    private _source;
+    private _settings;
+    private _bfast;
+    private _isDone;
+    private _vimResult?;
+    private _error?;
+    private _progress;
+    private _progressPromise;
+    private _completionPromise;
+    constructor(source: VimSource, settings: VimPartialSettings);
+    /**
+     * Initiates the asynchronous request and handles progress updates.
+     */
+    private startRequest;
+    private end;
+    getResult(): Promise<RequestResult<Vim>>;
+    /**
+     * Async generator that yields progress updates.
+     * @returns An AsyncGenerator yielding IProgressLogs.
+     */
+    getProgress(): AsyncGenerator<IProgressLogs, void, void>;
+    abort(): void;
+}

package/dist/types/webgl-viewer/vim-loader/progressive/vimx.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module vim-loader
+ */
+import { G3dMaterial, RemoteVimx, VimHeader, G3dScene } from 'vim-format';
+/**
+ * Interface to interact with a vimx
+ */
+export declare class Vimx {
+    private readonly vimx;
+    readonly scene: G3dScene;
+    readonly materials: G3dMaterial;
+    readonly header: VimHeader;
+    static fromRemote(vimx: RemoteVimx, downloadMeshes: boolean): Promise<Vimx>;
+    private constructor();
+    getMesh(mesh: number): Promise<import("vim-format").G3dMesh>;
+    abort(): void;
+}