@jdultra/threedtiles 10.0.1 → 10.0.2

package/dist/tileset/OGC3DTile.d.ts

@@ -0,0 +1,123 @@
+/**
+ * class representing a tiled and multileveled mesh or point-cloud according to the OGC3DTiles 1.1 spec
+ * @class
+ * @extends THREE.Object3D
+ */
+export class OGC3DTile {
+    /**
+     * @param {Object} [properties] - the properties for this tileset
+     * @param {THREE.Renderer} [properties.renderer] - the renderer used to display the tileset
+     * @param {String} [properties.url] - the url to the parent tileset.json
+     * @param {String} [properties.queryParams] - optional, path params to add to individual tile urls (starts with "?").
+     * @param {Number} [properties.geometricErrorMultiplier] - the geometric error of the parent. 1.0 by default corresponds to a maxScreenSpaceError of 16
+     * @param {Boolean} [properties.loadOutsideView] - if truthy, tiles otside the camera frustum will be loaded with the least possible amount of detail
+     * @param {TileLoader} [properties.tileLoader] - A tile loader that can be shared among tilesets in order to share a common cache.
+     * @param {Function} [properties.meshCallback] - A callback function that will be called on every mesh
+     * @param {Function} [properties.pointsCallback] - A callback function that will be called on every points
+     * @param {Function} [properties.onLoadCallback] - A callback function that will be called when the root tile has been loaded
+     * @param {OcclusionCullingService} [properties.occlusionCullingService] - A service that handles occlusion culling
+     * @param {Boolean} [properties.centerModel] - If true, the tileset will be centered on 0,0,0 and in the case of georeferenced tilesets that use the "region" bounding volume, it will also be rotated so that the up axis matched the world y axis.
+     * @param {Boolean} [properties.static] - If true, the tileset is considered static which improves performance but the matrices aren't automatically updated
+     * @param {String} [properties.rootPath] - optional the root path for fetching children
+     * @param {String} [properties.json] - optional json object representing the tileset sub-tree
+     * @param {Number} [properties.parentGeometricError] - optional geometric error of the parent
+     * @param {Object} [properties.parentBoundingVolume] - optional bounding volume of the parent
+     * @param {String} [properties.parentRefine] - optional refine strategy of the parent of the parent
+     * @param {THREE.Camera} [properties.cameraOnLoad] - optional the camera used when loading this particular sub-tile
+     * @param {OGC3DTile} [properties.parentTile] - optional the OGC3DTile object that loaded this tile as a child
+     * @param {String} [properties.proxy] - optional the url to a proxy service. Instead of fetching tiles via a GET request, a POST will be sent to the proxy url with the real tile address in the body of the request.
+     * @param {Boolean} [properties.displayErrors] - optional value indicating that errors should be shown on screen.
+     */
+    constructor(properties?: {
+        renderer?: any;
+        url?: string | undefined;
+        queryParams?: string | undefined;
+        geometricErrorMultiplier?: number | undefined;
+        loadOutsideView?: boolean | undefined;
+        tileLoader?: TileLoader | undefined;
+        meshCallback?: Function | undefined;
+        pointsCallback?: Function | undefined;
+        onLoadCallback?: Function | undefined;
+        occlusionCullingService?: any;
+        centerModel?: boolean | undefined;
+        static?: boolean | undefined;
+        rootPath?: string | undefined;
+        json?: string | undefined;
+        parentGeometricError?: number | undefined;
+        parentBoundingVolume?: Object | undefined;
+        parentRefine?: string | undefined;
+        cameraOnLoad?: any;
+        parentTile?: OGC3DTile | undefined;
+        proxy?: string | undefined;
+        displayErrors?: boolean | undefined;
+    } | undefined);
+    proxy: string | undefined;
+    displayErrors: boolean | undefined;
+    displayCopyright: boolean;
+    queryParams: any;
+    uuid: any;
+    tileLoader: TileLoader;
+    /**
+     * To be called in the render loop.
+     * @param {Three.Camera} camera a camera that the tileset will be rendered with.
+     */
+    update(camera: Three.Camera): void;
+    geometricErrorMultiplier: number;
+    renderer: any;
+    meshCallback: Function | undefined;
+    loadOutsideView: boolean | undefined;
+    cameraOnLoad: any;
+    parentTile: OGC3DTile | undefined;
+    occlusionCullingService: any;
+    static: boolean | undefined;
+    color: any;
+    colorID: number | undefined;
+    matrixAutoUpdate: boolean | undefined;
+    matrixWorldAutoUpdate: boolean | undefined;
+    childrenTiles: any[];
+    meshContent: any[];
+    materialVisibility: boolean;
+    inFrustum: boolean;
+    level: any;
+    hasMeshContent: number;
+    hasUnloadedJSONContent: number;
+    centerModel: boolean | undefined;
+    abortController: AbortController;
+    _setup(properties: any): Promise<void>;
+    rootPath: any;
+    isSetup: boolean | undefined;
+    _assembleURL(root: any, relative: any): string;
+    _extractQueryParams(url: any, params: any): string;
+    _load(): Promise<void>;
+    /**
+     * Disposes of all the resources used by the tileset.
+     */
+    dispose(): void;
+    deleted: boolean | undefined;
+    parent: any;
+    _disposeChildren(): void;
+    children: any[] | undefined;
+    _update(camera: any, frustum: any): void;
+    _areAllChildrenLoadedAndHidden(): boolean;
+    /**
+     * Node is ready if it is outside frustum, if it was drawn at least once or if all it's children are ready
+     * @returns true if ready
+     */
+    _isReady(): boolean;
+    _changeContentVisibility(visibility: any): void;
+    meshDisplayed: boolean | undefined;
+    _calculateUpdateMetric(camera: any, frustum: any): number;
+    _getSiblings(): any[];
+    _calculateDistanceToCamera(camera: any): number;
+    /**
+     * Set the Geometric Error Multiplier for the tileset.
+     * the {@param geometricErrorMultiplier} can be a number between 1 and infinity.
+     * A {@param geometricErrorMultiplier} of 1 (default) corresponds to a max ScreenSpace error (MSE) of 16.
+     * A lower {@param geometricErrorMultiplier} loads less detail (higher MSE) and a higher {@param geometricErrorMultiplier} loads more detail (lower MSE)
+     *
+     * @param {Number} geometricErrorMultiplier set the LOD multiplier for the entire tileset
+     */
+    setGeometricErrorMultiplier(geometricErrorMultiplier: number): void;
+    _transformWGS84ToCartesian(lon: any, lat: any, h: any, sfct: any): void;
+}
+import { TileLoader } from "./TileLoader";

