math 0.0.3 → 0.1.0

package/dist/src/shapes/box2.d.ts

@@ -0,0 +1,174 @@
+import type { Vec2 } from '../core/vec2.js';
+import type { Circle } from './circle.js';
+/** An axis-aligned box in 2D space, as [minX, minY, maxX, maxY] */
+export type Box2 = [minX: number, minY: number, maxX: number, maxY: number];
+/**
+ * Create a new empty Box2 with "min" set to positive infinity and "max" set to negative infinity
+ * @returns A new Box2
+ */
+export declare function create(): Box2;
+/**
+ * Clones a Box2
+ * @param box - A Box2 to clone
+ * @returns a clone of box
+ */
+export declare function clone(box: Box2): Box2;
+/**
+ * Copies a Box2 to another Box2
+ * @param out the output Box2
+ * @param box the input Box2
+ * @returns the output Box2
+ */
+export declare function copy(out: Box2, box: Box2): Box2;
+/**
+ * Sets the min and max values of a Box2
+ * @param out - The output Box2
+ * @param minX - The minimum X coordinate
+ * @param minY - The minimum Y coordinate
+ * @param maxX - The maximum X coordinate
+ * @param maxY - The maximum Y coordinate
+ * @returns The updated Box2
+ */
+export declare function set(out: Box2, minX: number, minY: number, maxX: number, maxY: number): Box2;
+/**
+ * Sets the min and max values of a Box2 from Vec2 vectors
+ * @param out - The output Box2
+ * @param min - The minimum corner
+ * @param max - The maximum corner
+ * @returns The updated Box2
+ */
+export declare function setFromVectors(out: Box2, min: Vec2, max: Vec2): Box2;
+/**
+ * Extracts the minimum corner of a Box2
+ * @param out - The output Vec2 for the minimum corner
+ * @param box - The input Box2
+ * @returns The minimum corner
+ */
+export declare function min(out: Vec2, box: Box2): Vec2;
+/**
+ * Extracts the maximum corner of a Box2
+ * @param out - The output Vec2 for the maximum corner
+ * @param box - The input Box2
+ * @returns The maximum corner
+ */
+export declare function max(out: Vec2, box: Box2): Vec2;
+/**
+ * Set a Box2 to empty (min to positive infinity, max to negative infinity)
+ * @param out - The Box2 to make empty
+ * @returns The emptied Box2
+ */
+export declare function empty(out: Box2): Box2;
+/**
+ * Returns whether or not the boxes have exactly the same elements in the same position (when compared with ===)
+ * @param a - The first box
+ * @param b - The second box
+ * @returns True if the boxes are equal, false otherwise
+ */
+export declare function exactEquals(a: Box2, b: Box2): boolean;
+/**
+ * Returns whether or not the boxes have approximately the same elements in the same position
+ * @param a - The first box
+ * @param b - The second box
+ * @returns True if the boxes are equal, false otherwise
+ */
+export declare function equals(a: Box2, b: Box2): boolean;
+/**
+ * Sets the box from a center point and size
+ * @param out - The output Box2
+ * @param center - The center point
+ * @param size - The size of the box
+ * @returns The updated Box2
+ */
+export declare function setFromCenterAndSize(out: Box2, center: Vec2, size: Vec2): Box2;
+/**
+ * Expands a Box2 to include a point
+ * @param out - The output Box2
+ * @param box - The input Box2
+ * @param point - The point to include
+ * @returns The expanded Box2
+ */
+export declare function expandByPoint(out: Box2, box: Box2, point: Vec2): Box2;
+/**
+ * Widens a Box2 by a vector on both sides
+ * Subtracts the vector from min and adds it to max
+ * @param out - The output Box2
+ * @param box - The input Box2
+ * @param vector - The vector to expand by
+ * @returns The expanded Box2
+ */
+export declare function expandByExtents(out: Box2, box: Box2, vector: Vec2): Box2;
+/**
+ * Expands a Box2 uniformly by a scalar margin on all sides
+ * Subtracts the margin from min and adds it to max on each axis
+ * @param out - The output Box2
+ * @param box - The input Box2
+ * @param margin - The uniform margin to expand by
+ * @returns The expanded Box2
+ */
+export declare function expandByMargin(out: Box2, box: Box2, margin: number): Box2;
+/**
+ * Computes the union of two bounding boxes
+ * Returns a Box2 that encompasses both input boxes
+ * @param out - The output Box2
+ * @param boxA - The first Box2
+ * @param boxB - The second Box2
+ * @returns The union Box2
+ */
+export declare function union(out: Box2, boxA: Box2, boxB: Box2): Box2;
+/**
+ * Calculate the center point of a bounding box
+ * @param out - The output Vec2 for the center
+ * @param box - The input Box2
+ * @returns The center point
+ */
+export declare function center(out: Vec2, box: Box2): Vec2;
+/**
+ * Calculate the extents (half-size) of a bounding box
+ * @param out - The output Vec2 for the extents
+ * @param box - The input Box2
+ * @returns The extents (distance from center to each edge)
+ */
+export declare function extents(out: Vec2, box: Box2): Vec2;
+/**
+ * Calculate the size (dimensions) of a bounding box
+ * @param out - The output Vec2 for the size
+ * @param box - The input Box2
+ * @returns The size (width, height)
+ */
+export declare function size(out: Vec2, box: Box2): Vec2;
+/**
+ * Calculate the area of a bounding box
+ * @param box - The input Box2
+ * @returns The area (width * height)
+ */
+export declare function area(box: Box2): number;
+/**
+ * Scale a bounding box by a vector, handling non-uniform and negative scaling
+ * @param out - The output Box2
+ * @param box - The input Box2
+ * @param scale - The scale to apply (as a Vec2)
+ * @returns The scaled Box2
+ */
+export declare function scale(out: Box2, box: Box2, scale: Vec2): Box2;
+/**
+ * Test if a point is contained within the bounding box
+ * @param box - The bounding box
+ * @param point - The point to test
+ * @returns true if the point is inside or on the boundary of the box
+ */
+export declare function containsPoint(box: Box2, point: Vec2): boolean;
+/**
+ * Test if one Box2 completely contains another Box2
+ * @param container - The potentially containing Box2
+ * @param contained - The Box2 that might be contained
+ * @returns true if the container Box2 completely contains the contained Box2
+ */
+export declare function containsBox2(container: Box2, contained: Box2): boolean;
+/**
+ * Check whether two bounding boxes intersect
+ */
+export declare function intersectsBox2(boxA: Box2, boxB: Box2): boolean;
+/**
+ * Test intersection between an axis-aligned bounding box and a circle.
+ */
+export declare function intersectsCircle(box: Box2, circle: Circle): boolean;

