@jdultra/threedtiles 14.0.19 → 14.0.21

package/dist/tileset/OGC3DTile.d.ts

@@ -46,6 +46,44 @@ export class OGC3DTile extends THREE.Object3D<THREE.Object3DEventMap> {
      * @param {number} [properties.splatsSaturation = 1.0] - optional saturation multiplier. Typical useful range: 0.0 → 2.0 (1.0 = unchanged).
      * @param {number} [properties.splatsContrast = 1.0] - optional contrast multiplier. Typical useful range: 0.0 → 2.0 (1.0 = unchanged).
      * @param {Array|Object} [properties.splatsTempTint = [0.0, 0.0]] - optional temperature and tint pair for simple white-balance adjustment. Values: temperature ∈ [-100,100], tint ∈ [-100,100]. Default [0,0].
+     * @param {Object} [properties.physics.sim = undefined] - physics sim helper {@link physics.js}
+     * @param {String} [properties.physics.type = fixed] - type: 'dynamic' | 'kinematic' | 'fixed' (default 'fixed')
+     * @param {String} [properties.physics.shape = none] - LEGACY single collider shape: 'none' | 'mesh' | 'bounds' | 'hull'. Used only when no advanced collider rules are provided.
+     * @param {number} [properties.physics.mass = 1] - mass
+     * @param {number} [properties.physics.maxLOD = infinity] - LEGACY global max LOD for constructing colliders. Higher is more accurate and more costly. Only the currently loaded LODs are used.
+     * @param {Array|Vector3} [properties.physics.velocity = [0,0,0]] - velocity vector
+     * @param {Array|Vector3} [properties.physics.angularVelocity = [0,0,0]] - angular velocity
+     *
+     * @param {Object} [properties.physics.colliders] - ADVANCED rules to mix different collider types by geometricError or by level (LOD).
+     * @param {number} [properties.physics.colliders.maxLOD] - Global LOD cap for colliders. If omitted, falls back to properties.physics.maxLOD, else Infinity.
+     * @param {string[]} [properties.physics.colliders.priority=["mesh","hull","bounds"]] - Priority when multiple rules match the same tile. First entry wins.
+     * @param {Object[]} [properties.physics.colliders.byGeometricError] - Preferred criterion when provided. Inclusive ranges on geometricError.
+     * @param {("mesh"|"hull"|"bounds")} properties.physics.colliders.byGeometricError[].shape - Collider type to use in this range.
+     * @param {number} properties.physics.colliders.byGeometricError[].min - Inclusive minimum geometricError for the rule (defaults to -Infinity if omitted).
+     * @param {number} properties.physics.colliders.byGeometricError[].max - Exclusive maximum geometricError for the rule (defaults to +Infinity if omitted).
+     * @param {Object[]} [properties.physics.colliders.byLevel] - Fallback criterion when byGeometricError is absent/empty. Inclusive ranges on integer level (LOD).
+     * @param {("mesh"|"hull"|"bounds")} properties.physics.colliders.byLevel[].shape - Collider type to use in this LOD interval.
+     * @param {number} properties.physics.colliders.byLevel[].min - Inclusive minimum LOD (integer).
+     * @param {number} properties.physics.colliders.byLevel[].max - Inclusive maximum LOD (integer).
+     * @param {("mesh"|"hull"|"bounds")} [properties.physics.colliders.defaultShape] - Optional fallback shape when no rule matches. If omitted, legacy properties.physics.shape is used. If neither present, no collider is created.
+     *
+     * Selection rules:
+     *  - If colliders.byGeometricError has entries, it is used exclusively. Otherwise, byLevel is used when present.
+     *  - If multiple rules match, the first in colliders.priority is chosen (default priority is ["mesh","hull","bounds"]).
+     *  - If no rule matches, defaultShape is used; if absent, falls back to legacy properties.physics.shape; otherwise no collider is created.
+     *  - The colliders.maxLOD (or legacy maxLOD) acts as a global cap. Tiles with level > maxLOD never get colliders.
+     *  - When a tile becomes invisible, existing colliders at level === maxLOD are retained if the tile has children (as a fallback for deeper LODs), identical to legacy behavior.
+     * e.g. (physics.colliders):
+     * {
+     *   "maxLOD": 4,
+     *   "priority": ["mesh", "hull", "bounds"],
+     *   "byLevel": [
+     *     { "shape": "mesh",   "min": 4, "max": 4 },
+     *     { "shape": "hull",   "min": 3,  "max": 3 },
+     *     { "shape": "bounds", "min": 0,  "max": 2  }
+     *   ],
+     *   "defaultShape": "bounds"
+     * }
      */
     constructor(properties?: {
         url?: string | undefined;
@@ -85,6 +123,7 @@ export class OGC3DTile extends THREE.Object3D<THREE.Object3DEventMap> {
         splatsContrast?: number | undefined;
         splatsTempTint?: Object | any[] | undefined;
     });
+    physics: any;
     splatsMesh: any;
     oldUltraMeshSplats: any;
     iosCompatibility: any;
@@ -243,6 +282,21 @@ export class OGC3DTile extends THREE.Object3D<THREE.Object3DEventMap> {
     _isReady(): boolean;
     _isReadyImmediate(): boolean;
     _changeContentVisibility(visibility: any): void;
+    /**
+     * Set the world-space pose of this tileset.
+     *
+     * IMPORTANT: When a physics simulation is attached (this.physics && this.physics.sim && this.physics.rigidBodyID),
+     * you MUST use this method to transform the object. Do NOT modify transforms using THREE.Object3D core methods
+     * (e.g. position.set, quaternion.set, applyQuaternion, setRotationFromEuler, etc.) because the physics engine
+     * is authoritative for the object's transform. This method keeps the physics rigid body in sync and updates colliders.
+     *
+     * @param {THREE.Vector3} position - New world-space position. Must be an instance of THREE.Vector3.
+     * @param {THREE.Euler|THREE.Quaternion} rotation - Rotation can be either a THREE.Euler or a THREE.Quaternion.
+     * @param {THREE.Vector3} scale - New scale. Must be an instance of THREE.Vector3.
+     * @throws {TypeError} If position or scale are not THREE.Vector3, or if rotation is not THREE.Euler/THREE.Quaternion.
+     */
+    setPose(position: THREE.Vector3, rotation: THREE.Euler | THREE.Quaternion, scale: THREE.Vector3): void;
+    _updateCollider(): void;
     _calculateUpdateMetric(camera: any, frustum: any): number;
     _getSiblings(): any[];
     _calculateDistanceToCamera(camera: any): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jdultra/threedtiles",
-  "version": "14.0.19",
+  "version": "14.0.21",
   "author": "Emeric Beaufays",
   "description": "An OGC 3DTiles viewer for Three.js",
   "main": "dist/threedtiles.cjs.js",
@@ -32,6 +32,7 @@
     "three": "^0.180.0"
   },
   "dependencies": {
+    "@dimforge/rapier3d-compat": "^0.19.2",
     "@haragei/dag": "^1.1.0",
     "@spz-loader/core": "^0.3.0",
     "data-structure-typed": "^2.0.4",
@@ -56,6 +57,8 @@
     "typescript": "^5.9.2",
     "vite": "^7.1.6",
     "vite-plugin-static-copy": "^3.1.0",
-    "vitest": "^3.2.4"
+    "vitest": "^3.2.4",
+    "vite-plugin-top-level-await": "^1.3.0",
+    "vite-plugin-wasm": "^3.2.1"
   }
 }

package/dist/geometry/obb copy.d.ts

@@ -1,16 +0,0 @@
-export class OBB {
-    constructor(values: any);
-    center: Vector3;
-    halfWidth: number;
-    halfHeight: number;
-    halfDepth: number;
-    aabb: Box3;
-    sphere: Sphere;
-    matrixToOBBCoordinateSystem: Matrix3;
-    inFrustum(frustum: any): any;
-    distanceToPoint(point: any): number;
-}
-import { Vector3 } from "three";
-import { Box3 } from "three";
-import { Sphere } from "three";
-import { Matrix3 } from "three";