vim-web 0.6.0-dev.0 → 0.6.0-dev.10

package/dist/types/core-viewers/webgl/loader/element3d.d.ts

@@ -1,108 +0,0 @@
-/**
- * @module vim-loader
- */
-import * as THREE from 'three';
-import { Vim } from './vim';
-import { IElement, VimHelpers } from 'vim-format';
-import { Submesh } from './mesh';
-import { IVimElement } from '../../shared/vim';
-/**
- * High level api to interact with the loaded vim   ometry and data.
- */
-export declare class Element3D implements IVimElement {
-    private _color;
-    private _boundingBox;
-    private _meshes;
-    private readonly _outlineAttribute;
-    private readonly _visibleAttribute;
-    private readonly _coloredAttribute;
-    private readonly _focusedAttribute;
-    private readonly _colorAttribute;
-    /**
-     * Indicate whether this object is architectural or markup.
-     */
-    readonly type = "Element3D";
-    /**
-     * The vim object from which this object came from.
-     */
-    readonly vim: Vim;
-    /**
-     * The bim element index associated with this object.
-     */
-    readonly element: number;
-    /**
-     * The ID of the element associated with this object.
-     */
-    get elementId(): bigint;
-    /**
-     * The geometry instances  associated with this object.
-     */
-    readonly instances: number[] | undefined;
-    /**
-     * Checks if this object has associated geometry.
-     * @returns {boolean} True if this object has geometry, otherwise false.
-     */
-    get hasMesh(): boolean;
-    get isRoom(): boolean;
-    /**
-     * Determines whether to render selection outline for this object or not.
-     */
-    get outline(): boolean;
-    set outline(value: boolean);
-    /**
-     * Determines whether to render focus highlight for this object or not.
-     */
-    get focused(): boolean;
-    set focused(value: boolean);
-    /**
-     * Determines whether to render this object or not.
-     */
-    get visible(): boolean;
-    set visible(value: boolean);
-    /**
-     * Gets or sets the display color of this object.
-     * @param {THREE.Color | undefined} color The color to apply. Pass undefined to revert to the default color.
-     * @returns {THREE.Color} The current color of the object.
-     */
-    get color(): THREE.Color | undefined;
-    set color(color: THREE.Color | undefined);
-    private get renderer();
-    /**
-     * Constructs a new instance of Object.
-     * @param {Vim} vim The Vim instance.
-     * @param {number} element The element index.
-     * @param {number[] | undefined} instances An optional array of instance numbers.
-     * @param {Submesh[] | undefined} meshes An optional array of submeshes.
-     */
-    constructor(vim: Vim, element: number, instances: number[] | undefined, meshes: Submesh[] | undefined);
-    /**
-     * Asynchronously retrieves Bim data for the element associated with this object.
-     * @returns {IElement} An object containing the bim data for this element.
-     */
-    getBimElement(): Promise<IElement>;
-    /**
-     * Asynchronously retrieves Bim parameters for the element associated with this object.
-     * @returns {VimHelpers.ElementParameter[]} An array of all bim parameters for this elements.
-     */
-    getBimParameters(): Promise<VimHelpers.ElementParameter[]>;
-    /**
-     * Retrieves the bounding box of the object from cache or computes it if needed.
-     * Returns undefined if the element is abstract.
-     * @returns {THREE.Box3 | undefined} The bounding box of the object, or undefined if the object has no geometry.
-     */
-    getBoundingBox(): Promise<THREE.Box3>;
-    /**
-     * Retrieves the center position of this object.
-     * @param {THREE.Vector3} [target=new THREE.Vector3()] Optional parameter specifying where to copy the center position data.
-     * A new instance is created if none is provided.
-     * @returns {THREE.Vector3 | undefined} The center position of the object, or undefined if the object has no geometry.
-     */
-    getCenter(target?: THREE.Vector3): Promise<THREE.Vector3>;
-    /**
-     * Internal method used to replace this object's meshes and apply color as needed.
-     * @param {Submesh} mesh The new mesh to be added.
-     * @throws {Error} Throws an error if the provided mesh instance does not match any existing instances.
-     */
-    _addMesh(mesh: Submesh): void;
-    private updateMeshes;
-}