package/dist/src/shapes/box3.d.ts

@@ -0,0 +1,213 @@
+import type { Mat4 } from '../core/mat4.js';
+import type { Vec3 } from '../core/vec3.js';
+import type { Plane3 } from './plane3.js';
+import type { Sphere } from './sphere.js';
+/** A box in 3D space */
+export type Box3 = [minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number];
+/**
+ * Create a new empty Box3 with "min" set to positive infinity and "max" set to negative infinity
+ * @returns A new Box3
+ */
+export declare function create(): Box3;
+/**
+ * Clones a Box3
+ * @param box - A Box3 to clone
+ * @returns a clone of box
+ */
+export declare function clone(box: Box3): Box3;
+/**
+ * Copies a Box3 to another Box3
+ * @param out the output Box3
+ * @param box the input Box3
+ * @returns the output Box3
+ */
+export declare function copy(out: Box3, box: Box3): Box3;
+/**
+ * Sets the min and max values of a Box3
+ * @param out - The output Box3
+ * @param minX - The minimum X coordinate
+ * @param minY - The minimum Y coordinate
+ * @param minZ - The minimum Z coordinate
+ * @param maxX - The maximum X coordinate
+ * @param maxY - The maximum Y coordinate
+ * @param maxZ - The maximum Z coordinate
+ * @returns The updated Box3
+ */
+export declare function set(out: Box3, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): Box3;
+/**
+ * Sets the min and max values of a Box3 from Vec3 vectors
+ * @param out - The output Box3
+ * @param min - The minimum corner
+ * @param max - The maximum corner
+ * @returns The updated Box3
+ */
+export declare function setFromVectors(out: Box3, min: Vec3, max: Vec3): Box3;
+/**
+ * Extracts the minimum corner of a Box3
+ * @param out - The output Vec3 for the minimum corner
+ * @param box - The input Box3
+ * @returns The minimum corner
+ */
+export declare function min(out: Vec3, box: Box3): Vec3;
+/**
+ * Extracts the maximum corner of a Box3
+ * @param out - The output Vec3 for the maximum corner
+ * @param box - The input Box3
+ * @returns The maximum corner
+ */
+export declare function max(out: Vec3, box: Box3): Vec3;
+/**
+ * Set a Box3 to empty (min to positive infinity, max to negative infinity)
+ * @param out - The Box3 to make empty
+ * @returns The emptied Box3
+ */
+export declare function empty(out: Box3): Box3;
+/**
+ * Returns whether or not the boxes have exactly the same elements in the same position (when compared with ===)
+ * @param a - The first box
+ * @param b - The second box
+ * @returns True if the boxes are equal, false otherwise
+ */
+export declare function exactEquals(a: Box3, b: Box3): boolean;
+/**
+ * Returns whether or not the boxes have approximately the same elements in the same position
+ * @param a - The first box
+ * @param b - The second box
+ * @returns True if the boxes are equal, false otherwise
+ */
+export declare function equals(a: Box3, b: Box3): boolean;
+/**
+ * Sets the box from a center point and size
+ * @param out - The output Box3
+ * @param center - The center point
+ * @param size - The size of the box
+ * @returns The updated Box3
+ */
+export declare function setFromCenterAndSize(out: Box3, center: Vec3, size: Vec3): Box3;
+/**
+ * Expands a Box3 to include a point
+ * @param out - The output Box3
+ * @param box - The input Box3
+ * @param point - The point to include
+ * @returns The expanded Box3
+ */
+export declare function expandByPoint(out: Box3, box: Box3, point: Vec3): Box3;
+/**
+ * Widens a Box3 by a vector on both sides
+ * Subtracts the vector from min and adds it to max
+ * @param out - The output Box3
+ * @param box - The input Box3
+ * @param vector - The vector to expand by
+ * @returns The expanded Box3
+ */
+export declare function expandByExtents(out: Box3, box: Box3, vector: Vec3): Box3;
+/**
+ * Expands a Box3 uniformly by a scalar margin on all sides
+ * Subtracts the margin from min and adds it to max on each axis
+ * @param out - The output Box3
+ * @param box - The input Box3
+ * @param margin - The uniform margin to expand by
+ * @returns The expanded Box3
+ */
+export declare function expandByMargin(out: Box3, box: Box3, margin: number): Box3;
+/**
+ * Computes the union of two bounding boxes
+ * Returns a Box3 that encompasses both input boxes
+ * @param out - The output Box3
+ * @param boxA - The first Box3
+ * @param boxB - The second Box3
+ * @returns The union Box3
+ */
+export declare function union(out: Box3, boxA: Box3, boxB: Box3): Box3;
+/**
+ * Calculate the center point of a bounding box
+ * @param out - The output Vec3 for the center
+ * @param box - The input Box3
+ * @returns The center point
+ */
+export declare function center(out: Vec3, box: Box3): Vec3;
+/**
+ * Calculate the extents (half-size) of a bounding box
+ * @param out - The output Vec3 for the extents
+ * @param box - The input Box3
+ * @returns The extents (distance from center to each face)
+ */
+export declare function extents(out: Vec3, box: Box3): Vec3;
+/**
+ * Calculate the size (dimensions) of a bounding box
+ * @param out - The output Vec3 for the size
+ * @param box - The input Box3
+ * @returns The size (width, height, depth)
+ */
+export declare function size(out: Vec3, box: Box3): Vec3;
+/**
+ * Calculate the surface area of a bounding box
+ * @param box - The input Box3
+ * @returns The surface area
+ */
+export declare function surfaceArea(box: Box3): number;
+/**
+ * Scale a bounding box by a vector, handling non-uniform and negative scaling
+ * @param out - The output Box3
+ * @param box - The input Box3
+ * @param scale - The scale to apply (as a Vec3)
+ * @returns The scaled Box3
+ */
+export declare function scale(out: Box3, box: Box3, scale: Vec3): Box3;
+/**
+ * Transform a bounding box by a 4x4 matrix.
+ * Uses Arvo's trick — transform the center, build new half-extents from
+ * |M| · extents — which is ~4× fewer ops than transforming all 8 corners.
+ * Reference: Jim Arvo, "Transforming Axis-Aligned Bounding Boxes",
+ * Graphics Gems I (1990).
+ * https://github.com/erich666/GraphicsGems/blob/master/gems/TransBox.c
+ * Assumes mat is affine (no perspective), which is always true for AABB
+ * transforms in practice.
+ * Safe under aliasing (out and box may be the same array): all six box
+ * components are read into locals before out is written.
+ * @param out - The output Box3
+ * @param box - The input Box3
+ * @param mat - The 4x4 transformation matrix
+ * @returns The transformed Box3
+ */
+export declare function transformMat4(out: Box3, box: Box3, mat: Mat4): Box3;
+/**
+ * Test if a point is contained within the bounding box
+ * @param box - The bounding box
+ * @param point - The point to test
+ * @returns true if the point is inside or on the boundary of the box
+ */
+export declare function containsPoint(box: Box3, point: Vec3): boolean;
+/**
+ * Test if one Box3 completely contains another Box3
+ * @param container - The potentially containing Box3
+ * @param contained - The Box3 that might be contained
+ * @returns true if the container Box3 completely contains the contained Box3
+ */
+export declare function containsBox3(container: Box3, contained: Box3): boolean;
+/**
+ * Check whether two bounding boxes intersect
+ */
+export declare function intersectsBox3(boxA: Box3, boxB: Box3): boolean;
+/**
+ * Test whether an axis-aligned bounding box intersects a triangle, via the
+ * separating-axis theorem over 13 axes: the 3 box face normals, the triangle
+ * face normal, and the 9 box-axis × triangle-edge cross products.
+ *
+ * Fully inlined with local scalars — no scratch arrays or per-call allocations.
+ * Axes are tested cheapest-first (box faces, i.e. the triangle-vs-box AABB
+ * reject) so the common non-overlapping case exits before any edge or cross
+ * product is computed. On each edge-cross axis two of the three vertices project
+ * to the same value (the axis is perpendicular to that edge), so only two
+ * projections are needed. An all-zero cross axis (edge parallel to a box axis)
+ * collapses every projection and the radius to 0, passing automatically.
+ */
+export declare function intersectsTriangle3(box: Box3, a: Vec3, b: Vec3, c: Vec3): boolean;
+/**
+ * Test intersection between axis-aligned bounding box and a sphere.
+ */
+export declare function intersectsSphere(box: Box3, sphere: Sphere): boolean;
+/**
+ * Test intersection between axis-aligned bounding box and plane.
+ */
+export declare function intersectsPlane3(box: Box3, plane: Plane3): boolean;

