@x-viewer/core 0.9.0

package/dist/types/core/model/bimtiles/BatchedMeshesParser.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from "three";
+import { BatchData, MeshJsonData } from "./BimTilesData";
+/**
+ * Batched mesh.
+ */
+export interface BatchedMesh {
+    type: number;
+    position: THREE.TypedArray;
+    color: THREE.TypedArray;
+    normal: THREE.TypedArray;
+    indice: THREE.TypedArray;
+    uv: THREE.TypedArray;
+    tangent: THREE.TypedArray;
+    barycentric: THREE.TypedArray;
+    materialId: string;
+    userIds: number[];
+    batchTable: BatchData[];
+}
+/**
+ * Parses batched meshes of a tile.
+ */
+export declare class BatchedMeshesParser {
+    parse(buffer: ArrayBuffer, meshes: MeshJsonData[]): BatchedMesh[];
+    private parseMesh;
+    private parseTypedArray;
+}

package/dist/types/core/model/bimtiles/BimTilesConfigParser.d.ts

@@ -0,0 +1,43 @@
+import * as THREE from "three";
+export interface BimTilesConfigMetadata {
+    asset: string;
+    version: string;
+    generateTool?: string;
+    datetime: string;
+    root: string;
+    modelSize: number;
+}
+export interface BimTilesConfigStatistics {
+    elementCount: number;
+    batchElementCount: number;
+    instanceElementCount: number;
+    batchCount: number;
+    instanceCount: number;
+    tileCount: number;
+    userDataCount: number;
+    materialCount: number;
+    meshVertexCount: number;
+    meshFaceCount: number;
+    textureCount: number;
+    texturePixels: number;
+}
+interface BimTilesConfigView {
+    transform: THREE.Matrix4;
+    boundingVolume: THREE.Box3;
+}
+/**
+ * BimTiles config definition.
+ * A bimtiles has one config file.
+ */
+export declare class BimTilesConfigParser {
+    private url;
+    private metadata;
+    private statistics;
+    private view;
+    constructor(url: string);
+    parse(): Promise<boolean>;
+    getMetadata(): BimTilesConfigMetadata;
+    getStatistics(): BimTilesConfigStatistics;
+    getView(): BimTilesConfigView;
+}
+export {};

package/dist/types/core/model/bimtiles/BimTilesData.d.ts

