@jdultra/threedtiles 13.2.6 → 13.3.0

package/dist/entry.d.ts

@@ -2,5 +2,6 @@ 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 { OBB } from "./geometry/obb.js";
 export { OGC3DTile, getOGC3DTilesCopyrightInfo } from "./tileset/OGC3DTile";
 export { splatsVertexShader, splatsFragmentShader } from "./splats/SplatsMesh.js";

package/dist/geometry/obb.d.ts

@@ -1,23 +1,140 @@
 export class OBB {
-    constructor(values: any);
+    /**
+     * Creates an oriented-bounding-box (OBB) from a 12-element numeric array.
+     *
+     * @param {number[]} values 12 numbers:
+     * `[cx, cy, cz, e1x, e1y, e1z, e2x, e2y, e2z, e3x, e3y, e3z]` where
+     * `center = (cx, cy, cz)` and `e1 e2 e3` are the local edge vectors.
+     * @constructor
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:0]{index=0}
+    */
+    constructor(values: number[]);
+    isOBB: boolean;
     center: Vector3;
     e1: Vector3;
     e2: Vector3;
     e3: Vector3;
     halfSize: Vector3;
     rotationMatrix: Matrix3;
-    copy(aObb: any): void;
-    getSize(result: any): any;
-    applyMatrix4(matrix: any): this;
-    intersectRay(ray: any, result: any): any;
-    intersectsRay(ray: any): boolean;
-    insidePlane(plane: any): boolean;
-    inFrustum(frustum: any): boolean;
-    distanceToPoint(point: any): number;
-    helper(): LineSegments<BufferGeometry<import("three").NormalBufferAttributes>, LineBasicMaterial, import("three").Object3DEventMap>;
+    /**
+     * Copy all geometric properties from another {@link OBB}.
+     *
+     * @param {OBB} aObb Source OBB whose data will be copied.
+     * @returns {void}
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:1]{index=1}
+    */
+    copy(aObb: OBB): void;
+    /**
+     * Get the full **size** (width, height, depth) of this OBB.
+     *
+     * @param {THREE.Vector3} result Pre-allocated vector that receives the size.
+     * @returns {THREE.Vector3} The same `result` instance for chaining.
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:2]{index=2}
+     */
+    getSize(result: THREE.Vector3): THREE.Vector3;
+    /**
+     * Apply an arbitrary affine transformation to this OBB.
+     *
+     * Scales, rotations (including non-uniform scale & reflection) and translations
+     * encoded in the 4×4 matrix are baked into `center`, `rotationMatrix`
+     * and `halfSize`.
+     *
+     * @param {THREE.Matrix4} matrix World-space transform to apply.
+     * @returns {OBB} This instance for chaining.
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:3]{index=3}
+     */
+    applyMatrix4(matrix: THREE.Matrix4): OBB;
+    /**
+     * Compute the exact intersection point between a world-space ray and this OBB.
+     *
+     * @param {THREE.Ray} ray Ray expressed in world coordinates.
+     * @param {THREE.Vector3} result Vector that receives the intersection point.
+     * @returns {?THREE.Vector3} `result` with the hit point, or `null` if no hit.
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:4]{index=4}
+     */
+    intersectRay(ray: THREE.Ray, result: THREE.Vector3): THREE.Vector3 | null;
+    /**
+     * Clamp a point to the surface or interior of the OBB (closest point query).
+     *
+     * @param {THREE.Vector3} point World-space point to be clamped.
+     * @param {THREE.Vector3} target Vector that will receive the clamped point.
+     * @returns {THREE.Vector3} The same `target` instance for chaining.
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:5]{index=5}
+     */
+    clampPoint(point: THREE.Vector3, target: THREE.Vector3): THREE.Vector3;
+    /**
+     * Test whether a {@link THREE.Sphere} intersects or is contained by this OBB.
+     *
+     * @param {THREE.Sphere} sphere Sphere to test.
+     * @returns {boolean} `true` if the sphere overlaps the OBB.
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:6]{index=6}
+     */
+    intersectsSphere(sphere: THREE.Sphere): boolean;
+    /**
+     * Separating-Axis-Theorem (SAT) intersection test between two OBBs.
+     *
+     * @param {OBB} other The second OBB.
+     * @param {number} [epsilon=Number.EPSILON] Numerical tolerance for stability.
+     * @returns {boolean} `true` if the two OBBs overlap.
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:7]{index=7}
+     */
+    intersectsOBB(other: OBB, epsilon?: number): boolean;
+    /**
+     * Fast boolean ray-OBB intersection convenience method.
+     *
+     * @param {THREE.Ray} ray Ray expressed in world coordinates.
+     * @returns {boolean} `true` if the ray intersects the OBB.
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:8]{index=8}
+     */
+    intersectsRay(ray: THREE.Ray): boolean;
+    /**
+     * Determine whether the OBB lies on the positive side of (or intersects) a plane.
+     *
+     * The plane is interpreted as **inside-facing** when its normal points toward
+     * the allowed half-space.
+     *
+     * @param {THREE.Plane} plane Plane used for the half-space test.
+     * @returns {boolean} `true` if any part of the OBB is inside or touching the plane.
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:9]{index=9}
+     */
+    insidePlane(plane: THREE.Plane): boolean;
+    /**
+     * View-frustum culling test.
+     *
+     * @param {THREE.Frustum} frustum Frustum to test against.
+     * @returns {boolean} `true` if this OBB is at least partially inside the frustum.
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:10]{index=10}
+     */
+    inFrustum(frustum: THREE.Frustum): boolean;
+    /**
+     * Compute the shortest Euclidean distance from the OBB to a point.
+     *
+     * @param {THREE.Vector3} point Point in world coordinates.
+     * @returns {number} Distance (≥ 0). Zero indicates the point is inside.
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:11]{index=11}
+     */
+    distanceToPoint(point: THREE.Vector3): number;
+    /**
+     * Create a red wire-frame visual helper for debugging purposes.
+     *
+     * @returns {THREE.LineSegments} A disposable wireframe object that
+     *          renders the eight corners and twelve edges of the OBB.
+     * @memberof OBB
+     * @see OBB implementation source :contentReference[oaicite:12]{index=12}
+     */
+    helper(): THREE.LineSegments;
 }
 import { Vector3 } from "three";
 import { Matrix3 } from "three";
-import { BufferGeometry } from "three";
-import { LineBasicMaterial } from "three";
-import { LineSegments } from "three";