package/dist/tileset/OcclusionCullingService.d.ts

@@ -0,0 +1,31 @@
+/**
+ * An occlusion culling service that helps to only refine tiles that are visible.
+ * This occlusion culling has a cost but allows downloading much less data.
+ * For models that have a lot of geometry that is often hidden from the camera by walls, this can greatly improve the frame-rate.
+ * @class
+ */
+export class OcclusionCullingService {
+    cullMap: any[];
+    cullMaterial: any;
+    cullTarget: any;
+    cullPixels: Uint8Array;
+    /**
+     *
+     * @param {Integer} side use THREE.FrontSide, THREE.BackSide or THREE.DoubleSide (FrontSide default)
+     */
+    setSide(side: Integer): void;
+    _createCullTarget(): any;
+    /**
+     * Update function to be called on every frame in the render loop.
+     * @param {THREE.scene} scene
+     * @param {THREE.Renderer} renderer
+     * @param {THREE.camera} camera
+     */
+    update(scene: THREE.scene, renderer: THREE.Renderer, camera: THREE.camera): void;
+    /**
+     * check if the given tile ID was visible in the last rendered frame.
+     * @param {string|Number} id
+     * @returns true if tile is visible
+     */
+    hasID(id: string | number): any;
+}

package/dist/tileset/TileLoader.d.ts