package/dist/types/core-viewers/webgl/loader/elementMapping.d.ts

@@ -1,113 +0,0 @@
-/**
- * @module vim-loader
- */
-import { G3d, G3dScene, VimDocument } from 'vim-format';
-export declare class ElementNoMapping {
-    getElementsFromElementId(id: number): any;
-    hasElement(element: number): boolean;
-    getElements(): any[];
-    getInstancesFromElement(element: number): number[] | undefined;
-    getElementFromInstance(instance: number): any;
-    getElementId(element: number): bigint | undefined;
-}
-export declare class ElementMapping {
-    private _instanceToElement;
-    private _instanceMeshes;
-    private _elementToInstances;
-    private _elementIds;
-    private _elementIdToElements;
-    constructor(instances: number[], instanceToElement: number[], elementIds: BigInt64Array, instanceMeshes?: Int32Array);
-    static fromG3d(g3d: G3d, bim: VimDocument): Promise<ElementMapping>;
-    /**
-     * Returns element indices associated with element id
-     * @param id element id
-     */
-    getElementsFromElementId(id: number | bigint): number[];
-    /**
-     * Returns true if element exists in the vim.
-     */
-    hasElement(element: number): boolean;
-    hasMesh(element: number): boolean;
-    /**
-     * Returns all element indices of the vim
-     */
-    getElements(): ArrayIterator<number>;
-    /**
-     * Returns instance indices associated with vim element index
-     * @param element vim element index
-     */
-    getInstancesFromElement(element: number): number[] | undefined;
-    /**
-     * Returns the element index associated with the g3d instance index.
-     * @param instance g3d instance index
-     * @returns element index or undefined if not found
-     */
-    getElementFromInstance(instance: number): number;
-    /**
-     * Retrieves the element ID corresponding to the provided element index.
-     * @param {number} element The element index.
-     * @returns {bigint} The element ID associated with the given index.
-     */
-    getElementId(element: number): bigint;
-    /**
-     * Returns a map where data[i] -> i
-     */
-    private static invertArray;
-    /**
-     * Returns a map where data[i] -> i
-     */
-    private static invertMap;
-}
-export declare class ElementMapping2 {
-    private _instanceToElement;
-    private _elementToInstances;
-    private _instanceToElementId;
-    constructor(scene: G3dScene);
-    /**
-     * Retrieves element indices associated with the given element ID.
-     * @param {number | bigint} id The element ID.
-     * @returns {number[] | undefined} An array of element indices associated with the element ID,
-     * or undefined if no elements are associated with the ID.
-     */
-    getElementsFromElementId(id: number | bigint): any;
-    /**
-     * Checks if the element exists in the vim.
-     * @param {number} element The element to check for existence.
-     * @returns {boolean} True if the element exists in the vim, otherwise false.
-     */
-    hasElement(element: number): boolean;
-    /**
-     * Checks if the element has a mesh in the vim.
-     * @param {number} element The element to check for mesh existence.
-     * @returns {boolean} True if the element has a mesh in the vim, otherwise false.
-     */
-    hasMesh(element: number): boolean;
-    /**
-     * Retrieves all element indices of the vim.
-     * @returns {IterableIterator<number>} An iterator of all element indices in the vim.
-     */
-    getElements(): MapIterator<number>;
-    /**
-     * Retrieves instance indices associated with the specified vim element index.
-     * @param {number} element The vim element index.
-     * @returns {number[] | undefined} An array of instance indices associated with the vim element index,
-     * or undefined if the element does not exist in the vim.
-     */
-    getInstancesFromElement(element: number): number[] | undefined;
-    /**
-     * Retrieves the element index associated with the g3d instance index.
-     * @param {number} instance The g3d instance index.
-     * @returns {number | undefined} The element index associated with the instance, or undefined if not found.
-     */
-    getElementFromInstance(instance: number): number;
-    /**
-     * Retrieves the element ID associated with the specified element index.
-     * @param {number} element The element index.
-     * @returns {bigint | undefined} The element ID associated with the element index, or undefined if not found.
-     */
-    getElementId(element: number): bigint;
-    /**
-     * Returns a map where data[i] -> i
-     */
-    private static invertMap;
-}