@@ -0,0 +1,280 @@
+import * as THREE from "three";
+export declare const WEBGL_MAG_FILTERS: Record<number, THREE.MagnificationTextureFilter>;
+export declare const WEBGL_MIN_FILTERS: Record<number, THREE.MinificationTextureFilter>;
+export declare const WEBGL_WRAPPINGS: Record<number, THREE.Wrapping>;
+/**
+ * "Alpha mode" refers to the way in which transparency is handled.
+ */
+export declare enum AlphaMode {
+    /**
+     * No transparency, and the image is fully visible.
+     */
+    Opaque = "OPAQUE",
+    /**
+     * Transparency is achieved by using a separate mask layer that specifies which parts of the image should be transparent.
+     */
+    Mask = "MASK",
+    /**
+     * Transparency is achieved by blending the image with the background based on the alpha channel values of the image.
+     */
+    Blend = "BLEND"
+}
+/**
+ * BimTiles definition.
+ */
+export interface BimTilesJson {
+    asset: {
+        version: string;
+        generateTool: string;
+        datetime: string;
+    };
+    properties: {
+        material: {
+            url: string;
+        };
+        userData: {
+            url: string;
+        };
+        userId: {
+            url: string;
+            maxUserIdIndex: number;
+        };
+        userIdBox: {
+            url: string;
+        };
+    };
+    root: {
+        id: string;
+        transform: number[];
+        boundingVolume: number[];
+        refine: "replace" | "add";
+        geometricError: number;
+        content: {
+            uri: string;
+        };
+        children: [];
+    };
+}
+/**
+ * BimTiles material texture definition.
+ */
+export interface BimTilesMaterialTextureJson {
+    index: number;
+    texCoord: number;
+    transform?: {
+        offset: [number, number];
+        rotation: number;
+        scale: [number, number];
+    };
+}
+/**
+ * BimTiles materials definition.
+ */
+export interface BimTilesMaterialJson {
+    materials: {
+        /**
+         * The key is material id.
+         */
+        [key: string]: {
+            /**
+             * Material id, unique in this tile set
+             */
+            id: string;
+            name: string;
+            baseColorFactor: number[];
+            baseColorTexture: BimTilesMaterialTextureJson;
+            metallicFactor: number;
+            roughnessFactor: number;
+            metallicRoughnessTexture: BimTilesMaterialTextureJson;
+            doubleSided: boolean;
+            alphaMode: AlphaMode;
+            alphaCutoff: number;
+            normalTexture: BimTilesMaterialTextureJson;
+            emissiveFactor: number[];
+            emissiveTexture: BimTilesMaterialTextureJson;
+            occlusionTexture: BimTilesMaterialTextureJson;
+        };
+    };
+    textures: {
+        image: number;
+        sampler: number;
+    }[];
+    images: {
+        uri: string;
+        type: string;
+        width: number;
+        height: number;
+        dimensions: number;
+    }[];
+    samplers: {
+        magFilter: number;
+        minFilter: number;
+        wrapS: number;
+        wrapT: number;
+    }[];
+}
+/**
+ * BimTiles UserData definition.
+ * These userData are usually familyInstance attributes.
+ */
+export interface BimTilesUserDataJson {
+    /**
+     * Stores all userData's keys, case-sensitive.
+     * Because a lot of userData keys are the same, we can save space this way.
+     */
+    userDataKeys: string[];
+    /**
+     * Stores all userData's values, case-sensitive.
+     * Because a lot of userData values are the same, we can save space this way.
+     */
+    userDataValues: any[];
+    userDataItems: Record<number, number>[];
+}
+/**
+ * BimTiles UserId definition.
+ * A tile set has one userId file.
+ */
+export interface BimTilesUserIdJson {
+    /**
+     * Stores all modelIds of this tile set.
+     * ModelId is required, and must be unique in a tile set.
+     */
+    modelIds: string[];
+    /**
+     * Stores all familyInstanceIds for all models of this tile set.
+     * FamilyInstanceId is nice to have, otherwise, it'll generate one, but it won't be able to
+     * find an object's userData.
+     * A familyInstance may contain more than one primitives, thus may have more than one userIds.
+     */
+    familyInstanceIds: string[];
+    /**
+     * ModelId and familyInstanceIds map.
+     * One modelId contains at least one familyInstanceIds.
+     * The key is the index of modelIds array, we can find the modelId by this index.
+     * The value is the index array of familyInstanceIds, we can find familyInstanceIds by these indexes.
+     */
+    modelTable: Record<number, number[]>;
+    /**
+     * UserId and userData map.
+     * One userId maps to 0 or 1 userData.
+     * The key is userId.
+     * In order to get proper userData, we also need to know modelId and familyInstanceId.
+     * So, the value is a tuple of modelId index, familyInstanceId index and userData index.
+     * If a primitive doesn't has userData, the userData index is -1.
+     */
+    userIdTable: Record<number, [number, number, number]>;
+}
+/**
+ * UserId bounding box definition.
+ * The key is userId.
+ * The vlaue is bounding box value, in order of xmin, ymin, zmin, xmax, ymax, zmax.
+ */
+export type BimTilesUserIdBoxJson = Record<number, number[]>;
+export type BimTilesProperty = BimTilesMaterialJson | BimTilesUserDataJson | BimTilesUserIdJson | BimTilesUserIdBoxJson;
+export declare const WEBGL_COMPONENT_TYPES: {
+    int8: Int8ArrayConstructor;
+    uint8: Uint8ArrayConstructor;
+    int16: Int16ArrayConstructor;
+    uint16: Uint16ArrayConstructor;
+    int32: Int32ArrayConstructor;
+    uint32: Uint32ArrayConstructor;
+    float: Float32ArrayConstructor;
+    double: Float64ArrayConstructor;
+};
+interface ComponentTypes {
+    int8: Int8ArrayConstructor;
+    uint8: Uint8ArrayConstructor;
+    int16: Int16ArrayConstructor;
+    uint16: Uint16ArrayConstructor;
+    int32: Int32ArrayConstructor;
+    uint32: Uint32ArrayConstructor;
+    float: Float32ArrayConstructor;
+    double: Float64ArrayConstructor;
+}
+export declare enum WEBGL_TYPE_SIZES {
+    scalar = 1,
+    vec2 = 2,
+    vec3 = 3,
+    vec4 = 4,
+    mat2 = 4,
+    mat3 = 9,
+    mat4 = 16
+}
+/**
+ * Definition of a concrete instance.
+ */
+export interface Instance {
+    /**
+     * The transform of the instance.
+     */
+    transform: number[];
+    /**
+     * The userId of the instance.
+     */
+    userId: number;
+}
+/**
+ * Definition of an instanced mesh data and concrete instances.
+ */
+export interface InstancedMeshData {
+    blobId: number;
+    url: string;
+    instances: Instance[];
+}
+/**
+ * Definition of a buffer.
+ */
+export interface MeshBufferData {
+    byteOffset: number;
+    byteLength: number;
+    componentType: keyof ComponentTypes;
+    type: WEBGL_TYPE_SIZES;
+    count: number;
+    max?: number[];
+    min?: number[];
+}
+/**
+ * Definition for a primitive of a batch.
+ */
+export interface BatchData {
+    userId: number;
+    indexStart: number;
+    indexCount: number;
+    positionStart: number;
+    positionCount: number;
+}
+export interface MeshJsonData {
+    byteOffset: number;
+    byteLength: number;
+    buffers: MeshBufferData[];
+    primitive: {
+        type: number;
+        position: number;
+        normal: number;
+        tangent: number;
+        indice: number;
+        uv_0: number;
+        color?: number;
+        barycentric: number;
+        material: string;
+        materialId: string;
+        normalCompressed: boolean;
+    };
+    batchTable: BatchData[];
+}
+export interface InstancedMeshJsonData {
+    meshes: MeshJsonData[];
+}
+/**
+ * Definition of a tile.
+ * A tile can contain both instanced and batched mesh.
+ * A tile may contain part of (not all) primitives of an instance.
+ *   e.g., an instance has 10 concrete primitives, a tile may contain 3 of them.
+ * A tile may contain part of (not all) primitives of a batch.
+ *   e.g., a batch has 10 primitives, a tile may contain 3 of them.
+ */
+export interface TileJsonData {
+    instancedMeshes: InstancedMeshData[];
+    batchedMeshes: MeshJsonData[];
+}
+export {};