@@ -0,0 +1,78 @@
+/**
+ * A Tile loader that manages caching and load order.
+ * The cache is an LRU cache and is defined by the number of items it can hold.
+ * The actual number of cached items might grow beyond max if all items are in use.
+ *
+ * The load order is designed for optimal perceived loading speed (nearby tiles are refined first).
+ * @class
+ */
+export class TileLoader {
+    /**
+     * Creates a tile loader with a maximum number of cached items and callbacks.
+     * The only required property is a renderer that will be used to visualize the tiles.
+     * The maxCachedItems property is the size of the cache in number of objects, mesh tile and tileset.json files.
+     * The mesh and point callbacks will be called for every incoming mesh or points.
+     *
+     *
+     *
+     * @param {Object} [options] - Optional configuration object.
+     * @param {renderer} [options.renderer] - The renderer, this is required for KTX2 support.
+     * @param {number} [options.maxCachedItems=100] - the cache size.
+     * @param {function} [options.meshCallback = undefined] - A callback to call on newly decoded meshes.
+     * @param {function} [options.pointsCallback = undefined] - A callback to call on newly decoded points.
+     * @param {sring} [options.proxy = undefined] - An optional proxy that tile requests will be directed too as POST requests with the actual tile url in the body of the request.
+     */
+    constructor(options?: {
+        renderer?: any;
+        maxCachedItems?: number | undefined;
+        meshCallback?: Function | undefined;
+        pointsCallback?: Function | undefined;
+        proxy?: any;
+    } | undefined);
+    maxCachedItems: number;
+    proxy: any;
+    meshCallback: Function | undefined;
+    pointsCallback: Function | undefined;
+    gltfLoader: any;
+    b3dmDecoder: B3DMDecoder;
+    cache: any;
+    register: {};
+    ready: any[];
+    downloads: any[];
+    nextReady: any[];
+    nextDownloads: any[];
+    /**
+     * To be called in the render loop or at regular intervals.
+     * launches tile downloading and loading in an orderly fashion.
+     */
+    update(): void;
+    _scheduleDownload(f: any): void;
+    _download(): void;
+    _meshReceived(cache: any, register: any, key: any, distanceFunction: any, getSiblings: any, level: any, uuid: any): void;
+    _loadBatch(): 0 | 1;
+    _getNextDownloads(): void;
+    _getNextReady(): void;
+    /**
+     * Schedules a tile content to be downloaded
+     *
+     * @param {AbortController} abortController
+     * @param {string|Number} tileIdentifier
+     * @param {string} path
+     * @param {Function} callback
+     * @param {Function} distanceFunction
+     * @param {Function} getSiblings
+     * @param {Number} level
+     * @param {Boolean} sceneZupToYup
+     * @param {Boolean} meshZupToYup
+     * @param {Number} geometricError
+     */
+    get(abortController: AbortController, tileIdentifier: string | number, path: string, callback: Function, distanceFunction: Function, getSiblings: Function, level: number, sceneZupToYup: boolean, meshZupToYup: boolean, geometricError: number): void;
+    /**
+     *  unregisters a tile content for a specific tile, removing it from the cache if no other tile is using the same content.
+     * @param {string} path the content path/url
+     * @param {string|Number} tileIdentifier the tile ID
+     */
+    invalidate(path: string, tileIdentifier: string | number): void;
+    _checkSize(): void;
+}
+import { B3DMDecoder } from "../decoder/B3DMDecoder";

package/dist/tileset/implicit/ImplicitTileResolver.d.ts

@@ -0,0 +1 @@
+export function resolveImplicite(rootTile: any, url: any): Promise<any>;

package/dist/tileset/implicit/SubtreeDecoder.d.ts

@@ -0,0 +1 @@
+export function fetchAndDecodeSubtree(url: any): Promise<any>;