package/dist/src/shapes/circle.d.ts

@@ -0,0 +1,7 @@
+import type { Vec2 } from '../core/vec2.js';
+/** A circle in 2D space */
+export type Circle = {
+    center: Vec2;
+    radius: number;
+};
+export declare function create(): Circle;

package/dist/src/shapes/frustum.d.ts

@@ -0,0 +1,147 @@
+import type { Mat4 } from '../core/mat4.js';
+import type { Vec3 } from '../core/vec3.js';
+import type { Box3 } from './box3.js';
+import type { Plane3 } from './plane3.js';
+import type { Sphere } from './sphere.js';
+/**
+ * A view frustum, represented as the six bounding planes of a camera's view volume.
+ * Ordered as [left, right, bottom, top, near, far]. Plane normals point inward, so a
+ * point is inside the frustum when its signed distance to every plane is >= 0.
+ */
+export type Frustum = [Plane3, Plane3, Plane3, Plane3, Plane3, Plane3];
+/**
+ * The eight corners of a frustum, as returned by [[corners]].
+ * Ordered near bottom-left, near top-left, near top-right, near bottom-right,
+ * then the same four in the far plane.
+ */
+export type FrustumCorners = [Vec3, Vec3, Vec3, Vec3, Vec3, Vec3, Vec3, Vec3];
+/**
+ * Creates a new frustum of zeroed planes.
+ * @returns A new frustum
+ */
+export declare function create(): Frustum;
+/**
+ * Clones a frustum.
+ * @param f - The frustum to clone
+ * @returns A new frustum
+ */
+export declare function clone(f: Frustum): Frustum;
+/**
+ * Copies one frustum to another.
+ * @param out - The output frustum
+ * @param f - The source frustum
+ * @returns The output frustum
+ */
+export declare function copy(out: Frustum, f: Frustum): Frustum;
+/**
+ * Extracts the six planes of a view frustum from a projection and view matrix, using the
+ * OpenGL / WebGL clip-space depth convention (NDC z in [-1, 1]).
+ *
+ * Pair this with `mat4.perspectiveNO`, `mat4.frustumNO` or `mat4.orthoNO`.
+ *
+ * @param out - The output frustum
+ * @param proj - The projection matrix
+ * @param view - The view matrix
+ * @returns The output frustum
+ */
+export declare function setFromViewProjectionMatrixNO(out: Frustum, proj: Mat4, view: Mat4): Frustum;
+/**
+ * Extracts the six planes of a view frustum from a projection and view matrix, using the
+ * WebGPU / Vulkan / D3D / Metal clip-space depth convention (NDC z in [0, 1]).
+ *
+ * Pair this with `mat4.perspectiveZO`, `mat4.frustumZO` or `mat4.orthoZO`.
+ *
+ * @param out - The output frustum
+ * @param proj - The projection matrix
+ * @param view - The view matrix
+ * @returns The output frustum
+ */
+export declare function setFromViewProjectionMatrixZO(out: Frustum, proj: Mat4, view: Mat4): Frustum;
+/**
+ * Extracts only the four lateral planes (left, right, bottom, top) of a view frustum from a
+ * projection and view matrix, skipping near and far. This is convention-independent — the
+ * NO/ZO split only affects the near plane — so it pairs with any projection matrix.
+ *
+ * Intended for streaming pipelines that already cull distant content and only need to reject
+ * objects outside the camera's sides. Test against the result with `frustum.sidesIntersectsSphere`,
+ * `frustum.sidesIntersectsBox3`, `frustum.sidesContainsPoint` or `frustum.sidesIntersectsRay`.
+ *
+ * @param out - The output frustum; only slots 0-3 are written
+ * @param proj - The projection matrix
+ * @param view - The view matrix
+ * @returns The output frustum
+ */
+export declare function setFromViewProjectionMatrixSides(out: Frustum, proj: Mat4, view: Mat4): Frustum;
+/**
+ * Tests if a sphere intersects the frustum.
+ * @param f - The frustum
+ * @param s - The sphere
+ * @returns True if the sphere intersects or is inside the frustum
+ */
+export declare function intersectsSphere(f: Frustum, s: Sphere): boolean;
+/**
+ * Tests if a sphere intersects the lateral planes of a sides-only frustum, skipping near and far.
+ * @param f - The sides-only frustum
+ * @param s - The sphere
+ * @returns True if the sphere intersects or is inside the frustum's sides
+ */
+export declare function sidesIntersectsSphere(f: Frustum, s: Sphere): boolean;
+/**
+ * Tests if an axis-aligned box intersects the frustum, using the p-vertex test.
+ * @param f - The frustum
+ * @param box - The box
+ * @returns True if the box intersects or is inside the frustum
+ */
+export declare function intersectsBox3(f: Frustum, box: Box3): boolean;
+/**
+ * Tests if an axis-aligned box intersects the lateral planes of a sides-only frustum, using the
+ * p-vertex test, skipping near and far.
+ * @param f - The sides-only frustum
+ * @param box - The box
+ * @returns True if the box intersects or is inside the frustum's sides
+ */
+export declare function sidesIntersectsBox3(f: Frustum, box: Box3): boolean;
+/**
+ * Tests if a point is inside the frustum.
+ * @param f - The frustum
+ * @param p - The point
+ * @returns True if the point is inside or on the boundary of the frustum
+ */
+export declare function containsPoint(f: Frustum, p: Vec3): boolean;
+/**
+ * Tests if a point is inside the lateral planes of a sides-only frustum, skipping near and far.
+ * @param f - The sides-only frustum
+ * @param p - The point
+ * @returns True if the point is inside or on the boundary of the frustum's sides
+ */
+export declare function sidesContainsPoint(f: Frustum, p: Vec3): boolean;
+/**
+ * Tests if a ray intersects the frustum, using a slab test over the planes.
+ * A ray that starts inside the frustum always intersects.
+ * @param f - The frustum
+ * @param origin - Ray origin
+ * @param direction - Ray direction (need not be normalized)
+ * @returns True if the ray intersects the frustum
+ */
+export declare function intersectsRay(f: Frustum, origin: Vec3, direction: Vec3): boolean;
+/**
+ * Tests if a ray intersects the lateral planes of a sides-only frustum, using a slab test over the
+ * planes, skipping near and far. A ray that starts inside the sides always intersects.
+ * @param f - The sides-only frustum
+ * @param origin - Ray origin
+ * @param direction - Ray direction (need not be normalized)
+ * @returns True if the ray intersects the frustum's sides
+ */
+export declare function sidesIntersectsRay(f: Frustum, origin: Vec3, direction: Vec3): boolean;
+/**
+ * Computes the eight corners of the frustum by intersecting three planes each.
+ * The frustum must be a full six-plane frustum (near and far present).
+ *
+ * Output order: near bottom-left, near top-left, near top-right, near bottom-right,
+ * far bottom-left, far top-left, far top-right, far bottom-right.
+ *
+ * @param out - The output corners (8 vec3s)
+ * @param f - The frustum
+ * @returns The output corners
+ */
+export declare function corners(out: FrustumCorners, f: Frustum): FrustumCorners;