package/dist/types/core-viewers/webgl/loader/geometry.d.ts

@@ -1,103 +0,0 @@
-/**
- * @module vim-loader
- */
-import * as THREE from 'three';
-import { G3d, MeshSection } from 'vim-format';
-export type MergeArgs = {
-    matrix: THREE.Matrix4;
-    section: MeshSection;
-    legacyInstances: number[];
-    legacyLoadRooms: boolean;
-    transparent: boolean;
-};
-export declare namespace Transparency {
-    /**
-     * Determines how to draw (or not) transparent and opaque objects
-     */
-    type Mode = 'opaqueOnly' | 'transparentOnly' | 'allAsOpaque' | 'all';
-    /**
-     * Returns true if the transparency mode is one of the valid values
-     */
-    function isValid(value: string | undefined | null): value is Mode;
-    /**
-     * Returns true if the transparency mode requires to use RGBA colors
-     */
-    function requiresAlpha(mode: Mode): mode is "all" | "transparentOnly";
-}
-/**
- * Creates a BufferGeometry with all given instances merged
- * @param instances indices of the instances from the g3d to merge
- * @returns a BufferGeometry
- */
-export declare function createGeometryFromInstances(g3d: G3d, args: MergeArgs): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
-/**
- * Creates a BufferGeometry from a given mesh index in the g3d
- * @param mesh g3d mesh index
- * @param transparent specify to use RGB or RGBA for colors
- */
-export declare function createGeometryFromMesh(g3d: G3d, mesh: number, section: MeshSection, transparent: boolean): THREE.BufferGeometry;
-/**
- * Returns a THREE.Matrix4 from the g3d for given instance
- * @param instance g3d instance index
- * @param target matrix where the data will be copied, a new matrix will be created if none provided.
- */
-export declare function getInstanceMatrix(g3d: G3d, instance: number, target?: THREE.Matrix4): THREE.Matrix4;
-/**
- * Creates a BufferGeometry from given geometry data arrays
- * @param vertices vertex data with 3 number per vertex (XYZ)
- * @param indices index data with 3 indices per face
- * @param vertexColors color data with 3 or 4 number per vertex. RBG or RGBA
- * @param colorSize specify whether to treat colors as RGB or RGBA
- * @returns a BufferGeometry
- */
-export declare function createGeometryFromArrays(vertices: Float32Array, indices: Uint32Array, vertexColors?: Float32Array | undefined, colorSize?: number): THREE.BufferGeometry;
-/**
- * Returns a merged mesh of all meshes related to given instances along with picking related metadata
- * Returns undefined if mesh would be empty
- * @param section mesh sections to include in the merged mesh.
- * @param transparent true to use a transparent material.
- * @param instances instances for which to merge meshes.
- */
-export declare function mergeInstanceMeshes(g3d: G3d, mergeArgs: MergeArgs): MergeResult;
-/**
- * Returns a merged mesh of all unique meshes along with picking related metadata
- * @param section mesh sections to include in the merged mesh.
- * @param transparent true to use a transparent material.
- * @param instances instances for which to merge meshes.
- */
-export declare function mergeUniqueMeshes(g3d: G3d, args: MergeArgs): MergeResult;
-/**
- * Holds the info that needs to be precomputed for a merge.
- */
-export declare class MergeInfo {
-    section: MeshSection;
-    transparent: boolean;
-    instances: number[];
-    indexCount: number;
-    vertexCount: number;
-    constructor(section: MeshSection, transparent: boolean, instance: number[], indexCount: number, vertexCount: number);
-    createBuffer(): MergeBuffer;
-}
-/**
- * Allocates and holds all arrays needed to merge meshes.
- */
-export declare class MergeBuffer {
-    indices: Uint32Array;
-    vertices: Float32Array;
-    colors: Float32Array;
-    groups: number[];
-    colorSize: number;
-    boxes: THREE.Box3[];
-    constructor(info: MergeInfo, positionSize: number, colorSize: number);
-    toBufferGeometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
-}
-/**
- * Holds the result from a merge operation.
- */
-export declare class MergeResult {
-    geometry: THREE.BufferGeometry;
-    instances: number[];
-    submeshes: number[];
-    boxes: THREE.Box3[];
-    constructor(geometry: THREE.BufferGeometry, instance: number[], submeshes: number[], boxes: THREE.Box3[]);
-}