package/dist/types/core/model/bimtiles/BimTilesMaterialManager.d.ts

@@ -0,0 +1,139 @@
+import * as THREE from "three";
+import type { BimTilesRenderer } from "./BimTilesRenderer";
+import { TileObject } from "../Constants";
+import { BimTilesMaterial, BimTilesPickMaterial, BimTilesTransparentMaterial, BimTilesHighlightMaterial } from "../../../core/materials";
+/**
+ * Object state type, which can be "Hidden", "Transparent", "Highlighted" or "Hovered".
+ * Each tile object (maps to a userId) has a "color" (8 bytes) value that contains
+ * State types, opacity value, etc.
+ * - State types are stored in color.r
+ *   - bit 0: Hidden
+ *   - bit 1: Transparent
+ *   - bit 2: Hovered
+ *   - bit 3: Highlighted
+ *   - bit 4-7: not used for now
+ * - Opacity value is stored in color.g (value between 0 to 1)
+ * - color.b for transparent effect ( used by cloned mesh), currently only bit 0 is used.
+ * - color.a is not used for now
+ *
+ * All tile object states of a tileset are stored in a stateTexture,
+ * which will be send to GPU, thus GPU knows which tile object should
+ * be hidden/transparent/hovered/highlighted.
+ */
+export declare enum StateType {
+    /**
+     * Hide a tile object.
+     */
+    Hidden = 0,
+    /**
+     * Transparent is implemented by cloning objects' mesh (don't clone geometry) and
+     * apply a transparent material.
+     */
+    Transparent = 1,
+    /**
+     * We implement highlight by cloning mesh and apply a highlight material.
+     * There can be transparent objects and highlighted objects in the same time.
+     * But, one object is either transparent or highlighted.
+     */
+    Highlighted = 2,
+    /**
+     * There should only one object being hovered!
+     * We implement hover effect by blending an object's color in shader.
+     */
+    Hovered = 3
+}
+export declare class BimTilesMaterialManager {
+    private _pickMaterial?;
+    private _highlightMaterial?;
+    private _transparentMaterial?;
+    private stateTexture;
+    protected batchMaterialMap: Map<string, BimTilesMaterial>;
+    protected instanceMaterialMap: Map<string, BimTilesMaterial>;
+    tileRenderer: BimTilesRenderer;
+    highlightMesh?: THREE.Mesh;
+    constructor(tileRenderer: BimTilesRenderer, modelCfg: any);
+    createBatchMaterial(materialId: string, params?: THREE.MeshStandardMaterialParameters, hasBarycentric?: boolean): BimTilesMaterial | undefined;
+    createInstanceMaterial(materialId: string, params?: THREE.MeshStandardMaterialParameters, hasBarycentric?: boolean): BimTilesMaterial | undefined;
+    get highlightMaterial(): BimTilesHighlightMaterial;
+    get transparentMaterial(): BimTilesTransparentMaterial;
+    get pickMaterial(): BimTilesPickMaterial;
+    /**
+     * Creates a DataTexture to store objects' states.
+     * todo: The width and height of texture can't exceed the maximum size supported by the current gpu.
+     */
+    private createStateTexture;
+    /**
+     * Updates state.
+     * @param opacity Useful for StateType.Transparent, and when flag is true.
+     */
+    updateState(state: StateType, userIds: number[], flag: boolean, opacity?: number): void;
+    private setHiddenForTransparent;
+    private updateClonedTransparentMesh;
+    private clearClonedTransparentMesh;
+    private cloneMeshForTransparent;
+    private disposeClonedTransparentMesh;
+    private updateAllClonedTransparentMesh;
+    private clearAllClonedTransparentMesh;
+    /**
+     * Sets current tileset visible or invisible.
+     */
+    setHidden(flag: boolean): void;
+    /**
+     * Sets current tileset's opacity.
+     * @param opacity A value between 0 and 1, and will be converted to 0-255.
+     * opacity is 1 means to clear opacity.
+     */
+    setOpacity(opacity: number): void;
+    /**
+     * Clears hovered object.
+     * We don't store the hovered userId, simply clear the flag for all userIds.
+     */
+    clearHovered(): void;
+    updateHighlightMesh(): void;
+    clearHighlightMesh(): void;
+    clearState(state: StateType): void;
+    setDoubleSidedMaterials(): void;
+    revertDoubleSidedMaterials(): void;
+    setClipPlanes(planes: THREE.Plane[]): void;
+    resetState(): void;
+    updateMaterialStates(): void;
+    dispose(): void;
+    private disposeMesh;
+    /**
+     * Checks if there is any visible object.
+     */
+    hasVisibleObject(): boolean;
+    /**
+     * Checks if there is any invisible object.
+     */
+    hasInvisibleObject(): boolean;
+    /**
+     * Get transparent userIds.
+     */
+    getTransparentUserIds(): number[];
+    /**
+     * Get highlight userIds.
+     */
+    getHighlightUserIds(): number[];
+    /**
+     * Gets the hovered object if any.
+     */
+    getHoveredObject(): TileObject | undefined;
+    /**
+     * Converts an opacity value between 0-1 to value 0-255. For values:
+     * 0: actually equals to hidden, we'll convert it to 1 in shader.
+     * [0, 1): will be mapped to integer between [1, 255]
+     * 1: will be mapped to 0 in shader.
+     */
+    private opacity2Int8;
+    /**
+     * Sets the flag(0 or 1) of a number by given StateType.
+     * @param num A number between 0 and 255.
+     */
+    private setFlag;
+    /**
+     * Gets the flag(0 or 1) from a number by given StateType.
+     * @param num A number between 0 and 255.
+     */
+    private getFlag;
+}

