@jdultra/threedtiles 14.0.19 → 14.0.21

package/dist/entry.d.ts

@@ -2,6 +2,8 @@ export { OcclusionCullingService } from "./tileset/OcclusionCullingService";
 export { TileLoader } from "./tileset/TileLoader";
 export { InstancedOGC3DTile } from "./tileset/instanced/InstancedOGC3DTile.js";
 export { InstancedTileLoader } from "./tileset/instanced/InstancedTileLoader.js";
+export { Physics } from "./simulation/physics.js";
+export { ColliderShape } from "./simulation/ColliderShape.js";
 export { OBB } from "./geometry/obb.js";
 export { OGC3DTile, getOGC3DTilesCopyrightInfo } from "./tileset/OGC3DTile";
 export { splatsVertexShader, splatsFragmentShader, SplatsMesh } from "./splats/SplatsMesh.js";

package/dist/simulation/ColliderShape.d.ts

@@ -0,0 +1,112 @@
+export namespace ColliderShape {
+    export { createBall };
+    export { createCuboid };
+    export { createBox };
+    export { createRoundCuboid };
+    export { createCapsule };
+    export { createCone };
+    export { createCylinder };
+    export { createSegment };
+    export { createTriangle };
+    export { createPolyline };
+    export { createConvexHull };
+    export { createHeightfield };
+}
+declare function createBall(radius: any): {
+    kind: string;
+    params: {
+        radius: number;
+    };
+};
+declare function createCuboid(hx: any, hy: any, hz: any): {
+    kind: string;
+    params: {
+        hx: number;
+        hy: number;
+        hz: number;
+    };
+};
+declare function createBox(hx: any, hy: any, hz: any): {
+    kind: string;
+    params: {
+        hx: number;
+        hy: number;
+        hz: number;
+    };
+};
+declare function createRoundCuboid(hx: any, hy: any, hz: any, radius: any): {
+    kind: string;
+    params: {
+        hx: number;
+        hy: number;
+        hz: number;
+        radius: number;
+    };
+};
+declare function createCapsule(halfHeight: any, radius: any): {
+    kind: string;
+    params: {
+        halfHeight: number;
+        radius: number;
+    };
+};
+declare function createCone(halfHeight: any, radius: any): {
+    kind: string;
+    params: {
+        halfHeight: number;
+        radius: number;
+    };
+};
+declare function createCylinder(halfHeight: any, radius: any): {
+    kind: string;
+    params: {
+        halfHeight: number;
+        radius: number;
+    };
+};
+declare function createSegment(a: any, b: any): {
+    kind: string;
+    params: {
+        a: any;
+        b: any;
+    };
+};
+declare function createTriangle(a: any, b: any, c: any): {
+    kind: string;
+    params: {
+        a: any;
+        b: any;
+        c: any;
+    };
+};
+declare function createPolyline(vertices: any, indices: any): {
+    kind: string;
+    params: {
+        vertices: any;
+        indices: any;
+    };
+};
+declare function createConvexHull(vertices: any): {
+    kind: string;
+    params: {
+        vertices: any;
+    };
+};
+declare function createHeightfield(rows: any, cols: any, heights: any, scale?: {
+    x: number;
+    y: number;
+    z: number;
+}): {
+    kind: string;
+    params: {
+        rows: number;
+        cols: number;
+        heights: any;
+        scale: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+};
+export {};

package/dist/simulation/physics.d.ts

@@ -0,0 +1,177 @@
+export class Physics {
+    /**
+     * constructor(options)
+     *  - updateIntervalMs: number (default 16). setTimeout tick period on the main thread
+     *  - fixedDt: number seconds per physics step (default: updateIntervalMs/1000)
+     *  - gravity: [x,y,z] OR { mode:'vector', vector:[x,y,z] } OR { mode:'geocentric', planetCenter:[x,y,z], intensity:number }
+     *  - autoStart: boolean (default true)
+     */
+    constructor(options?: {});
+    updateIntervalMs: any;
+    fixedDt: any;
+    gravity: {
+        mode: string;
+        vector: any[];
+        planetCenter?: undefined;
+        intensity?: undefined;
+    } | {
+        mode: string;
+        planetCenter: any[];
+        intensity: any;
+        vector?: undefined;
+    };
+    autoStart: boolean;
+    sharedMemorySupported: boolean;
+    worker: any;
+    _msgId: number;
+    _pending: Map<any, any>;
+    _onWorkerMessage(ev: any): void;
+    helperWorker: any;
+    _helperMsgId: number;
+    _helperPending: Map<any, any>;
+    _onHelperMessage(ev: any): void;
+    _paused: boolean;
+    _lastTickTime: number;
+    _lastState: any;
+    _currentState: any;
+    _interpolationMax: number;
+    _nextBodyId: number;
+    _nextColliderId: number;
+    rigidBodies: Map<any, any>;
+    bodyToColliders: Map<any, any>;
+    colliderToBody: Map<any, any>;
+    _listeners: Map<any, any>;
+    _initPromise: Promise<any>;
+    /**
+     * addObject({ object, type, mass, position, rotation, velocity, angularVelocity })
+     *  - object: THREE.Object3D (e.g., OGC3DTile or any Object3D)
+     *  - type: 'dynamic' | 'kinematic' | 'fixed' (default 'dynamic')
+     *  - mass: number (default 1)
+     *  - position: array|Vector3
+     *  - rotation: Euler|Quaternion|[x,y,z,w]
+     *  - velocity: array|Vector3 (optional)
+     *  - angularVelocity: array|Vector3 (optional)
+     */
+    addObject(options?: {}): string;
+    /**
+     * attachTrimeshCollider({ bodyId, geometry?, positions?, indices?, localPosition?, localRotation?, localScale? }) => Promise<string colliderId>
+     * Creates a TRIMESH collider with baked non-uniform scale and attaches it to the body.
+     * Positions/indices are always duplicated on the main thread and their ArrayBuffers are transferred.
+     */
+    attachTrimeshCollider({ bodyId, geometry, positions, indices, localPosition, localRotation, localScale }: {
+        bodyId: any;
+        geometry: any;
+        positions: any;
+        indices: any;
+        localPosition: any;
+        localRotation: any;
+        localScale: any;
+    }): Promise<null> | Promise<string>;
+    /**
+     * addConvexHullCollider({ bodyId, geometry?, positions?, indices?, localPosition?, localRotation?, localScale? }) => Promise<string colliderId>
+     * Computes a convex hull in a helper worker (with non-uniform scale baked in) and attaches it as a collider.
+     * Positions/indices are duplicated on the main thread and their ArrayBuffers are transferred to the helper worker.
+     */
+    addConvexHullCollider({ bodyId, geometry, positions, indices, localPosition, localRotation, localScale }: {
+        bodyId: any;
+        geometry: any;
+        positions: any;
+        indices: any;
+        localPosition: any;
+        localRotation: any;
+        localScale: any;
+    }): Promise<string | null>;
+    /**
+     * attachShapeCollider({ bodyId, shape, localPosition?, localRotation? }) => Promise<string colliderId>
+     * Creates a primitive/analytic collider (via engine-agnostic shape descriptor) and attaches it to the body.
+     * Note: Any scale must be baked into the shape's parameters; no scale is applied at runtime.
+     */
+    attachShapeCollider({ bodyId, shape, localPosition, localRotation }: {
+        bodyId: any;
+        shape: any;
+        localPosition: any;
+        localRotation: any;
+    }): string | Promise<null>;
+    /**
+     * detachCollider({ colliderId })
+     */
+    detachCollider({ colliderId }: {
+        colliderId: any;
+    }): void;
+    /**
+     * removeObject({ bodyId })
+     */
+    removeObject({ bodyId }: {
+        bodyId: any;
+    }): void;
+    /**
+     * applyForce({ bodyId, force, worldPoint?, wake = true, impulse = false })
+     */
+    applyForce({ bodyId, force, worldPoint, wake, impulse }: {
+        bodyId: any;
+        force: any;
+        worldPoint: any;
+        wake?: boolean | undefined;
+        impulse?: boolean | undefined;
+    }): void;
+    /**
+     * setGravity(gravityOptions)
+     */
+    setGravity(gravityOptions: any): void;
+    /**
+     * setPose({ bodyId, position?, rotation?, wake = true })
+     * Teleport a rigid body to a new pose immediately.
+     * - position: [x,y,z] or THREE.Vector3 (optional)
+     * - rotation: [x,y,z,w] or THREE.Quaternion/Euler (optional)
+     * - wake: boolean (default true)
+     */
+    setPose({ bodyId, position, rotation, wake }: {
+        bodyId: any;
+        position: any;
+        rotation: any;
+        wake?: boolean | undefined;
+    }): void;
+    /**
+     * raycast({ origin, direction, maxToi = 1e6, filter? }) => Promise<hits[]>
+     */
+    raycast({ origin, direction, maxToi, filter }: {
+        origin: any;
+        direction: any;
+        maxToi?: number | undefined;
+        filter: any;
+    }): Promise<any>;
+    /**
+     * pause / resume
+     */
+    pause(): void;
+    resume(): void;
+    /**
+     * setUpdateInterval(ms: number)
+     */
+    setUpdateInterval(ms: any): void;
+    /**
+     * stepOnce(dtSeconds?: number)
+     * Requests a single physics integration step on worker.
+     */
+    stepOnce(dtSeconds: any): Promise<any>;
+    /**
+     * update()
+     * Interpolates between the last two physics snapshots and applies transforms to linked THREE.Object3D.
+     * This is automatically called on a setTimeout loop by the constructor, but can also be called manually.
+     */
+    update(): void;
+    /**
+     * dispose()
+     * Terminates the worker and clears all registries.
+     */
+    dispose(): void;
+    _scheduleNextTick(): void;
+    _onTick(): void;
+    _ensureHelperWorker(): void;
+    _helperPost(msg: any, transfer?: any[]): Promise<any>;
+    _post(msg: any, transfer?: any[]): Promise<any>;
+    on(type: any, fn: any): () => void;
+    off(type: any, fn: any): void;
+    _emit(type: any, payload: any): void;
+}
+export default Physics;

package/dist/simulation/physicsHelper.worker.d.ts

@@ -0,0 +1,6 @@
+declare function ack(id: any, result?: null, transfer?: any[]): void;
+declare function nack(id: any, error: any): void;
+declare function computeHullFromPositions(positions: any, scale: any): {
+    hullVertices: Float32Array<ArrayBufferLike>;
+    hullIndices: null;
+};

package/dist/simulation/physicsRapier.worker.d.ts

@@ -0,0 +1 @@
+export {};