package/dist/types/core-viewers/webgl/loader/index.d.ts

@@ -1,24 +0,0 @@
-export type { VimSettings, VimPartialSettings } from './vimSettings';
-export * from './vimCollection';
-export type { RequestSource, LoadRequest, ILoadRequest } from './progressive/loadRequest';
-export * as Materials from './materials';
-export type { Transparency } from './geometry';
-export type * from './webglAttribute';
-export type * from './colorAttribute';
-export type * from './element3d';
-export type * from './elementMapping';
-export type * from './mesh';
-export type * from './scene';
-export type * from './vim';
-export type * from './progressive/g3dOffsets';
-export type * from './progressive/g3dSubset';
-export type * from './progressive/insertableGeometry';
-export type * from './progressive/insertableMesh';
-export type * from './progressive/insertableSubmesh';
-export type * from './progressive/instancedMesh';
-export type * from './progressive/instancedMeshFactory';
-export type * from './progressive/instancedSubmesh';
-export type * from './progressive/legacyMeshFactory';
-export type * from './progressive/loadingSynchronizer';
-export type * from './progressive/subsetBuilder';
-export type * from './progressive/subsetRequest';

package/dist/types/core-viewers/webgl/loader/materials/ghostMaterial.d.ts

@@ -1,16 +0,0 @@
-/**
- * @module vim-loader/materials
- * This module provides materials for rendering specific visualization modes in VIM.
- */
-import * as THREE from 'three';
-/**
- * Creates a material for the ghost effect in isolation mode.
- *
- * - **Non-visible items**: Rendered as transparent objects using a customizable fill color.
- * - **Visible items**: Completely excluded from rendering.
- * - Designed for use with instanced or merged meshes.
- * - Includes clipping plane support, vertex colors, and transparency.
- *
- * @returns {THREE.ShaderMaterial} A custom shader material for the ghost effect.
- */
-export declare function createGhostMaterial(): THREE.ShaderMaterial;

package/dist/types/core-viewers/webgl/loader/materials/index.d.ts

@@ -1,10 +0,0 @@
-export * from './ghostMaterial';
-export * from './maskMaterial';
-export * from './materials';
-export * from './mergeMaterial';
-export * from './outlineMaterial';
-export * from './pickingMaterial';
-export * from './simpleMaterial';
-export * from './skyboxMaterial';
-export * from './standardMaterial';
-export * from './transferMaterial';

package/dist/types/core-viewers/webgl/loader/materials/maskMaterial.d.ts

@@ -1,8 +0,0 @@
-/**
- * @module vim-loader/materials
- */
-import * as THREE from 'three';
-/**
- * Material used for selection outline it only renders selection in white and discards the rests.
- */
-export declare function createMaskMaterial(): THREE.ShaderMaterial;

package/dist/types/core-viewers/webgl/loader/materials/materials.d.ts