package/dist/types/core/model/bimtiles/BimTilesModel.d.ts

@@ -0,0 +1,67 @@
+import * as THREE from "three";
+import { BimTilesConfigMetadata, BimTilesConfigParser, BimTilesConfigStatistics } from "./BimTilesConfigParser";
+import { BimTilesMaterialManager } from "./BimTilesMaterialManager";
+import { BimTilesRenderer } from "./BimTilesRenderer";
+import { TileObject, ModelData3d } from "../Constants";
+import { Model } from "../Model";
+export declare class BimTilesModel extends Model {
+    /**
+     * ModelId for BimTiles is actually tilesetId, it is a number (0-255), but we use it as a string.
+     */
+    modelId: string;
+    _bbox?: THREE.Box3;
+    tilesRenderer: BimTilesRenderer;
+    metadata: BimTilesConfigMetadata;
+    statistics: BimTilesConfigStatistics;
+    constructor(modelData: ModelData3d, baseUrl: string, bimTilesCfg: BimTilesConfigParser);
+    getTilesRenderer(): BimTilesRenderer;
+    get materialManager(): BimTilesMaterialManager;
+    get propertyParser(): import("./BimTilesPropertyParser").BimTilesPropertyParser;
+    get highlighUsageGroup(): THREE.Group<THREE.Object3DEventMap>;
+    get transparentUsageGroup(): THREE.Group<THREE.Object3DEventMap>;
+    get pickUsageGroup(): THREE.Group<THREE.Object3DEventMap>;
+    getModelObject(): THREE.Object3D;
+    private traverseObjectByUserId;
+    getObjectByUserId(userId: number): THREE.Object3D | undefined;
+    getBBox(): THREE.Box3;
+    setObjectHoveredByUserId(userId: number, hovered: boolean): void;
+    clearHovered(): void;
+    /**
+     * Highlights an object by userId.
+     */
+    setObjectHighlightedByUserIds(userIds: number[], highlight: boolean): void;
+    clearHighlight(): void;
+    setDoubleSidedMaterials(): void;
+    revertDoubleSidedMaterials(): void;
+    setObjectOpacityByUserIds(userIds: number[], opacity: number): void;
+    clearObjectOpacityByUserIds(userIds: number[]): void;
+    setOpacity(opacity: number): void;
+    clearOpacity(): void;
+    /**
+     * Sets current tileset visible or invisible.
+     */
+    setVisible(visible: boolean): void;
+    setObjectVisibleByUserIds(userIds: number[], visible: boolean): void;
+    /**
+     * Checks if there is any visible object.
+     */
+    hasVisibleObject(): boolean;
+    /**
+     * Checks if there is any invisible object.
+     */
+    hasInvisibleObject(): boolean;
+    /**
+     * Gets the hovered object if any.
+     */
+    getHoveredObject(): TileObject | undefined;
+    getBBoxByUserId(userId: number): THREE.Box3 | undefined;
+    getUserDataByUserId(userId: number): Record<string, any> | undefined;
+    /**
+     * Gets all userIds of a tileset.
+     */
+    getUserIds(): number[];
+    getUserId(modelId: string, familyInstanceId: string): number[];
+    getUserData(modelId: string, familyInstanceId: string): Record<string, any> | undefined;
+    getUserIdByFilter(filter: (userData: Record<string, any>) => boolean): number[];
+    setClipPlanes(planes: THREE.Plane[]): void;
+}