package/dist/tileset/instanced/InstancedOGC3DTile.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Similarly to {@link OGC3DTile}, this class that extends THREE.Object3D loads a tiled and multileveled OGC3DTiles 1.0 or 1.1 dataset.
+ * The difference is that tiles are instanced. This is useful when one wants to load the same tileset hundreds or even thousands of times.
+ * Imagine rendering hundreds of very high detail cars driving in a city.
+ * Each tile content is instanced but each {@link InstancedOGC3DTile} object also has it's own LOD tree making this scenario very efficient.
+ * @class
+ */
+export class InstancedOGC3DTile {
+    /**
+     *
+     * @param {Object} [properties] - the properties for this tileset
+     * @param {Object} [properties.renderer] - the renderer used to display the tileset
+     * @param {Object} [properties.url] - the url to the parent tileset.json
+     * @param {Object} [properties.pathParams] - optional, path params to add to individual tile urls (starts with "?").
+     * @param {Object} [properties.geometricErrorMultiplier] - the geometric error of the parent. 1.0 by default corresponds to a maxScreenSpaceError of 16
+     * @param {Object} [properties.loadOutsideView] - if truthy, tiles otside the camera frustum will be loaded with the least possible amount of detail
+     * @param {Object} [properties.tileLoader] - A tile loader that can be shared among tilesets in order to share a common cache.
+     * @param {Object} [properties.meshCallback] - A callback function that will be called on every mesh
+     * @param {Object} [properties.pointsCallback] - A callback function that will be called on every points
+     * @param {Object} [properties.onLoadCallback] - A callback function that will be called when the root tile has been loaded
+     * @param {Object} [properties.occlusionCullingService] - A service that handles occlusion culling
+     * @param {Object} [properties.centerModel] - If true, the tileset will be centered on 0,0,0 and in the case of georeferenced tilesets that use the "region" bounding volume, it will also be rotated so that the up axis matched the world y axis.
+     * @param {Object} [properties.static] - If true, the tileset is considered static which improves performance but the tileset cannot be moved
+     * @param {Object} [properties.rootPath] - optional the root path for fetching children
+     * @param {Object} [properties.json] - optional json object representing the tileset sub-tree
+     * @param {Object} [properties.parentGeometricError] - optional geometric error of the parent
+     * @param {Object} [properties.parentBoundingVolume] - optional bounding volume of the parent
+     * @param {Object} [properties.parentRefinement] - optional refinement strategy of the parent of the parent
+     * @param {Object} [properties.cameraOnLoad] - optional the camera used when loading this particular sub-tile
+     * @param {Object} [properties.parentTile] - optional the OGC3DTile object that loaded this tile as a child
+     */
+    constructor(properties?: {
+        renderer?: Object | undefined;
+        url?: Object | undefined;
+        pathParams?: Object | undefined;
+        geometricErrorMultiplier?: Object | undefined;
+        loadOutsideView?: Object | undefined;
+        tileLoader?: Object | undefined;
+        meshCallback?: Object | undefined;
+        pointsCallback?: Object | undefined;
+        onLoadCallback?: Object | undefined;
+        occlusionCullingService?: Object | undefined;
+        centerModel?: Object | undefined;
+        static?: Object | undefined;
+        rootPath?: Object | undefined;
+        json?: Object | undefined;
+        parentGeometricError?: Object | undefined;
+        parentBoundingVolume?: Object | undefined;
+        parentRefinement?: Object | undefined;
+        cameraOnLoad?: Object | undefined;
+        parentTile?: Object | undefined;
+    } | undefined);
+    renderer: Object | undefined;
+    geometricErrorMultiplier: number | Object;
+    tileset: InstancedTile;
+    matrixAutoUpdate: boolean | undefined;
+    tileLoader: Object | undefined;
+    /**
+     * To be called in the render loop.
+     * @param {Three.Camera} camera a camera that the tileset will be rendered with.
+     */
+    update(camera: Three.Camera, frustum: any): void;
+    /**
+     * Set the Geometric Error Multiplier for the tileset.
+     * the {@param geometricErrorMultiplier} can be a number between 1 and infinity.
+     * A {@param geometricErrorMultiplier} of 1 (default) corresponds to a max ScreenSpace error (MSE) of 16.
+     * A lower {@param geometricErrorMultiplier} loads less detail (higher MSE) and a higher {@param geometricErrorMultiplier} loads more detail (lower MSE)
+     *
+     * @param {Number} geometricErrorMultiplier set the LOD multiplier for the entire tileset
+     */
+    setGeometricErrorMultiplier(geometricErrorMultiplier: number): void;
+}
+import { InstancedTile } from "./InstancedTile.js";