@@ -1,161 +0,0 @@
-/**
- * @module vim-loader/materials
- */
-import * as THREE from 'three';
-import { StandardMaterial } from './standardMaterial';
-import { OutlineMaterial } from './outlineMaterial';
-import { ViewerSettings } from '../../viewer/settings/viewerSettings';
-import { MergeMaterial } from './mergeMaterial';
-import { SkyboxMaterial } from './skyboxMaterial';
-export type ModelMaterial = THREE.Material | THREE.Material[] | undefined;
-/**
- * Defines the materials to be used by the vim loader and allows for material injection.
- */
-export declare class Materials {
-    static instance: Materials;
-    static createInstance(instance: Materials): void;
-    static getInstance(): Materials;
-    /**
-     * Material used for opaque model geometry.
-     */
-    readonly opaque: StandardMaterial;
-    /**
-     * Material used for transparent model geometry.
-     */
-    readonly transparent: StandardMaterial;
-    /**
-     * Material used for maximum performance.
-     */
-    readonly simple: THREE.Material;
-    /**
-     * Material used when creating wireframe geometry of the model.
-     */
-    readonly wireframe: THREE.LineBasicMaterial;
-    /**
-     * Material used to show traces of hidden objects.
-     */
-    readonly ghost: THREE.Material;
-    /**
-     * Material used to filter out what is not selected for selection outline effect.
-     */
-    readonly mask: THREE.ShaderMaterial;
-    /**
-     * Material used for selection outline effect.
-     */
-    readonly outline: OutlineMaterial;
-    /**
-     * Material used for the skybox effect.
-     */
-    readonly skyBox: SkyboxMaterial;
-    /**
-     * Material used to merge outline effect with scene render.
-     */
-    readonly merge: MergeMaterial;
-    private _clippingPlanes;
-    private _sectionStrokeWitdh;
-    private _sectionStrokeFallof;
-    private _sectionStrokeColor;
-    private _focusIntensity;
-    private _focusColor;
-    private _onUpdate;
-    constructor(opaque?: StandardMaterial, transparent?: StandardMaterial, simple?: THREE.Material, wireframe?: THREE.LineBasicMaterial, ghost?: THREE.Material, mask?: THREE.ShaderMaterial, outline?: OutlineMaterial, merge?: MergeMaterial, skyBox?: SkyboxMaterial);
-    /**
-     * Updates material settings based on the provided configuration.
-     * @param {ViewerSettings} settings - The settings to apply to the materials.
-     */
-    applySettings(settings: ViewerSettings): void;
-    /**
-     * A signal dispatched whenever a material is modified.
-     */
-    get onUpdate(): import("ste-signals").ISignal;
-    /**
-     * Determines the color of the model regular opaque and transparent materials.
-     */
-    get modelColor(): THREE.Color;
-    set modelColor(color: THREE.Color);
-    /**
-     * Determines the opacity of the ghost material.
-     */
-    get ghostOpacity(): number;
-    set ghostOpacity(opacity: number);
-    /**
-     * Determines the color of the ghost material.
-     */
-    get ghostColor(): THREE.Color;
-    set ghostColor(color: THREE.Color);
-    /**
-     * Determines the color intensity of the highlight effect on mouse hover.
-     */
-    get focusIntensity(): number;
-    set focusIntensity(value: number);
-    /**
-     * Determines the color of the highlight effect on mouse hover.
-     */
-    get focusColor(): THREE.Color;
-    set focusColor(value: THREE.Color);
-    /**
-     * Determines the color of wireframe meshes.
-     */
-    get wireframeColor(): THREE.Color;
-    set wireframeColor(value: THREE.Color);
-    /**
-     * Determines the opacity of wireframe meshes.
-     */
-    get wireframeOpacity(): number;
-    set wireframeOpacity(value: number);
-    /**
-     * The clipping planes applied to all relevent materials
-     */
-    get clippingPlanes(): THREE.Plane[] | undefined;
-    set clippingPlanes(value: THREE.Plane[] | undefined);
-    /**
-     * The width of the stroke effect where the section box intersects the model.
-     */
-    get sectionStrokeWitdh(): number;
-    set sectionStrokeWitdh(value: number);
-    /**
-     * Gradient of the stroke effect where the section box intersects the model.
-     */
-    get sectionStrokeFallof(): number;
-    set sectionStrokeFallof(value: number);
-    /**
-     * Color of the stroke effect where the section box intersects the model.
-     */
-    get sectionStrokeColor(): THREE.Color;
-    set sectionStrokeColor(value: THREE.Color);
-    /**
-     * Color of the selection outline effect.
-     */
-    get outlineColor(): THREE.Color;
-    set outlineColor(value: THREE.Color);
-    get outlineAntialias(): boolean;
-    set outlineAntialias(value: boolean);
-    /**
-     * Size of the blur convolution on the selection outline effect. Minimum 2.
-     */
-    get outlineBlur(): number;
-    set outlineBlur(value: number);
-    /**
-     * Gradient of the the selection outline effect.
-     */
-    get outlineFalloff(): number;
-    set outlineFalloff(value: number);
-    /**
-     * Intensity of the the selection outline effect.
-     */
-    get outlineIntensity(): number;
-    set outlineIntensity(value: number);
-    get skyboxSkyColor(): THREE.Color;
-    set skyboxSkyColor(value: THREE.Color);
-    get skyboxGroundColor(): THREE.Color;
-    set skyboxGroundColor(value: THREE.Color);
-    get skyboxSharpness(): number;
-    set skyboxSharpness(value: number);
-    /** dispose all materials. */
-    dispose(): void;
-}
-/**
- * Creates a new instance of the default wireframe material.
- * @returns {THREE.LineBasicMaterial} A new instance of LineBasicMaterial.
- */
-export declare function createWireframe(): THREE.LineBasicMaterial;