package/dist/types/core/model/bimtiles/BimTilesPropertyParser.d.ts

@@ -0,0 +1,42 @@
+import * as protobuf from "protobufjs";
+import * as THREE from "three";
+import { BimTilesMaterialJson, BimTilesUserDataJson, BimTilesUserIdJson, BimTilesUserIdBoxJson } from "./BimTilesData";
+export declare class BimTilesPropertyParser {
+    private baseUrl;
+    private textureLoaderCache;
+    private materialCache;
+    private textureCache;
+    private userDataCache;
+    private familyInstanceIdCache;
+    private familyInstanceAndUserIdsCache;
+    private userIdAndUserDataCache;
+    private userBoxCache;
+    private protoRoot;
+    preprocessURL: ((uri: string | URL) => string) | null;
+    constructor(baseUrl: string, protoRoot: protobuf.Root);
+    getProperty(url: string, fetchOptions: RequestInit | undefined, protobufType: string): Promise<any>;
+    private getPropertyFromJson;
+    private getPropertyFromBinary;
+    private getTextureLoader;
+    private loadTexture;
+    private assignTexture;
+    parseMaterial(json: BimTilesMaterialJson): Promise<void>;
+    parseUserData(json: BimTilesUserDataJson): void;
+    parseUserId(json: BimTilesUserIdJson): void;
+    parseUserIdBox(json: BimTilesUserIdBoxJson, parentMatrix?: THREE.Matrix4): void;
+    getMaterialParameters(userId: string): THREE.MeshStandardMaterialParameters | undefined;
+    getUserData(userId: number): Record<string, any> | undefined;
+    getFamilyInstanceIdsByModelId(modelId: string): string[] | undefined;
+    getUserIdBox(userId: number): THREE.Box3 | undefined;
+    /**
+     * Gets all userIds of a model.
+     */
+    getUserIds(): number[];
+    /**
+     * Gets all userIds of the modelId and familyInstanceId
+     */
+    getUserIdsByFamilyInstanceId(modelId: string, familyInstanceId: string): number[];
+    private getUserIdByUserDataIndex;
+    getUserIdByFilter(filter: (userData: Record<string, any>) => boolean): number[];
+    dispose(): void;
+}