package/dist/tileset/instanced/InstancedTile.d.ts

@@ -0,0 +1,70 @@
+export class InstancedTile {
+    /**
+     *
+     * @param {
+     *   json: optional,
+     *   url: optional,
+     *   rootPath: optional,
+     *   parentGeometricError: optional,
+     *   parentBoundingVolume: optional,
+     *   parentRefinement: optional,
+     *   loadOutsideView: Boolean,
+     *   tileLoader : InstancedTileLoader,
+     *   meshCallback: function,
+     *   cameraOnLoad: camera,
+     *   parentTile: OGC3DTile,
+     *   onLoadCallback: function,
+     *   centerModel: Boolean,
+     *   queryParams: String
+     * } properties
+     */
+    constructor(properties: any);
+    queryParams: any;
+    uuid: any;
+    tileLoader: any;
+    master: any;
+    meshCallback: any;
+    loadOutsideView: any;
+    cameraOnLoad: any;
+    parentTile: any;
+    childrenTiles: any[];
+    jsonChildren: any;
+    meshContent: Set<any>;
+    static: any;
+    matrixAutoUpdate: boolean | undefined;
+    matrixWorldAutoUpdate: boolean | undefined;
+    materialVisibility: boolean;
+    inFrustum: boolean;
+    level: any;
+    hasMeshContent: number;
+    hasUnloadedJSONContent: number;
+    centerModel: any;
+    deleted: boolean;
+    abortController: AbortController;
+    rootPath: any;
+    loadJson(json: any, url: any): void;
+    setup(properties: any): Promise<void>;
+    isSetup: boolean | undefined;
+    isAbsolutePathOrURL(input: any): any;
+    assembleURL(root: any, relative: any): string;
+    extractQueryParams(url: any, params: any): string;
+    load(): void;
+    matrixWorldNeedsUpdate: boolean | undefined;
+    loadMesh(mesh: any): void;
+    dispose(): void;
+    parent: any;
+    disposeChildren(): void;
+    _update(camera: any, frustum: any): void;
+    areAllChildrenLoadedAndHidden(): boolean;
+    /**
+     * Node is ready if it is outside frustum, if it was drawn at least once or if all it's children are ready
+     * @returns true if ready
+     */
+    isReady(): boolean;
+    changeContentVisibility(visibility: any): void;
+    calculateUpdateMetric(camera: any, frustum: any): number;
+    getSiblings(): any[];
+    calculateDistanceToCamera(camera: any): number;
+    getWorldMatrix(): any;
+    transformWGS84ToCartesian(lon: any, lat: any, h: any, sfct: any): void;
+}

package/dist/tileset/instanced/InstancedTileLoader.d.ts

