@jdultra/threedtiles 10.1.9 → 11.0.0

package/dist/tileset/OGC3DTile.d.ts

@@ -7,7 +7,7 @@ export class OGC3DTile extends THREE.Object3D<THREE.Object3DEventMap> {
     /**
      * @param {Object} [properties] - the properties for this 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 {Object} [properties.queryParams] - optional, path params to add to individual tile urls
      * @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.
@@ -31,10 +31,13 @@ export class OGC3DTile extends THREE.Object3D<THREE.Object3DEventMap> {
      * @param {Number} [properties.domHeight] - optional the canvas height (used to calculate geometric error). If a renderer is provided, it'll be used instead, else a default value is used.
      * @param {DracoLoader} [properties.dracoLoader] - optional a draco loader (three/addons).
      * @param {KTX2Loader} [properties.ktx2Loader] - optional a ktx2 loader (three/addons).
+     * @param {Number} [properties.distanceBias] - optional a bias that allows loading more or less detail closer to the camera relative to far away. The value should be a positive number. A value below 1 loads less detail near the camera and a value above 1 loads more detail near the camera. This needs to be compensated by the geometricErrorMultiplier in order to load a reasonable number of tiles.
+     * @param {String} [properties.loadingStrategy] - optional a strategy for loading tiles "INCREMENTAL" loads intermediate LODs while "IMMEDIATE" skips intermediate LODs.
+     * @param {String} [properties.drawBoundingVolume] - optional draws the bounding volume (may cause flickering)
      */
     constructor(properties?: {
         url?: string | undefined;
-        queryParams?: string | undefined;
+        queryParams?: Object | undefined;
         geometricErrorMultiplier?: number | undefined;
         loadOutsideView?: boolean | undefined;
         tileLoader?: TileLoader | undefined;
@@ -58,19 +61,39 @@ export class OGC3DTile extends THREE.Object3D<THREE.Object3DEventMap> {
         domHeight?: number | undefined;
         dracoLoader?: any;
         ktx2Loader?: any;
+        distanceBias?: number | undefined;
+        loadingStrategy?: string | undefined;
+        drawBoundingVolume?: string | undefined;
     } | undefined);
+    contentURL: any[];
     rendererSize: THREE.Vector2;
+    loadingStrategy: string;
+    distanceBias: number;
     proxy: string | undefined;
+    drawBoundingVolume: string | boolean;
     displayErrors: boolean | undefined;
     displayCopyright: boolean;
-    queryParams: any;
+    queryParams: {
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    } | undefined;
     uuid: any;
     tileLoader: TileLoader;
     /**
      * To be called in the render loop.
      * @param {Three.Camera} camera a camera that the tileset will be rendered with.
+    * @returns {{numTiles: number, maxLOD: number, percentageLoaded: percentageLoaded}} An object containing describing the current state of the loaded tileset.
      */
-    update(camera: Three.Camera): void;
+    update(camera: Three.Camera): {
+        numTiles: number;
+        maxLOD: number;
+        percentageLoaded: number[];
+    };
     geometricErrorMultiplier: number;
     renderer: THREE.Renderer | undefined;
     meshCallback: Function | undefined;
@@ -84,7 +107,6 @@ export class OGC3DTile extends THREE.Object3D<THREE.Object3DEventMap> {
     childrenTiles: any[];
     meshContent: any[];
     materialVisibility: boolean;
-    inFrustum: boolean;
     level: any;
     hasMeshContent: number;
     hasUnloadedJSONContent: number;
@@ -103,22 +125,37 @@ export class OGC3DTile extends THREE.Object3D<THREE.Object3DEventMap> {
     isSetup: boolean | undefined;
     _assembleURL(root: any, relative: any): string;
     _extractQueryParams(url: any, params: any): string;
-    _load(): Promise<void>;
+    _load(loadJson?: boolean, loadMesh?: boolean): Promise<void>;
     /**
      * Disposes of all the resources used by the tileset.
      */
     dispose(): void;
     deleted: boolean | undefined;
+    _disposeMeshContent(): void;
     _disposeChildren(): void;
+    _updateImmediate(camera: any, frustum: any): void;
+    shouldBeVisible: boolean | undefined;
+    check(): void;
+    _statsImmediate(maxLOD: any, numTiles: any, percentageLoaded: any, numTilesRendered: any): void;
+    _stats(maxLOD: any, numTiles: any, percentageLoaded: any, numTilesRendered: any): void;
+    _trimTreeImmediate(): void;
+    _updateNodeVisibilityImmediate(parentDisplaysMesh?: boolean): void;
+    _shouldBeVisibleUpdateImmediate(): void;
+    _setShouldNotBeVisibleRecursive(): void;
+    _loadMeshImmediate(): void;
+    _computeMetricRecursive(camera: any, frustum: any): void;
+    metric: number | undefined;
+    _expandTreeImmediate(camera: any): void;
     _update(camera: any, frustum: any): void;
+    _loadJsonChildren(camera: 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;
+    _isReadyImmediate(): boolean;
     _changeContentVisibility(visibility: any): void;
-    meshDisplayed: boolean | undefined;
     _calculateUpdateMetric(camera: any, frustum: any): number;
     _getSiblings(): any[];
     _calculateDistanceToCamera(camera: any): number;
@@ -133,5 +170,9 @@ export class OGC3DTile extends THREE.Object3D<THREE.Object3DEventMap> {
     setGeometricErrorMultiplier(geometricErrorMultiplier: number): void;
     _transformWGS84ToCartesian(lon: any, lat: any, h: any, sfct: any): void;
 }
+/**
+ * @returns a list of vendors that require copyright to be displayed in the app
+ */
+export function getOGC3DTilesCopyrightInfo(): string;
 import * as THREE from 'three';
 import { TileLoader } from "./TileLoader";

package/dist/tileset/TileLoader.d.ts

@@ -57,7 +57,7 @@ export class TileLoader {
     _scheduleDownload(f: any): void;
     _download(): void;
     _meshReceived(cache: any, register: any, key: any, distanceFunction: any, getSiblings: any, level: any, uuid: any): void;
-    _loadBatch(): 0 | undefined;
+    _loadBatch(): void;
     _getNextDownloads(): void;
     _getNextReady(): void;
     /**

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

@@ -29,6 +29,7 @@ export class InstancedOGC3DTile extends THREE.Object3D<THREE.Object3DEventMap> {
      * @param {Number} [properties.domWidth = 1000] - optional the canvas width (used to calculate geometric error). If a renderer is provided, it'll be used instead, else a default value is used.
      * @param {Number} [properties.domHeight = 1000] - optional the canvas height (used to calculate geometric error). If a renderer is provided, it'll be used instead, else a default value is used.
      * @param {Object} [properties.renderer = undefined] - optional the renderer is used to infer the canvas size and compute tiles geometric error.
+     * @param {Number} [properties.distanceBias] - optional a bias that allows loading more or less detail closer to the camera relative to far away. The value should be a positive number. A value below 1 loads less detail near the camera and a value above 1 loads more detail near the camera. This needs to be compensated by the geometricErrorMultiplier in order to load a reasonable number of tiles.
      */
     constructor(properties?: {
         url?: Object | undefined;
@@ -51,9 +52,11 @@ export class InstancedOGC3DTile extends THREE.Object3D<THREE.Object3DEventMap> {
         domWidth?: number | undefined;
         domHeight?: number | undefined;
         renderer?: Object | undefined;
+        distanceBias?: number | undefined;
     } | undefined);
     rendererSize: THREE.Vector2;
     renderer: Object | undefined;
+    distanceBias: number;
     geometricErrorMultiplier: number | Object;
     tileset: InstancedTile;
     tileLoader: Object | undefined;

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

@@ -14,7 +14,8 @@ export class InstancedTile extends THREE.Object3D<THREE.Object3DEventMap> {
      *   parentTile: OGC3DTile,
      *   onLoadCallback: function,
      *   centerModel: Boolean,
-     *   queryParams: String
+     *   queryParams: String,
+     *   distanceBias: distanceBias
      * } properties
      */
     constructor(properties: any);
@@ -25,6 +26,7 @@ export class InstancedTile extends THREE.Object3D<THREE.Object3DEventMap> {
     loadOutsideView: any;
     cameraOnLoad: any;
     parentTile: any;
+    distanceBias: number;
     childrenTiles: any[];
     jsonChildren: any;
     meshContent: Set<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jdultra/threedtiles",
-    "version": "10.1.9",
+    "version": "11.0.0",
     "description": "An OGC 3DTiles viewer for Three.js",
     "main": "dist/threedtiles.min.js",
     "types": "dist/entry.d.ts",