@jdultra/threedtiles 12.0.0 → 13.0.0

package/dist/tileset/OGC3DTile.d.ts

@@ -3,37 +3,37 @@
  * @class
  * @extends {THREE.Object3D}
  */
-export class OGC3DTile {
+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 {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.
-     * @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.
-     * @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).
-     * @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)
+     * @param {Object} [properties.queryParams = undefined] - optional, path params to add to individual tile urls
+     * @param {Number} [properties.geometricErrorMultiplier = 1] - the geometric error of the parent. 1.0 by default corresponds to a maxScreenSpaceError of 16
+     * @param {Boolean} [properties.loadOutsideView = false] - if truthy, tiles otside the camera frustum will be loaded with the least possible amount of detail
+     * @param {TileLoader} [properties.tileLoader = undefined] - A tile loader that can be shared among tilesets in order to share a common cache.
+     * @param {Function} [properties.meshCallback = undefined] - A callback function that will be called on every mesh
+     * @param {Function} [properties.pointsCallback = undefined] - A callback function that will be called on every points
+     * @param {Function} [properties.onLoadCallback = undefined] - A callback function that will be called when the root tile has been loaded
+     * @param {OcclusionCullingService} [properties.occlusionCullingService = undefined] - A service that handles occlusion culling
+     * @param {Boolean} [properties.centerModel = false] - 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 = false] - If true, the tileset is considered static which improves performance but the matrices aren't automatically updated
+     * @param {String} [properties.rootPath = undefined] - optional the root path for fetching children
+     * @param {String} [properties.json = undefined] - optional json object representing the tileset sub-tree
+     * @param {Number} [properties.parentGeometricError = undefined] - optional geometric error of the parent
+     * @param {Object} [properties.parentBoundingVolume = undefined] - optional bounding volume of the parent
+     * @param {String} [properties.parentRefine = undefined] - optional refine strategy of the parent of the parent
+     * @param {THREE.Camera} [properties.cameraOnLoad = undefined] - optional the camera used when loading this particular sub-tile
+     * @param {OGC3DTile} [properties.parentTile = undefined] - optional the OGC3DTile object that loaded this tile as a child
+     * @param {String} [properties.proxy = undefined] - 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 = false] - optional value indicating that errors should be shown on screen.
+     * @param {THREE.Renderer} [properties.renderer = undefined] - 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 = undefined] - 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 = undefined] - 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 = undefined] - optional a draco loader (three/addons).
+     * @param {KTX2Loader} [properties.ktx2Loader = undefined] - optional a ktx2 loader (three/addons).
+     * @param {Number} [properties.distanceBias = 1] - 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 = "INCREMENTAL"] - optional a strategy for loading tiles "INCREMENTAL" loads intermediate LODs while "IMMEDIATE" skips intermediate LODs.
+     * @param {String} [properties.drawBoundingVolume = false] - optional draws the bounding volume (may cause flickering)
      */
     constructor(properties?: {
         url?: string | undefined;
@@ -52,11 +52,11 @@ export class OGC3DTile {
         parentGeometricError?: number | undefined;
         parentBoundingVolume?: Object | undefined;
         parentRefine?: string | undefined;
-        cameraOnLoad?: any;
+        cameraOnLoad?: THREE.Camera | undefined;
         parentTile?: OGC3DTile | undefined;
         proxy?: string | undefined;
         displayErrors?: boolean | undefined;
-        renderer?: any;
+        renderer?: THREE.Renderer | undefined;
         domWidth?: number | undefined;
         domHeight?: number | undefined;
         dracoLoader?: any;
@@ -65,8 +65,9 @@ export class OGC3DTile {
         loadingStrategy?: string | undefined;
         drawBoundingVolume?: string | undefined;
     } | undefined);
+    splatsMesh: any;
     contentURL: any[];
-    rendererSize: any;
+    rendererSize: THREE.Vector2;
     loadingStrategy: string;
     distanceBias: number;
     proxy: string | undefined;
@@ -96,17 +97,17 @@ export class OGC3DTile {
         percentageLoaded: number;
     };
     geometricErrorMultiplier: number;
-    renderer: any;
+    splatsCropRadius: number;
+    splatsSizeMultiplier: number;
+    renderer: THREE.Renderer | undefined;
     meshCallback: Function | undefined;
     loadOutsideView: boolean | undefined;
-    cameraOnLoad: any;
+    cameraOnLoad: THREE.Camera | undefined;
     parentTile: OGC3DTile | undefined;
     occlusionCullingService: any;
     static: boolean | undefined;
-    color: any;
+    color: THREE.Color | undefined;
     colorID: number | undefined;
-    matrixAutoUpdate: boolean | undefined;
-    matrixWorldAutoUpdate: boolean | undefined;
     childrenTiles: any[];
     meshContent: any[];
     materialVisibility: boolean;
@@ -116,6 +117,16 @@ export class OGC3DTile {
     centerModel: boolean | undefined;
     abortController: AbortController;
     onLoadCallback: Function | undefined;
+    /**
+     * Specify a size multiplier for splats
+     * @param {number} sizeMultiplier
+     */
+    setSplatsSizeMultiplier(sizeMultiplier: number): void;
+    /**
+     * specify a crop radius for splats
+     * @param {number} cropRadius
+     */
+    setSplatsCropRadius(cropRadius: number): void;
     /**
      * Manually updates all the matrices of the tileset.
      * To be called after transforming a {@link OGC3DTile tileset} instantiated with the "static" option
@@ -140,9 +151,9 @@ export class OGC3DTile {
      */
     dispose(): void;
     deleted: boolean | undefined;
-    parent: any;
     _disposeMeshContent(): void;
     _disposeChildren(): void;
+    raycast(raycaster: any, intersects: any): boolean | void;
     _updateImmediate(camera: any, frustum: any): void;
     shouldBeVisible: boolean | undefined;
     _statsImmediate(maxLOD: any, numTiles: any, percentageLoaded: any, numTilesRendered: any): void;
@@ -177,6 +188,7 @@ export class OGC3DTile {
      * @param {Number} geometricErrorMultiplier set the LOD multiplier for the entire tileset
      */
     setGeometricErrorMultiplier(geometricErrorMultiplier: number): void;
+    splatsReady: boolean | undefined;
     /**
      * Set the Distance Bias for the tileset.
      * the {@param distanceBias} can be a number between 0 and infinity.
@@ -192,4 +204,5 @@ export class OGC3DTile {
  * @returns a list of vendors that are required by copyright to be displayed in the app.
  */
 export function getOGC3DTilesCopyrightInfo(): string[];
+import * as THREE from 'three';
 import { TileLoader } from "./TileLoader";

package/dist/tileset/OcclusionCullingService.d.ts

@@ -6,15 +6,15 @@
  */
 export class OcclusionCullingService {
     cullMap: any[];
-    cullMaterial: any;
-    cullTarget: any;
+    cullMaterial: THREE.MeshBasicMaterial;
+    cullTarget: THREE.WebGLRenderTarget<THREE.Texture>;
     cullPixels: Uint8Array;
     /**
      *
      * @param {Integer} side use THREE.FrontSide, THREE.BackSide or THREE.DoubleSide (FrontSide default)
      */
     setSide(side: Integer): void;
-    _createCullTarget(): any;
+    _createCullTarget(): THREE.WebGLRenderTarget<THREE.Texture>;
     /**
      * Update function to be called on every frame in the render loop.
      * @param {THREE.scene} scene
@@ -29,3 +29,4 @@ export class OcclusionCullingService {
      */
     hasID(id: string | number): any;
 }
+import * as THREE from 'three';

package/dist/tileset/TileLoader.d.ts

@@ -16,24 +16,25 @@ export class TileLoader {
      *
      *
      * @param {Object} [options] - Optional configuration object.
+     * @param {renderer} [options.renderer] - the WebGL renderer
      * @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);
-    zUpToYUpMatrix: any;
+    renderer: any;
+    zUpToYUpMatrix: THREE.Matrix4;
     maxCachedItems: number;
     proxy: any;
     meshCallback: Function | undefined;
@@ -43,6 +44,7 @@ export class TileLoader {
     hasKTX2Loader: boolean | undefined;
     hasMeshOptDecoder: boolean;
     b3dmDecoder: B3DMDecoder;
+    splatsDecoder: SplatsDecoder;
     cache: any;
     register: {};
     ready: any[];
@@ -74,7 +76,7 @@ export class TileLoader {
      * @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;
+    get(abortController: AbortController, tileIdentifier: string | number, path: string, callback: Function, distanceFunction: Function, getSiblings: Function, level: number, sceneZupToYup: boolean, meshZupToYup: boolean, geometricError: number, splatsMesh: any): void;
     /**
      * Invalidates all the unused cached tiles.
      */
@@ -87,4 +89,6 @@ export class TileLoader {
     invalidate(path: string, tileIdentifier: string | number): void;
     _checkSize(): void;
 }
+import * as THREE from 'three';
 import { B3DMDecoder } from "../decoder/B3DMDecoder";
+import { SplatsDecoder } from "../decoder/SplatsDecoder";

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

@@ -5,7 +5,7 @@
  * 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 {
+export class InstancedOGC3DTile extends THREE.Object3D<THREE.Object3DEventMap> {
     /**
      *
      * @param {Object} [properties] - the properties for this tileset
@@ -54,12 +54,11 @@ export class InstancedOGC3DTile {
         renderer?: Object | undefined;
         distanceBias?: number | undefined;
     } | undefined);
-    rendererSize: any;
+    rendererSize: THREE.Vector2;
     renderer: Object | undefined;
     distanceBias: number;
     geometricErrorMultiplier: number | Object;
     tileset: InstancedTile;
-    matrixAutoUpdate: boolean | undefined;
     tileLoader: Object | undefined;
     _renderSize(size: any): void;
     /**
@@ -85,4 +84,5 @@ export class InstancedOGC3DTile {
      */
     setGeometricErrorMultiplier(geometricErrorMultiplier: number): void;
 }
+import * as THREE from 'three';
 import { InstancedTile } from "./InstancedTile.js";

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

@@ -1,4 +1,4 @@
-export class InstancedTile {
+export class InstancedTile extends THREE.Object3D<THREE.Object3DEventMap> {
     /**
      *
      * @param {
@@ -31,8 +31,6 @@ export class InstancedTile {
     jsonChildren: any;
     meshContent: Set<any>;
     static: any;
-    matrixAutoUpdate: boolean | undefined;
-    matrixWorldAutoUpdate: boolean | undefined;
     materialVisibility: boolean;
     inFrustum: boolean;
     level: any;
@@ -44,7 +42,6 @@ export class InstancedTile {
     rootPath: any;
     loadJson(json: any, url: any): void;
     setup(properties: any): Promise<void>;
-    matrixWorldNeedsUpdate: boolean | undefined;
     isSetup: boolean | undefined;
     isAbsolutePathOrURL(input: any): any;
     assembleURL(root: any, relative: any): string;
@@ -52,7 +49,6 @@ export class InstancedTile {
     load(): void;
     loadMesh(mesh: any): void;
     dispose(): void;
-    parent: any;
     disposeChildren(): void;
     _update(camera: any, frustum: any): void;
     areAllChildrenLoadedAndHidden(): boolean;
@@ -65,6 +61,7 @@ export class InstancedTile {
     calculateUpdateMetric(camera: any, frustum: any): number;
     getSiblings(): any[];
     calculateDistanceToCamera(camera: any): number;
-    getWorldMatrix(): any;
+    getWorldMatrix(): THREE.Matrix4;
     transformWGS84ToCartesian(lon: any, lat: any, h: any, sfct: any): void;
 }
+import * as THREE from 'three';

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

@@ -35,7 +35,7 @@ export class InstancedTileLoader {
         dracoLoader?: any;
         renderer?: any;
     } | undefined);
-    zUpToYUpMatrix: any;
+    zUpToYUpMatrix: THREE.Matrix4;
     maxCachedItems: number;
     maxInstances: number;
     proxy: any;
@@ -78,5 +78,6 @@ export class InstancedTileLoader {
     _getNextDownloads(): void;
     _checkSize(): void;
 }
+import * as THREE from 'three';
 import { B3DMDecoder } from "../../decoder/B3DMDecoder";
 import { InstancedOGC3DTile } from './InstancedOGC3DTile';

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

@@ -2,7 +2,7 @@ export class MeshTile {
     constructor(scene: any);
     scene: any;
     instancedTiles: any[];
-    reuseableMatrix: any;
+    reuseableMatrix: THREE.Matrix4;
     addInstance(instancedTile: any): void;
     addToScene(): void;
     setObject(instancedMesh: any): void;
@@ -11,3 +11,4 @@ export class MeshTile {
     getCount(): number;
     dispose(): boolean;
 }
+import * as THREE from 'three';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jdultra/threedtiles",
-  "version": "12.0.0",
+  "version": "13.0.0",
   "author": "Emeric Beaufays",
   "description": "An OGC 3DTiles viewer for Three.js",
   "main": "dist/threedtiles.cjs.js",
@@ -22,12 +22,17 @@
     "build": "vite build --config vite.prod.config.js && npm run build:types",
     "build:types": "tsc --declaration --emitDeclarationOnly --allowJs --outDir dist",
     "generate-docs": "jsdoc --configure jsdoc.json --verbose",
-    "dev": "vite"
+    "dev": "vite",
+    "build:dev": "vite build --config vite.config.js",
+    "test:watch": "vitest",
+    "test": "vitest run"
   },
   "peerDependencies": {
     "three": "0.170.0"
   },
   "dependencies": {
+    "@haragei/dag": "^1.1.0",
+    "data-structure-typed": "^1.53.5",
     "js-utils-z": "^1.2.1",
     "meshoptimizer": "^0.20.0",
     "path-browserify": "^1.0.1",
@@ -36,8 +41,11 @@
   },
   "devDependencies": {
     "@rollup/plugin-terser": "^0.4.4",
+    "@types/three": "^0.169.0",
+    "jsdom": "^25.0.1",
     "typescript": "^5.6.3",
     "vite": "^5.4.10",
-    "vite-plugin-static-copy": "^2.0.0"
+    "vite-plugin-static-copy": "^2.0.0",
+    "vitest": "^2.1.5"
   }
 }