package/dist/types/core/model/bimtiles/BimTilesRenderer.d.ts

@@ -0,0 +1,49 @@
+import { Tile, TilesRenderer } from "3d-tiles-renderer";
+import * as THREE from "three";
+import { BimTilesJson } from "./BimTilesData";
+import { BimTilesMaterialManager } from "./BimTilesMaterialManager";
+import { BimTilesPropertyParser } from "./BimTilesPropertyParser";
+/**
+ * @link https://github.com/NASA-AMMOS/3DTilesRendererJS/blob/v0.3.32/src/three/TilesRenderer.js
+ * @example
+ * BimTilesRenderer
+ *     |
+ * tileRender.loadRootTileSet(tileSet)
+ *     |
+ * tileRender.update()
+ *     |
+ * traverse tile
+ *     |
+ * tileRender.requestTileContents(tile) --------- downloadQueue, parseQueue
+ *                                                         |
+ *                                                tileRender.tileInView(tile)
+ *                                                         |
+ * tileRender.setTileVisible(tile, visible)------- tileRender.calculateError(tile)
+ */
+export declare class BimTilesRenderer extends TilesRenderer {
+    highlighUsage: THREE.Group;
+    transparentUsage: THREE.Group;
+    pickUsage: THREE.Group;
+    materialManager?: BimTilesMaterialManager;
+    baseUrl: string;
+    propertyParser: BimTilesPropertyParser;
+    tilesetId: number;
+    onBeforeParseTile?: (tile: Tile) => void;
+    private protoRoot;
+    constructor(url: string, tilesetId: number);
+    private getVertexColorArray;
+    private createBatchedMesh;
+    private createInstancedMesh;
+    /**
+     * Gets cloned geometries by given userIds.
+     */
+    getGeometryByUserIds(userIds: number[]): THREE.BufferGeometry;
+    parseTile(buffer: ArrayBuffer, tile: any, extension: any): Promise<void>;
+    disposeTile(tile: any): void;
+    preprocessNode(tile: any, tileSetDir: string, parentTile?: Tile): void;
+    fetchTileSet(url: string, fetchOptions: RequestInit, parent?: undefined): Promise<BimTilesJson>;
+    loadRootTileSet(url: string): Promise<any>;
+    update(): void;
+    setTileVisible(tile: any, visible: boolean): void;
+    calculateError(tile: Tile): void;
+}

package/dist/types/core/model/bimtiles/InstancedMeshesParser.d.ts

@@ -0,0 +1,37 @@
+import * as THREE from "three";
+import { InstancedMeshData } from "./BimTilesData";
+export interface InstancedMesh {
+    type: number;
+    position: THREE.TypedArray;
+    color: THREE.TypedArray;
+    normal: THREE.TypedArray;
+    indice: THREE.TypedArray;
+    uv: THREE.TypedArray;
+    tangent: THREE.TypedArray;
+    barycentric: THREE.TypedArray;
+    userIds: number[];
+    matrices: number[];
+    materialId: string;
+}
+/**
+ * Parses instanced meshes of a tile.
+ */
+export declare class InstancedMeshesParser {
+    header?: {
+        magic: string;
+        version: number;
+        byteLength: number;
+    };
+    static instanceDataMap: Record<string, InstancedMesh[]>;
+    parse(instMeshDataArray: InstancedMeshData[], baseUrl: string, protoRoot?: protobuf.Root): Promise<InstancedMesh[]>;
+    private parseInstanceBuffer;
+    private parseInstanceProto;
+    private parseMeshes;
+    private parseMesh;
+    private parseTypedArray;
+    /**
+     * Get InstancedMesh from cache or online.
+     * @param url Instance full url for a particular LoD.
+     */
+    private getInstancedMeshByUrlAndBlobId;
+}

package/dist/types/core/model/bimtiles/TileParser.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Parses a tile.
+ */
+export declare class TileParser {
+    parse(buffer: ArrayBuffer, baseUrl: string, protoRoot: protobuf.Root): Promise<{
+        batchedMeshes: import("./BatchedMeshesParser").BatchedMesh[];
+        instancedMeshes: import("./InstancedMeshesParser").InstancedMesh[];
+    }>;
+    private parseBinary;
+    private parseProto;
+}