@@ -0,0 +1,73 @@
+/**
+ * A Tile loader that manages caching and load order for instanced tiles.
+ * The cache is an LRU cache and is defined by the number of items it can hold.
+ * The actual number of cached items might grow beyond max if all items are in use.
+ *
+ * The load order is designed for optimal perceived loading speed (nearby tiles are refined first).
+ *
+ */
+export class InstancedTileLoader {
+    /**
+     * Creates a tile loader with a maximum number of cached items and callbacks.
+     * The only required property is a renderer that will be used to visualize the tiles.
+     * The maxCachedItems property is the size of the cache in number of objects, mesh tile and tileset.json files.
+     * The mesh and point callbacks will be called for every incoming mesh or points.
+     *
+     * @param {scene} [scene] - a threejs scene.
+     * @param {Object} [options] - Optional configuration object.
+     * @param {number} [options.maxCachedItems=100] - the cache size.
+     * @param {number} [options.maxInstances=1] - the cache size.
+     * @param {function} [options.meshCallback] - A callback to call on newly decoded meshes.
+     * @param {function} [options.pointsCallback] - A callback to call on newly decoded points.
+     * @param {renderer} [options.renderer] - The renderer, this is required for KTX2 support.
+     * @param {sring} [options.proxy] - An optional proxy that tile requests will be directed too as POST requests with the actual tile url in the body of the request.
+     */
+    constructor(scene?: any, options?: {
+        maxCachedItems?: number | undefined;
+        maxInstances?: number | undefined;
+        meshCallback?: Function | undefined;
+        pointsCallback?: Function | undefined;
+        renderer?: any;
+        proxy?: any;
+    } | undefined);
+    maxCachedItems: number;
+    maxInstances: number;
+    proxy: any;
+    meshCallback: Function | undefined;
+    pointsCallback: Function | undefined;
+    gltfLoader: any;
+    b3dmDecoder: B3DMDecoder;
+    cache: any;
+    scene: any;
+    ready: any[];
+    downloads: any[];
+    nextReady: any[];
+    nextDownloads: any[];
+    /**
+     * To be called in the render loop or at regular intervals.
+     * launches tile downloading and loading in an orderly fashion.
+     */
+    update(): void;
+    _download(): void;
+    _loadBatch(): 0 | 1;
+    _getNextReady(): void;
+    /**
+     * Schedules a tile content to be downloaded
+     *
+     * @param {AbortController} abortController
+     * @param {string} path path or url to tile content
+     * @param {string|Number} uuid tile id
+     * @param {InstancedOGC3DTile} instancedOGC3DTile
+     * @param {Function} distanceFunction
+     * @param {Function} getSiblings
+     * @param {Number} level
+     * @param {Boolean} sceneZupToYup
+     * @param {Boolean} meshZupToYup
+     * @param {Number} geometricError
+     */
+    get(abortController: AbortController, path: string, uuid: string | number, instancedOGC3DTile: InstancedOGC3DTile, distanceFunction: Function, getSiblings: Function, level: number, sceneZupToYup: boolean, meshZupToYup: boolean, geometricError: number): void;
+    _getNextDownloads(): void;
+    _checkSize(): void;
+}
+import { B3DMDecoder } from "../../decoder/B3DMDecoder";
+import { InstancedOGC3DTile } from './InstancedOGC3DTile';

package/dist/tileset/instanced/JsonTile.d.ts

@@ -0,0 +1,11 @@
+export class JsonTile {
+    count: number;
+    instancedTiles: any[];
+    addInstance(instanceTile: any): void;
+    setObject(json: any, url: any): void;
+    json: any;
+    url: any;
+    getCount(): number;
+    update(): void;
+    dispose(): boolean;
+}

package/dist/tileset/instanced/MeshTile.d.ts

@@ -0,0 +1,13 @@
+export class MeshTile {
+    constructor(scene: any);
+    scene: any;
+    instancedTiles: any[];
+    reuseableMatrix: any;
+    addInstance(instancedTile: any): void;
+    addToScene(): void;
+    setObject(instancedMesh: any): void;
+    instancedMesh: any;
+    update(): void;
+    getCount(): number;
+    dispose(): boolean;
+}

package/package.json

@@ -1,10 +1,10 @@
 {
     "name": "@jdultra/threedtiles",
-    "version": "10.0.1",
+    "version": "10.0.2",
     "description": "An OGC 3DTiles viewer for Three.js",
     "main": "dist/threedtiles.min.js",
     "files": [
-        "dist/threedtiles.min.js",
+        "dist/**/*",
         "README.md",
         "LICENSE"
     ],