aether-physics 0.0.0-stage → 0.1.0

package/dist/types/engine/loop.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Fixed-timestep simulation clock with an accumulator.
+ *
+ * @see https://gafferongames.com/post/fix_your_timestep/
+ */
+export interface FrameResult {
+    /** Number of steps run. */
+    steps: number;
+    /** Interpolation factor in [0, 1) between the previous and current state. 1 while paused. */
+    alpha: number;
+    /** Whether accumulated time was discarded after reaching `maxStepsPerFrame`. */
+    droppedTime: boolean;
+}
+export declare class FixedStepLoop {
+    #private;
+    /** Simulation speed relative to real time. */
+    timeScale: number;
+    paused: boolean;
+    maxStepsPerFrame: number;
+    constructor(hz?: number);
+    /** Seconds per physics step. */
+    get dt(): number;
+    get hz(): number;
+    set hz(value: number);
+    /** Simulated time in seconds since the last reset. */
+    get simTime(): number;
+    /** Queues one step for the next `advance` call, regardless of `paused`. */
+    stepOnce(): void;
+    reset(): void;
+    /**
+     * Advances the clock and runs `step` once per elapsed timestep.
+     *
+     * @param nowMs - Current timestamp in milliseconds.
+     * @param step - Called with the fixed timestep in seconds.
+     */
+    advance(nowMs: number, step: (dt: number) => void): FrameResult;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export { FixedStepLoop } from './engine/loop.js';
+export type { FrameResult } from './engine/loop.js';
+export { EPSILON, approxEqual, clamp, Vec3, Mat3x3, Mat3x4, Quaternion } from './math/index.js';
+export type { QuatLike, Vec3Like } from './math/index.js';

package/dist/types/math/geometry/mat3x3.d.ts

@@ -0,0 +1,270 @@
+import type { QuatLike, Vec3Like } from "../types.js";
+import { Vec3 } from "./vec3.js";
+/**
+ * A 3×3 matrix for linear transforms (rotation, scale, shear, reflection) and other 3×3
+ * quantities such as inertia tensors.
+ *
+ * Conventions:
+ *
+ * - **Row-major storage.** Element (row `r`, column `c`) is `elements[r * 3 + c]`, and the
+ *   constructor takes arguments in reading order, so source code looks like the matrix on paper.
+ * - **Column vectors.** Vectors are transformed as `M · v`. In a product `A · B`, `B` is
+ *   applied first, then `A`.
+ * - **Columns are basis axes.** For a rotation from a child frame into its parent, column `i` is
+ *   the child's `i`-th axis expressed in the parent frame. For a rigid body's orientation the
+ *   columns are the body's X, Y and Z axes in world space.
+ * - **Right-hand rule.** A positive angle turns counter-clockwise when looking from the tip of
+ *   the rotation axis back toward the origin.
+ * - **Mutation and output.** Methods that modify this matrix do it in place and return `this`
+ *   for chaining. Methods that produce a vector write to an optional `out`, allocating one if
+ *   it is omitted. Inputs may alias `this` or `out`.
+ * - **`Orthonormal` variants.** Methods with `Orthonormal` in the name, and
+ *   `transformInverseVec3`, assume a pure rotation (or reflection) and use the transpose as the
+ *   inverse. Their results are undefined if the matrix contains scale or shear.
+ *
+ * The layout differs from Three.js: `THREE.Matrix3.elements` is column-major. Do not copy
+ * `elements` arrays between the two directly.
+ */
+export declare class Mat3x3 {
+    /** The nine elements in row-major order: `[m00, m01, m02, m10, m11, m12, m20, m21, m22]`. */
+    readonly elements: Float64Array;
+    /**
+     * Creates a matrix from its elements in row-major (reading) order. Defaults to the identity.
+     */
+    constructor(m00?: number, m01?: number, m02?: number, m10?: number, m11?: number, m12?: number, m20?: number, m21?: number, m22?: number);
+    /**
+     * Sets this matrix to the identity, which leaves every vector unchanged.
+     */
+    identity(): this;
+    /**
+     * Copies the elements of `m` into this matrix.
+     *
+     * @param m Source matrix.
+     */
+    copy(m: Mat3x3): this;
+    /**
+     * Returns a new matrix with the same elements as this one.
+     */
+    clone(): Mat3x3;
+    /**
+     * Sets this matrix to a diagonal matrix with `a`, `b` and `c` on the diagonal and zeros
+     * elsewhere.
+     *
+     * Overwrites the current contents. Used for axis-aligned scaling and for the inertia tensor
+     * of a shape aligned with its principal axes.
+     *
+     * @param a Element (0, 0).
+     * @param b Element (1, 1).
+     * @param c Element (2, 2).
+     */
+    setDiagonal(a: number, b: number, c: number): this;
+    /**
+     * Sets this matrix to a scaling matrix that stretches each axis by its own factor.
+     *
+     * Pass a single factor for uniform scaling: `setScale(2)` scales every axis by 2.
+     * Overwrites the current contents rather than scaling them.
+     *
+     * @param x Scale factor along the X axis.
+     * @param y Scale factor along the Y axis. Defaults to `x`.
+     * @param z Scale factor along the Z axis. Defaults to `x`.
+     */
+    setScale(x: number, y?: number, z?: number): this;
+    /**
+     * Sets this matrix to a scale by factor `k` along an arbitrary `axis` through the origin.
+     *
+     * Components parallel to `axis` are multiplied by `k`; components perpendicular to it
+     * are left unchanged. The result is `I + (k - 1) · axis · axisᵀ`, which is symmetric.
+     * With a cardinal axis this matches `setScale` with `k` on that axis and 1 elsewhere.
+     * `k = -1` reflects across the plane perpendicular to `axis`, and `k = 0` projects onto it.
+     *
+     * `axis` must be a unit vector. It is not normalized here, to keep this cheap on hot
+     * paths. A non-unit axis scales by `1 + (k - 1)·|axis|²` instead of `k`. Call
+     * `normalize()` on the axis first if it is not already unit length.
+     *
+     * @param axis Unit-length scaling axis. Its sign does not matter.
+     * @param k Scale factor along `axis`.
+     */
+    setScaleAlongAxis(axis: Vec3Like, k: number): this;
+    /**
+     * Sets this matrix to a reflection across the plane perpendicular to `normal`.
+     *
+     * Components along `normal` are negated; components in the plane are left unchanged.
+     * The result is `I - 2 · normal · normalᵀ`: symmetric, orthogonal, its own inverse, with
+     * determinant -1. Equivalent to `setScaleAlongAxis(normal, -1)`. With a cardinal axis
+     * this negates that one coordinate, e.g. `(1, 0, 0)` mirrors across the YZ plane.
+     *
+     * `normal` must be a unit vector. It is not normalized here, to keep this cheap on hot
+     * paths. A non-unit normal does not produce a reflection. Call `normalize()` on it first
+     * if it is not already unit length.
+     *
+     * @param normal Unit-length normal of the mirror plane. Its sign does not matter.
+     */
+    setReflection(normal: Vec3Like): this;
+    /**
+     * Sets this matrix to a shear: each coordinate is offset in proportion to the
+     * others.
+     *
+     * Factor `ab` is how far coordinate `a` moves per unit of coordinate `b`, and is stored
+     * in the matching off-diagonal element (`xy` → `m01`):
+     *
+     * ```
+     * x' = x + xy·y + xz·z
+     * y' = y + yx·x + yz·z
+     * z' = z + zx·x + zy·y
+     * ```
+     *
+     * Omitted factors default to 0, so `setShear(2)` shears X by Y only, and no arguments
+     * gives the identity. Shearing a coordinate by one or both of the others is volume
+     * preserving (determinant 1). Combining shears in both directions between a pair, such as
+     * `xy` with `yx`, is not: the determinant is
+     * `1 - xy·yx - xz·zx - yz·zy + xy·yz·zx + xz·zy·yx`.
+     *
+     * @param xy Shift of X per unit of Y.
+     * @param xz Shift of X per unit of Z.
+     * @param yx Shift of Y per unit of X.
+     * @param yz Shift of Y per unit of Z.
+     * @param zx Shift of Z per unit of X.
+     * @param zy Shift of Z per unit of Y.
+     */
+    setShear(xy?: number, xz?: number, yx?: number, yz?: number, zx?: number, zy?: number): this;
+    /**
+     * Multiplies every element of this matrix by the scalar `k`, in place.
+     *
+     * Unlike `setScale`, this keeps the current contents and scales them.
+     *
+     * @param k Scalar to multiply by.
+     */
+    multiplyScalar(k: number): this;
+    /**
+     * Post-multiplies this matrix by `m`: `this = this · m`.
+     *
+     * Under the column-vector convention, the result applies `m` first, then this.
+     *
+     * @param m Right-hand operand. May be `this`.
+     */
+    multiply(m: Mat3x3): this;
+    /**
+     * Pre-multiplies this matrix by `m`: `this = m · this`.
+     *
+     * Under the column-vector convention, the result applies this first, then `m`.
+     *
+     * @param m Left-hand operand. May be `this`.
+     */
+    premultiply(m: Mat3x3): this;
+    /**
+     * Sets this matrix to `a · b`.
+     *
+     * @param a Left-hand operand. May be `this`.
+     * @param b Right-hand operand. May be `this`.
+     */
+    multiplyMatrices(a: Mat3x3, b: Mat3x3): this;
+    /**
+     * Transposes this matrix in place, swapping rows and columns: element (r, c) becomes
+     * element (c, r).
+     *
+     * For an orthonormal matrix the transpose is the inverse.
+     */
+    transpose(): this;
+    /**
+     * Returns the determinant: the factor by which this matrix scales volumes.
+     *
+     * Zero means the matrix is singular and has no inverse. A negative value means it includes
+     * a reflection. Rotations have determinant 1.
+     */
+    determinant(): number;
+    /**
+     * Sets this matrix to the inverse of `m`, or to zero if `m` is singular.
+     *
+     * @param m Matrix to invert. May be `this`.
+     */
+    setInverse(m: Mat3x3): this;
+    /**
+     * Inverts this matrix in place, or sets it to zero if it is singular.
+     */
+    inverse(): this;
+    /**
+     * Sets this matrix to the inverse of `m`, assuming `m` is orthonormal.
+     *
+     * Computes `mᵀ`, which equals `m⁻¹` for any orthonormal matrix: rotations, reflections
+     * and their products. The result is undefined if `m` contains scale or shear.
+     *
+     * @param m Matrix to invert. May be `this`.
+     */
+    setInverseOrthonormal(m: Mat3x3): this;
+    /**
+     * Inverts this matrix in place, assuming it is orthonormal.
+     */
+    inverseOrthonormal(): this;
+    /**
+     * Computes `this · v` and writes it to `out`.
+     *
+     * @param v Vector to transform.
+     * @param out Destination. Allocated if omitted. May be `v`.
+     */
+    transformVec3(v: Vec3Like, out?: Vec3): Vec3;
+    /**
+     * Computes `thisᵀ · v`, the inverse transform of `v`, without building the inverse.
+     *
+     * Assumes this matrix is orthonormal.
+     *
+     * @param v Vector to transform.
+     * @param out Destination. Allocated if omitted. May be `v`.
+     */
+    transformInverseVec3(v: Vec3Like, out?: Vec3): Vec3;
+    /**
+     * Sets this matrix to a rotation of `theta` radians about the X axis.
+     *
+     * Positive angles turn counter-clockwise when looking from +X back toward the origin,
+     * so a quarter turn carries the Y axis onto the Z axis.
+     *
+     * @param theta Angle in radians.
+     */
+    setRotationX(theta: number): this;
+    /**
+     * Sets this matrix to a rotation of `theta` radians about the Y axis.
+     *
+     * Positive angles turn counter-clockwise when looking from +Y back toward the origin,
+     * so a quarter turn carries the Z axis onto the X axis.
+     *
+     * @param theta Angle in radians.
+     */
+    setRotationY(theta: number): this;
+    /**
+     * Sets this matrix to a rotation of `theta` radians about the Z axis.
+     *
+     * Positive angles turn counter-clockwise when looking from +Z back toward the origin,
+     * so a quarter turn carries the X axis onto the Y axis.
+     *
+     * @param theta Angle in radians.
+     */
+    setRotationZ(theta: number): this;
+    /**
+     * Sets this matrix to a rotation of `angle` radians about an arbitrary `axis`.
+     *
+     * Positive angles turn counter-clockwise when looking from the tip of `axis` back toward
+     * the origin. With a cardinal axis this matches `setRotationX`, `setRotationY` or
+     * `setRotationZ`.
+     *
+     * `axis` must be a unit vector. It is not normalized here, to keep this cheap on hot
+     * paths. A non-unit axis generally produces a matrix that is not a rotation: it
+     * distorts lengths and angles. Call `normalize()` on the axis first if it is not
+     * already unit length.
+     *
+     * @param axis Unit-length rotation axis.
+     * @param angle Angle in radians.
+     */
+    setFromAxisAngle(axis: Vec3Like, angle: number): this;
+    /**
+     * Sets this matrix to the rotation represented by the quaternion `q`, so that
+     * `transformVec3(v)` equals `q.rotateVec3(v)`.
+     *
+     * The columns are the images of the X, Y and Z axes under `q`. `q` and `−q` give the same
+     * matrix.
+     *
+     * `q` must be unit length. It is not normalized here, to keep this cheap on hot paths. A
+     * non-unit `q` generally produces a matrix that is not a rotation.
+     *
+     * @param q Unit quaternion.
+     */
+    setFromQuaternion(q: QuatLike): this;
+}

package/dist/types/math/geometry/mat3x4.d.ts

@@ -0,0 +1,338 @@
+import type { QuatLike, Vec3Like } from "../types.js";
+import { Mat3x3 } from "./mat3x3.js";
+import { Vec3 } from "./vec3.js";
+/**
+ * A 3×4 affine transform: a 3×3 linear part `A` with a translation column `t`.
+ *
+ * Behaves as a 4×4 matrix whose implicit bottom row is `[0, 0, 0, 1]`, mapping a point
+ * `p ↦ A·p + t`: the linear part is applied first, then the translation. Typically it holds a
+ * rigid transform from a child frame into its parent, such as a body's local-to-world transform.
+ *
+ * Conventions:
+ *
+ * - **Row-major storage.** Element (row `r`, column `c`) is `elements[r * 4 + c]`, and the
+ *   constructor takes arguments in reading order. The translation is at indices 3, 7 and 11.
+ * - **Column vectors.** Vectors are transformed as `M · v`. In a product `A · B`, `B` is
+ *   applied first, then `A`.
+ * - **Columns are the child frame.** For a rigid transform, columns 0–2 are the child's X, Y and
+ *   Z axes in the parent frame, and column 3 is the child's origin in the parent frame.
+ * - **Points and directions.** `transformPoint` applies the translation; `transformDirection`
+ *   applies only the linear part. Use directions for normals, velocities and axes.
+ * - **Right-hand rule.** A positive angle turns counter-clockwise when looking from the tip of
+ *   the rotation axis back toward the origin.
+ * - **Mutation and output.** Methods that modify this transform do it in place and return
+ *   `this` for chaining. Methods that produce a vector write to an optional `out`, allocating
+ *   one if it is omitted. Inputs may alias `this` or `out`.
+ * - **`Orthonormal` and `transformInverse*` methods.** These assume the linear part is a pure
+ *   rotation (or reflection) and use its transpose as the inverse. Their results are undefined
+ *   if the linear part contains scale or shear.
+ *
+ * Three.js has no 3×4 type, and `THREE.Matrix4.elements` is column-major. Build Three.js
+ * transforms from a position and a quaternion instead of copying `elements`.
+ */
+export declare class Mat3x4 {
+    /**
+     * The twelve elements in row-major order:
+     * `[m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23]`.
+     */
+    readonly elements: Float64Array;
+    /**
+     * Creates a transform from its elements in row-major (reading) order. Defaults to the
+     * identity.
+     */
+    constructor(m00?: number, m01?: number, m02?: number, m03?: number, m10?: number, m11?: number, m12?: number, m13?: number, m20?: number, m21?: number, m22?: number, m23?: number);
+    /**
+     * Sets this transform to the identity: no rotation, scale or translation.
+     */
+    identity(): this;
+    /**
+     * Copies the elements of `m` into this transform.
+     *
+     * @param m Source transform.
+     */
+    copy(m: Mat3x4): this;
+    /**
+     * Returns a new transform with the same elements as this one.
+     */
+    clone(): Mat3x4;
+    /**
+     * Sets this transform from a 3×3 linear part `m` and a translation `t`: `p ↦ m·p + t`.
+     *
+     * @param m Linear part.
+     * @param t Translation. Defaults to zero.
+     */
+    setFromMat3x3(m: Mat3x3, t?: Vec3Like): this;
+    /**
+     * Copies the 3×3 linear part of this transform into `out`, dropping the translation.
+     *
+     * @param out Destination. Allocated if omitted.
+     */
+    getMat3x3(out?: Mat3x3): Mat3x3;
+    /**
+     * Sets this transform to a pure translation by `(x, y, z)`.
+     *
+     * Overwrites the current contents: the linear part becomes the identity.
+     *
+     * @param x Translation along the X axis.
+     * @param y Translation along the Y axis.
+     * @param z Translation along the Z axis.
+     */
+    setTranslation(x: number, y: number, z: number): this;
+    /**
+     * Copies the translation column of this transform into `out`.
+     *
+     * This is where the transform sends the origin.
+     *
+     * @param out Destination. Allocated if omitted.
+     */
+    getTranslation(out?: Vec3): Vec3;
+    /**
+     * Copies column `index` of this transform into `out`.
+     *
+     * For a rigid transform, columns 0–2 are the child frame's X, Y and Z axes in the parent
+     * frame, and column 3 is its origin, the same as `getTranslation`.
+     *
+     * @param index Column to read: 0, 1 or 2 for an axis, 3 for the translation.
+     * @param out Destination. Allocated if omitted.
+     */
+    getAxis(index: 0 | 1 | 2 | 3, out?: Vec3): Vec3;
+    /**
+     * Sets this transform to the rigid transform that rotates by `q` and then translates by
+     * `p`: `x ↦ q·x·q* + p`.
+     *
+     * For a rigid body, `p` is its position and `q` its orientation, giving the body-to-world
+     * transform. The linear part matches `Mat3x3.setFromQuaternion(q)`.
+     *
+     * `q` must be unit length. It is not normalized here, to keep this cheap on hot paths.
+     *
+     * @param p Translation, the child frame's origin in the parent frame.
+     * @param q Unit quaternion for the rotation.
+     */
+    setFromPositionQuaternion(p: Vec3Like, q: QuatLike): this;
+    /**
+     * Sets this transform to a scaling about the origin that stretches each axis by its own
+     * factor.
+     *
+     * Pass a single factor for uniform scaling: `setScale(2)` scales every axis by 2.
+     * Overwrites the current contents rather than scaling them, and clears the translation.
+     *
+     * @param x Scale factor along the X axis.
+     * @param y Scale factor along the Y axis. Defaults to `x`.
+     * @param z Scale factor along the Z axis. Defaults to `x`.
+     */
+    setScale(x: number, y?: number, z?: number): this;
+    /**
+     * Sets this transform to a scale by factor `k` along an arbitrary `axis` through the origin.
+     *
+     * Components parallel to `axis` are multiplied by `k`; components perpendicular to it
+     * are left unchanged. The linear part is `I + (k - 1) · axis · axisᵀ`, which is symmetric.
+     * With a cardinal axis this matches `setScale` with `k` on that axis and 1 elsewhere.
+     * `k = -1` reflects across the plane perpendicular to `axis`, and `k = 0` projects onto it.
+     *
+     * `axis` must be a unit vector. It is not normalized here, to keep this cheap on hot
+     * paths. A non-unit axis scales by `1 + (k - 1)·|axis|²` instead of `k`. Call
+     * `normalize()` on the axis first if it is not already unit length.
+     *
+     * Clears the translation.
+     *
+     * @param axis Unit-length scaling axis. Its sign does not matter.
+     * @param k Scale factor along `axis`.
+     */
+    setScaleAlongAxis(axis: Vec3Like, k: number): this;
+    /**
+     * Sets this transform to a reflection across the plane through the origin perpendicular
+     * to `normal`.
+     *
+     * Components along `normal` are negated; components in the plane are left unchanged.
+     * The result is `I - 2 · normal · normalᵀ`: symmetric, orthogonal, its own inverse, with
+     * determinant -1. Equivalent to `setScaleAlongAxis(normal, -1)`. With a cardinal axis
+     * this negates that one coordinate, e.g. `(1, 0, 0)` mirrors across the YZ plane.
+     *
+     * `normal` must be a unit vector. It is not normalized here, to keep this cheap on hot
+     * paths. A non-unit normal does not produce a reflection. Call `normalize()` on it first
+     * if it is not already unit length.
+     *
+     * Clears the translation.
+     *
+     * @param normal Unit-length normal of the mirror plane. Its sign does not matter.
+     */
+    setReflection(normal: Vec3Like): this;
+    /**
+     * Sets this transform to a shear about the origin: each coordinate is offset in proportion to the
+     * others.
+     *
+     * Factor `ab` is how far coordinate `a` moves per unit of coordinate `b`, and is stored
+     * in the matching off-diagonal element (`xy` → `m01`):
+     *
+     * ```
+     * x' = x + xy·y + xz·z
+     * y' = y + yx·x + yz·z
+     * z' = z + zx·x + zy·y
+     * ```
+     *
+     * Omitted factors default to 0, so `setShear(2)` shears X by Y only, and no arguments
+     * gives the identity. Shearing a coordinate by one or both of the others is volume
+     * preserving (determinant 1). Combining shears in both directions between a pair, such as
+     * `xy` with `yx`, is not: the determinant is
+     * `1 - xy·yx - xz·zx - yz·zy + xy·yz·zx + xz·zy·yx`.
+     *
+     * Clears the translation.
+     *
+     * @param xy Shift of X per unit of Y.
+     * @param xz Shift of X per unit of Z.
+     * @param yx Shift of Y per unit of X.
+     * @param yz Shift of Y per unit of Z.
+     * @param zx Shift of Z per unit of X.
+     * @param zy Shift of Z per unit of Y.
+     */
+    setShear(xy?: number, xz?: number, yx?: number, yz?: number, zx?: number, zy?: number): this;
+    /**
+     * Multiplies every element of this transform by the scalar `k`, in place, including
+     * the translation.
+     *
+     * Unlike `setScale`, this keeps the current contents and scales them. Equivalent to
+     * scaling the result of every `transformPoint` by `k`.
+     *
+     * @param k Scalar to multiply by.
+     */
+    multiplyScalar(k: number): this;
+    /**
+     * Post-multiplies this transform by `m`: `this = this · m`.
+     *
+     * Under the column-vector convention, the result applies `m` first, then this.
+     *
+     * @param m Right-hand operand. May be `this`.
+     */
+    multiply(m: Mat3x4): this;
+    /**
+     * Pre-multiplies this transform by `m`: `this = m · this`.
+     *
+     * Under the column-vector convention, the result applies this first, then `m`.
+     *
+     * @param m Left-hand operand. May be `this`.
+     */
+    premultiply(m: Mat3x4): this;
+    /**
+     * Sets this transform to `a · b`.
+     *
+     * @param a Left-hand operand. May be `this`.
+     * @param b Right-hand operand. May be `this`.
+     */
+    multiplyMatrices(a: Mat3x4, b: Mat3x4): this;
+    /**
+     * Transposes the 3×3 linear part in place. The translation column is unchanged.
+     *
+     * The full 3×4 transpose is 4×3 and has no in-place equivalent.
+     */
+    transposeLinear(): this;
+    /**
+     * Determinant of the 3×3 linear part, which equals that of the full 4×4 transform.
+     */
+    determinant(): number;
+    /**
+     * Sets this transform to the inverse of `m`, or to zero if `m` is singular.
+     *
+     * @param m Transform to invert. May be `this`.
+     */
+    setInverse(m: Mat3x4): this;
+    /**
+     * Inverts this transform in place, or sets it to zero if it is singular.
+     */
+    inverse(): this;
+    /**
+     * Sets this transform to the inverse of `r`, assuming its 3×3 part is orthonormal.
+     *
+     * Computes `[Rᵀ | −Rᵀt]`. The result is undefined if `r` contains scale or shear.
+     *
+     * @param r Transform to invert. May be `this`.
+     */
+    setInverseOrthonormal(r: Mat3x4): this;
+    /**
+     * Inverts this transform in place, assuming its 3×3 part is orthonormal.
+     */
+    inverseOrthonormal(): this;
+    /**
+     * Transforms a point: `R·p + t`.
+     *
+     * @param p Point to transform.
+     * @param out Destination. Allocated if omitted. May be `p`.
+     */
+    transformPoint(p: Vec3Like, out?: Vec3): Vec3;
+    /**
+     * Transforms a direction by the 3×3 part only: `R·d`. Translation is ignored.
+     *
+     * @param d Direction to transform.
+     * @param out Destination. Allocated if omitted. May be `d`.
+     */
+    transformDirection(d: Vec3Like, out?: Vec3): Vec3;
+    /**
+     * Applies the inverse transform to a point, `Rᵀ·(p − t)`, without building the inverse.
+     *
+     * Assumes the 3×3 part is orthonormal.
+     *
+     * @param p Point to transform.
+     * @param out Destination. Allocated if omitted. May be `p`.
+     */
+    transformInversePoint(p: Vec3Like, out?: Vec3): Vec3;
+    /**
+     * Applies the inverse of the 3×3 part to a direction, `Rᵀ·d`, without building the inverse.
+     *
+     * Assumes the 3×3 part is orthonormal.
+     *
+     * @param d Direction to transform.
+     * @param out Destination. Allocated if omitted. May be `d`.
+     */
+    transformInverseDirection(d: Vec3Like, out?: Vec3): Vec3;
+    /**
+     * Sets this transform to a rotation of `theta` radians about the X axis.
+     *
+     * Positive angles turn counter-clockwise when looking from +X back toward the origin,
+     * so a quarter turn carries the Y axis onto the Z axis.
+     *
+     * Clears the translation.
+     *
+     * @param theta Angle in radians.
+     */
+    setRotationX(theta: number): this;
+    /**
+     * Sets this transform to a rotation of `theta` radians about the Y axis.
+     *
+     * Positive angles turn counter-clockwise when looking from +Y back toward the origin,
+     * so a quarter turn carries the Z axis onto the X axis.
+     *
+     * Clears the translation.
+     *
+     * @param theta Angle in radians.
+     */
+    setRotationY(theta: number): this;
+    /**
+     * Sets this transform to a rotation of `theta` radians about the Z axis.
+     *
+     * Positive angles turn counter-clockwise when looking from +Z back toward the origin,
+     * so a quarter turn carries the X axis onto the Y axis.
+     *
+     * Clears the translation.
+     *
+     * @param theta Angle in radians.
+     */
+    setRotationZ(theta: number): this;
+    /**
+     * Sets this transform to a rotation of `angle` radians about an arbitrary `axis`
+     * through the origin.
+     *
+     * Positive angles turn counter-clockwise when looking from the tip of `axis` back toward
+     * the origin. With a cardinal axis this matches `setRotationX`, `setRotationY` or
+     * `setRotationZ`.
+     *
+     * `axis` must be a unit vector. It is not normalized here, to keep this cheap on hot
+     * paths. A non-unit axis generally produces a matrix that is not a rotation: it
+     * distorts lengths and angles. Call `normalize()` on the axis first if it is not
+     * already unit length.
+     *
+     * Clears the translation.
+     *
+     * @param axis Unit-length rotation axis.
+     * @param angle Angle in radians.
+     */
+    setFromAxisAngle(axis: Vec3Like, angle: number): this;
+}