package/dist/types/core-viewers/webgl/loader/materials/mergeMaterial.d.ts

@@ -1,18 +0,0 @@
-/**
- * @module vim-loader/materials
- */
-import * as THREE from 'three';
-export declare class MergeMaterial {
-    material: THREE.ShaderMaterial;
-    constructor();
-    get color(): THREE.Color;
-    set color(value: THREE.Color);
-    get sourceA(): THREE.Texture;
-    set sourceA(value: THREE.Texture);
-    get sourceB(): THREE.Texture;
-    set sourceB(value: THREE.Texture);
-}
-/**
- * Material that Merges current fragment with a source texture.
- */
-export declare function createMergeMaterial(): THREE.ShaderMaterial;

package/dist/types/core-viewers/webgl/loader/materials/outlineMaterial.d.ts

@@ -1,78 +0,0 @@
-/**
- * @module vim-loader/materials
- */
-import * as THREE from 'three';
-/** Outline Material based on edge detection. */
-export declare class OutlineMaterial {
-    material: THREE.ShaderMaterial;
-    private _camera;
-    private _resolution;
-    private _precision;
-    private _antialias;
-    constructor(options?: Partial<{
-        sceneBuffer: THREE.Texture;
-        resolution: THREE.Vector2;
-        precision: number;
-        antialias: boolean;
-        camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    }>);
-    /**
-     * Enable antialiasing for the outline.
-     * This is actually applied in the rendering composer.
-     */
-    get antialias(): boolean;
-    set antialias(value: boolean);
-    /**
-     * Precision of the outline. This is used to scale the resolution of the outline.
-     */
-    get precision(): number;
-    set precision(value: number);
-    /**
-     * Resolution of the outline. This should match the resolution of screen.
-     */
-    get resolution(): THREE.Vector2;
-    set resolution(value: THREE.Vector2);
-    /**
-     * Camera used to render the outline.
-     */
-    get camera(): THREE.PerspectiveCamera | THREE.OrthographicCamera | undefined;
-    set camera(value: THREE.PerspectiveCamera | THREE.OrthographicCamera | undefined);
-    /**
-     * Blur of the outline. This is used to smooth the outline.
-     */
-    get strokeBlur(): number;
-    set strokeBlur(value: number);
-    /**
-     * Bias of the outline. This is used to control the strength of the outline.
-     */
-    get strokeBias(): number;
-    set strokeBias(value: number);
-    /**
-     * Multiplier of the outline. This is used to control the strength of the outline.
-     */
-    get strokeMultiplier(): number;
-    set strokeMultiplier(value: number);
-    /**
-     * Color of the outline.
-     */
-    get color(): THREE.Color;
-    set color(value: THREE.Color);
-    /**
-     * Scene buffer used to render the outline.
-     */
-    get sceneBuffer(): THREE.Texture;
-    set sceneBuffer(value: THREE.Texture);
-    /**
-     * Depth buffer used to render the outline.
-     */
-    get depthBuffer(): THREE.Texture;
-    set depthBuffer(value: THREE.Texture);
-    /**
-     * Dispose of the outline material.
-     */
-    dispose(): void;
-}
-/**
- * This material =computes outline using the depth buffer and combines it with the scene buffer to create a final scene.
- */
-export declare function createOutlineMaterial(): THREE.ShaderMaterial;