package/dist/src/shapes/index.d.ts

@@ -0,0 +1,20 @@
+export type * from '../core/index.js';
+export * as box2 from './box2.js';
+export type { Box2 } from './box2.js';
+export * as box3 from './box3.js';
+export type { Box3 } from './box3.js';
+export * as obb3 from './obb3.js';
+export type { OBB3 } from './obb3.js';
+export * as plane3 from './plane3.js';
+export type { Plane3 } from './plane3.js';
+export * as sphere from './sphere.js';
+export type { Sphere } from './sphere.js';
+export * as circle from './circle.js';
+export type { Circle } from './circle.js';
+export * as segment2 from './segment2.js';
+export * as polygon2 from './polygon2.js';
+export * as triangle2 from './triangle2.js';
+export * as triangle3 from './triangle3.js';
+export * as raycast3 from './raycast3.js';
+export * as frustum from './frustum.js';
+export type { Frustum, FrustumCorners } from './frustum.js';

package/dist/src/shapes/obb3.d.ts

@@ -0,0 +1,105 @@
+import type { Mat3 } from '../core/mat3.js';
+import type { Mat4 } from '../core/mat4.js';
+import type { Quat } from '../core/quat.js';
+import type { Vec3 } from '../core/vec3.js';
+import type { Box3 } from './box3.js';
+/** An oriented bounding box in 3D space */
+export type OBB3 = {
+    center: Vec3;
+    halfExtents: Vec3;
+    rotation: Mat3;
+};
+export declare function create(): OBB3;
+export declare function clone(a: OBB3): OBB3;
+export declare function copy(out: OBB3, a: OBB3): OBB3;
+/**
+ * Sets an OBB from center, half extents, and a rotation matrix.
+ * @param out the OBB to store the result
+ * @param center the center of the OBB
+ * @param halfExtents the half extents of the OBB
+ * @param rotation the Mat3 rotation matrix
+ * @returns the OBB with the given center, half extents, and rotation
+ */
+export declare function set(out: OBB3, center: Vec3, halfExtents: Vec3, rotation: Mat3): OBB3;
+/**
+ * Sets an OBB from center, half extents, and a quaternion.
+ * Convenience helper for users who store orientation as a quaternion.
+ *
+ * @param out - The OBB to store the result
+ * @param center - The center of the OBB
+ * @param halfExtents - The half extents of the OBB
+ * @param q - The quaternion representing the OBB's orientation
+ * @returns out
+ */
+export declare function setFromCenterHalfExtentsQuaternion(out: OBB3, center: Vec3, halfExtents: Vec3, q: Quat): OBB3;
+/**
+ * Creates an OBB from an axis-aligned bounding box (AABB).
+ * The resulting OBB will have the same center and extents as the AABB,
+ * with no rotation (identity orientation).
+ *
+ * @param out - The OBB to store the result
+ * @param aabb - The AABB (min and max corners)
+ * @returns out
+ */
+export declare function setFromBox3(out: OBB3, aabb: Box3): OBB3;
+/**
+ * Tests whether a point is contained within an OBB.
+ *
+ * @param obb - The OBB to test
+ * @param point - The point to test
+ * @returns true if the point is inside the OBB
+ */
+export declare function containsPoint(obb: OBB3, point: Vec3): boolean;
+/**
+ * Clamps a point to the surface or interior of an OBB.
+ * Reference: Closest Point on OBB to Point in Real-Time Collision Detection
+ * by Christer Ericson (chapter 5.1.4)
+ *
+ * @param out - The clamped point result
+ * @param obb - The OBB
+ * @param point - The point to clamp
+ * @returns out
+ */
+export declare function clampPoint(out: Vec3, obb: OBB3, point: Vec3): Vec3;
+/**
+ * Tests whether an OBB intersects with another OBB using the Separating Axis Theorem.
+ * Reference: OBB-OBB Intersection in Real-Time Collision Detection
+ * by Christer Ericson (chapter 4.4.1)
+ *
+ * A cross-product axis A_i x B_j degenerates to ~zero when those edges are near
+ * parallel, which makes its (un-normalised) separation test numerically unstable.
+ * Such an axis carries no separation information not already covered by the face
+ * axes, so it is skipped when `1 - R[i][j]^2` (its squared length, = sin^2 of the
+ * angle between the edges) falls below `epsilon`. This is scale-invariant — R is a
+ * matrix of cosines — unlike fudging the projected radii.
+ *
+ * @param a - The first OBB
+ * @param b - The second OBB
+ * @param epsilon - Squared-sine threshold below which near-parallel edge axes are skipped
+ * @returns true if the OBBs intersect
+ */
+export declare function intersectsOBB3(a: OBB3, b: OBB3, epsilon?: number): boolean;
+/**
+ * Tests whether an OBB intersects with an AABB.
+ *
+ * Specialised form of {@link intersectsOBB3}: the AABB's axes are the world axes, so
+ * the axis dot-product matrix R is just the OBB's rotation (no 9 dot-products), and the
+ * AABB's centre/half-extents come straight from its min/max. The near-parallel edge
+ * skip works identically — here it fires when an OBB axis aligns with a world axis.
+ *
+ * @param obb - The OBB
+ * @param aabb - The AABB (axis-aligned bounding box)
+ * @returns true if they intersect
+ */
+export declare function intersectsBox3(obb: OBB3, aabb: Box3): boolean;
+/**
+ * Applies a 4x4 transformation matrix to an OBB.
+ * This can be used to transform the bounding volume with the world matrix
+ * of a 3D object to keep both entities in sync.
+ *
+ * @param out - The transformed OBB
+ * @param obb - The OBB to transform
+ * @param matrix - The 4x4 transformation matrix
+ * @returns out
+ */
+export declare function applyMatrix4(out: OBB3, obb: OBB3, matrix: Mat4): OBB3;