@jdultra/threedtiles 10.0.2 → 10.1.1

package/dist/tileset/OGC3DTile.d.ts

@@ -6,7 +6,6 @@
 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
@@ -27,9 +26,13 @@ export class OGC3DTile {
      * @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.
+     * @param {THREE.Renderer} [properties.renderer] - optional the renderer used to display the tileset. Used to infer render resolution at runtime and to instantiate a ktx2loader on the fly if not provided.
+     * @param {Number} [properties.domWidth] - 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] - 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).
      */
     constructor(properties?: {
-        renderer?: any;
         url?: string | undefined;
         queryParams?: string | undefined;
         geometricErrorMultiplier?: number | undefined;
@@ -50,7 +53,13 @@ export class OGC3DTile {
         parentTile?: OGC3DTile | undefined;
         proxy?: string | undefined;
         displayErrors?: boolean | undefined;
+        renderer?: any;
+        domWidth?: number | undefined;
+        domHeight?: number | undefined;
+        dracoLoader?: any;
+        ktx2Loader?: any;
     } | undefined);
+    rendererSize: any;
     proxy: string | undefined;
     displayErrors: boolean | undefined;
     displayCopyright: boolean;
@@ -83,6 +92,14 @@ export class OGC3DTile {
     hasUnloadedJSONContent: number;
     centerModel: boolean | undefined;
     abortController: AbortController;
+    /**
+     * Call this to specify the canvas width/height when it changes (used to compute tiles geometric error that controls tile refinement).
+     * It's unnecessary to call this when the {@link OGC3DTile} is instantiated with the renderer.
+     *
+     * @param {Number} width
+     * @param {Number} height
+     */
+    setCanvasSize(width: number, height: number): void;
     _setup(properties: any): Promise<void>;
     rootPath: any;
     isSetup: boolean | undefined;

package/dist/tileset/TileLoader.d.ts

@@ -16,24 +16,30 @@ export class TileLoader {
      *
      *
      * @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.
+     * @param {KTX2Loader} [options.ktx2Loader = undefined] - A KTX2Loader (three/addons)
+     * @param {DRACOLoader} [options.dracoLoader = undefined] - A DRACOLoader (three/addons)
+     * @param {renderer} [options.renderer = undefined] - optional the renderer, this is required only for on the fly ktx2 support. not needed if you pass a ktx2Loader manually
      */
     constructor(options?: {
-        renderer?: any;
         maxCachedItems?: number | undefined;
         meshCallback?: Function | undefined;
         pointsCallback?: Function | undefined;
         proxy?: any;
+        ktx2Loader?: any;
+        dracoLoader?: any;
+        renderer?: any;
     } | undefined);
     maxCachedItems: number;
     proxy: any;
     meshCallback: Function | undefined;
     pointsCallback: Function | undefined;
     gltfLoader: any;
+    hasDracoLoader: boolean | undefined;
+    hasKTX2Loader: boolean | undefined;
     b3dmDecoder: B3DMDecoder;
     cache: any;
     register: {};

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

@@ -9,7 +9,6 @@ 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
@@ -28,9 +27,11 @@ export class InstancedOGC3DTile {
      * @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
+     * @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.
      */
     constructor(properties?: {
-        renderer?: Object | undefined;
         url?: Object | undefined;
         pathParams?: Object | undefined;
         geometricErrorMultiplier?: Object | undefined;
@@ -49,12 +50,25 @@ export class InstancedOGC3DTile {
         parentRefinement?: Object | undefined;
         cameraOnLoad?: Object | undefined;
         parentTile?: Object | undefined;
+        domWidth?: number | undefined;
+        domHeight?: number | undefined;
+        renderer?: Object | undefined;
     } | undefined);
+    rendererSize: any;
     renderer: Object | undefined;
     geometricErrorMultiplier: number | Object;
     tileset: InstancedTile;
     matrixAutoUpdate: boolean | undefined;
     tileLoader: Object | undefined;
+    _renderSize(size: any): void;
+    /**
+     * Call this to specify the canvas width/height when it changes (used to compute tiles geometric error that controls tile refinement).
+     * It's unnecessary to call this when the {@link OGC3DTile} is instantiated with the renderer.
+     *
+     * @param {Number} width
+     * @param {Number} height
+     */
+    setCanvasSize(width: number, height: number): void;
     /**
      * To be called in the render loop.
      * @param {Three.Camera} camera a camera that the tileset will be rendered with.

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

@@ -19,16 +19,21 @@ export class InstancedTileLoader {
      * @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.
+     * @param {KTX2Loader} [options.ktx2Loader = undefined] - A KTX2Loader (three/addons)
+     * @param {DRACOLoader} [options.dracoLoader = undefined] - A DRACOLoader (three/addons)
+     * @param {renderer} [options.renderer = undefined] - optional the renderer, this is required only for on the fly ktx2 support. not needed if you pass a ktx2Loader manually
+     
      */
     constructor(scene?: any, options?: {
         maxCachedItems?: number | undefined;
         maxInstances?: number | undefined;
         meshCallback?: Function | undefined;
         pointsCallback?: Function | undefined;
-        renderer?: any;
         proxy?: any;
+        ktx2Loader?: any;
+        dracoLoader?: any;
+        renderer?: any;
     } | undefined);
     maxCachedItems: number;
     maxInstances: number;
@@ -36,6 +41,8 @@ export class InstancedTileLoader {
     meshCallback: Function | undefined;
     pointsCallback: Function | undefined;
     gltfLoader: any;
+    hasDracoLoader: boolean | undefined;
+    hasKTX2Loader: boolean | undefined;
     b3dmDecoder: B3DMDecoder;
     cache: any;
     scene: any;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jdultra/threedtiles",
-    "version": "10.0.2",
+    "version": "10.1.1",
     "description": "An OGC 3DTiles viewer for Three.js",
     "main": "dist/threedtiles.min.js",
     "files": [