@pawells/math-extended 1.0.1

package/build/matrices/transformations.d.ts

@@ -0,0 +1,484 @@
+/**
+ * @fileoverview Matrix transformation functions for 2D and 3D operations.
+ *
+ * This module provides comprehensive transformation matrix creation and application functions
+ * for computer graphics, game development, and mathematical applications. It includes:
+ *
+ * - Rotation matrices (2D and 3D with Euler angles)
+ * - Scale transformation matrices (uniform and non-uniform)
+ * - Translation matrices for positional transformations
+ * - Vector transformation utilities with homogeneous coordinate support
+ * - View and projection matrices for 3D rendering pipelines
+ *
+ * All matrices use homogeneous coordinates for consistent transformation composition.
+ * 2D transformations use 3x3 matrices, 3D transformations use 4x4 matrices.
+ *
+ * @author JTV Development Team
+ * @since 1.0.0
+ */
+import { IMatrix3, IMatrix4 } from './types.js';
+import { TVector2, TVector3 } from '../vectors/types.js';
+/**
+ * Creates a 2D rotation matrix for rotating points around the origin.
+ *
+ * The matrix rotates points counterclockwise for positive angles in a standard
+ * right-handed coordinate system. Uses homogeneous coordinates for composition
+ * with other 2D transformations.
+ *
+ * Matrix structure:
+ * ```
+ * [cos(θ)  -sin(θ)   0]
+ * [sin(θ)   cos(θ)   0]
+ * [  0        0      1]
+ * ```
+ *
+ * @param radians - Rotation angle in radians (positive = counterclockwise)
+ * @returns {IMatrix3} A 3x3 rotation matrix for 2D transformations
+ *
+ * @throws {Error} If radians is not a finite number
+ *
+ * @example
+ * ```typescript
+ * // 90-degree counterclockwise rotation
+ * const matrix = MatrixRotation2D(Math.PI / 2);
+ *
+ * // 45-degree clockwise rotation
+ * const clockwise = MatrixRotation2D(-Math.PI / 4);
+ * ```
+ */
+export declare function MatrixRotation2D(radians: number): IMatrix3;
+/**
+ * Creates a 3D roll rotation matrix (rotation around the X-axis).
+ *
+ * Roll represents banking motion in aviation terminology. Positive angles
+ * follow the right-hand rule: curl fingers from Y toward Z, thumb points
+ * in positive X direction.
+ *
+ * Matrix structure:
+ * ```
+ * [1    0       0    0]
+ * [0  cos(θ) -sin(θ) 0]
+ * [0  sin(θ)  cos(θ) 0]
+ * [0    0       0    1]
+ * ```
+ *
+ * @param radians - Roll angle in radians (positive = right-hand rule around X-axis)
+ * @returns {IMatrix4} A 4x4 roll rotation matrix
+ *
+ * @throws {Error} If radians is not a finite number
+ *
+ * @example
+ * ```typescript
+ * // 45-degree roll (banking left in aviation)
+ * const rollMatrix = MatrixRotation3DRoll(Math.PI / 4);
+ * ```
+ */
+export declare function MatrixRotation3DRoll(radians: number): IMatrix4;
+/**
+ * Creates a 3D pitch rotation matrix (rotation around the Y-axis).
+ *
+ * Pitch represents elevation motion in aviation terminology. Positive angles
+ * follow the right-hand rule: curl fingers from Z toward X, thumb points
+ * in positive Y direction.
+ *
+ * Matrix structure:
+ * ```
+ * [ cos(θ)  0  sin(θ)  0]
+ * [   0     1    0     0]
+ * [-sin(θ)  0  cos(θ)  0]
+ * [   0     0    0     1]
+ * ```
+ *
+ * @param radians - Pitch angle in radians (positive = nose up in aviation)
+ * @returns {IMatrix4} A 4x4 pitch rotation matrix
+ *
+ * @throws {Error} If radians is not a finite number
+ *
+ * @example
+ * ```typescript
+ * // 30-degree pitch up
+ * const pitchMatrix = MatrixRotation3DPitch(Math.PI / 6);
+ * ```
+ */
+export declare function MatrixRotation3DPitch(radians: number): IMatrix4;
+/**
+ * Creates a 3D yaw rotation matrix (rotation around the Z-axis).
+ *
+ * Yaw represents heading motion in aviation terminology. Positive angles
+ * follow the right-hand rule: curl fingers from X toward Y, thumb points
+ * in positive Z direction.
+ *
+ * Matrix structure:
+ * ```
+ * [cos(θ) -sin(θ)  0  0]
+ * [sin(θ)  cos(θ)  0  0]
+ * [  0       0     1  0]
+ * [  0       0     0  1]
+ * ```
+ *
+ * @param radians - Yaw angle in radians (positive = turn left in aviation)
+ * @returns {IMatrix4} A 4x4 yaw rotation matrix
+ *
+ * @throws {Error} If radians is not a finite number
+ *
+ * @example
+ * ```typescript
+ * // 60-degree yaw left
+ * const yawMatrix = MatrixRotation3DYaw(Math.PI / 3);
+ * ```
+ */
+export declare function MatrixRotation3DYaw(radians: number): IMatrix4;
+/**
+ * Creates a composite 3D rotation matrix from yaw, pitch, and roll components.
+ *
+ * Uses intrinsic rotation sequence: Roll (X) → Pitch (Y) → Yaw (Z), which is
+ * the standard aviation rotation order. The rotations are applied in sequence,
+ * with each rotation being relative to the rotated coordinate system.
+ *
+ * This function supports two call patterns:
+ * 1. Individual angles: MatrixRotation3D(roll, pitch, yaw)
+ * 2. Vector input: MatrixRotation3D([roll, pitch, yaw])
+ *
+ * @param roll - Roll angle in radians (X-axis rotation) or vector [roll, pitch, yaw]
+ * @param pitch - Pitch angle in radians (Y-axis rotation, required if roll is number)
+ * @param yaw - Yaw angle in radians (Z-axis rotation, required if roll is number)
+ * @returns {IMatrix4} A 4x4 composite rotation matrix
+ *
+ * @throws {Error} If any angle is not a finite number
+ *
+ * @example
+ * ```typescript
+ * // Using individual angles (banking, elevation, heading)
+ * const rotationMatrix = MatrixRotation3D(0.1, 0.2, 0.3);
+ *
+ * // Using vector input
+ * const eulerAngles: TVector3 = [0.1, 0.2, 0.3];
+ * const rotationMatrix2 = MatrixRotation3D(eulerAngles);
+ * ```
+ */
+export declare function MatrixRotation3D(roll: number, pitch: number, yaw: number): IMatrix4;
+export declare function MatrixRotation3D(v: TVector3): IMatrix4;
+/**
+ * Creates a composite 3D rotation matrix from Euler angles specified in degrees.
+ *
+ * This is a convenience function that converts degree measurements to radians
+ * before calling MatrixRotation3D. Useful when working with user input or
+ * data sources that use degrees instead of radians.
+ *
+ * Uses the same intrinsic rotation sequence: Roll (X) → Pitch (Y) → Yaw (Z).
+ *
+ * @param roll - Roll angle in degrees (X-axis rotation) or vector [roll, pitch, yaw]
+ * @param pitch - Pitch angle in degrees (Y-axis rotation, required if roll is number)
+ * @param yaw - Yaw angle in degrees (Z-axis rotation, required if roll is number)
+ * @returns {IMatrix4} A 4x4 composite rotation matrix
+ *
+ * @throws {Error} If any angle is not a finite number
+ *
+ * @example
+ * ```typescript
+ * // Using individual angles in degrees
+ * const rotation = MatrixRotation3DEulerAngles(45, 30, 60);
+ *
+ * // Using vector input in degrees
+ * const angles: TVector3 = [45, 30, 60];
+ * const rotation2 = MatrixRotation3DEulerAngles(angles);
+ * ```
+ */
+export declare function MatrixRotation3DEulerAngles(roll: number, pitch: number, yaw: number): IMatrix4;
+export declare function MatrixRotation3DEulerAngles(v: TVector3): IMatrix4;
+/**
+ * Creates a 2D scale transformation matrix with flexible input options.
+ *
+ * Scale factors greater than 1 enlarge objects, factors between 0 and 1 shrink
+ * objects, and negative values flip objects across the corresponding axis.
+ * Uses homogeneous coordinates for composition with other 2D transformations.
+ *
+ * Matrix structure:
+ * ```
+ * [sx  0  0]
+ * [ 0 sy  0]
+ * [ 0  0  1]
+ * ```
+ *
+ * Supports three call patterns:
+ * 1. Uniform scaling: MatrixScale2D(scale)
+ * 2. Independent scaling: MatrixScale2D(x, y)
+ * 3. Vector scaling: MatrixScale2D([x, y])
+ *
+ * @param scale - Uniform scale factor for both axes, OR X-axis scale factor
+ * @param y - Y-axis scale factor (only for independent scaling)
+ * @returns {IMatrix3} A 3x3 scale transformation matrix
+ *
+ * @throws {Error} If any scale factor is not a finite number
+ *
+ * @example
+ * ```typescript
+ * // Uniform scaling (double size)
+ * const uniform = MatrixScale2D(2.0);
+ *
+ * // Independent scaling (stretch horizontally, compress vertically)
+ * const stretch = MatrixScale2D(2.0, 0.5);
+ *
+ * // Vector input
+ * const scaleVector: TVector2 = [1.5, 0.8];
+ * const vectorScale = MatrixScale2D(scaleVector);
+ *
+ * // Flip horizontally
+ * const flip = MatrixScale2D(-1, 1);
+ * ```
+ */
+export declare function MatrixScale2D(scale: number): IMatrix3;
+export declare function MatrixScale2D(x: number, y: number): IMatrix3;
+export declare function MatrixScale2D(v: TVector2): IMatrix3;
+/**
+ * Creates a 3D scale transformation matrix with flexible input options.
+ *
+ * Scale factors greater than 1 enlarge objects, factors between 0 and 1 shrink
+ * objects, and negative values flip objects across the corresponding axis.
+ * Uses homogeneous coordinates for composition with other 3D transformations.
+ *
+ * Matrix structure:
+ * ```
+ * [sx  0  0  0]
+ * [ 0 sy  0  0]
+ * [ 0  0 sz  0]
+ * [ 0  0  0  1]
+ * ```
+ *
+ * Supports three call patterns:
+ * 1. Uniform scaling: MatrixScale3D(scale)
+ * 2. Independent scaling: MatrixScale3D(x, y, z)
+ * 3. Vector scaling: MatrixScale3D([x, y, z])
+ *
+ * @param scale - Uniform scale factor for all axes, OR X-axis scale factor
+ * @param y - Y-axis scale factor (only for independent scaling)
+ * @param z - Z-axis scale factor (only for independent scaling)
+ * @returns {IMatrix4} A 4x4 scale transformation matrix
+ *
+ * @throws {Error} If any scale factor is not a finite number
+ *
+ * @example
+ * ```typescript
+ * // Uniform scaling (triple size)
+ * const uniform = MatrixScale3D(3.0);
+ *
+ * // Independent scaling (stretch, compress, normal)
+ * const stretch = MatrixScale3D(2.0, 0.5, 1.0);
+ *
+ * // Vector input
+ * const scaleVector: TVector3 = [1.5, 0.8, 2.0];
+ * const vectorScale = MatrixScale3D(scaleVector);
+ *
+ * // Mirror across XY plane
+ * const mirror = MatrixScale3D(1, 1, -1);
+ * ```
+ */
+export declare function MatrixScale3D(scale: number): IMatrix4;
+export declare function MatrixScale3D(x: number, y: number, z: number): IMatrix4;
+export declare function MatrixScale3D(v: TVector3): IMatrix4;
+/**
+ * Creates a 2D translation transformation matrix.
+ *
+ * Moves 2D points by the specified offset distances. Uses homogeneous
+ * coordinates to enable composition with other 2D transformations.
+ *
+ * Matrix structure:
+ * ```
+ * [1  0  tx]
+ * [0  1  ty]
+ * [0  0   1]
+ * ```
+ *
+ * @param v - Translation vector [x, y] containing offset distances
+ * @returns {IMatrix3} A 3x3 translation transformation matrix
+ *
+ * @throws {Error} If the input is not a valid 2D vector
+ *
+ * @example
+ * ```typescript
+ * // Move 10 units right, 5 units up
+ * const translation = MatrixTranslation2D(10, 5);
+ *
+ * // Using vector input
+ * const offset: TVector2 = [10, 5];
+ * const translation2 = MatrixTranslation2D(...offset);
+ * ```
+ */
+export declare function MatrixTranslation2D(...v: TVector2): IMatrix3;
+/**
+ * Creates a 3D translation transformation matrix with flexible input options.
+ *
+ * Moves 3D points by the specified offset distances along each axis.
+ * Uses homogeneous coordinates to enable composition with other 3D transformations.
+ *
+ * Matrix structure:
+ * ```
+ * [1  0  0  tx]
+ * [0  1  0  ty]
+ * [0  0  1  tz]
+ * [0  0  0   1]
+ * ```
+ *
+ * Supports three call patterns:
+ * 1. Uniform translation: MatrixTranslation3D(distance)
+ * 2. Independent translation: MatrixTranslation3D(x, y, z)
+ * 3. Vector translation: MatrixTranslation3D([x, y, z])
+ *
+ * @param translationOrX - Uniform translation distance for all axes, OR X-axis distance
+ * @param y - Y-axis translation distance (only for independent translation)
+ * @param z - Z-axis translation distance (only for independent translation)
+ * @returns {IMatrix4} A 4x4 translation transformation matrix
+ *
+ * @throws {Error} If any translation distance is not a finite number
+ *
+ * @example
+ * ```typescript
+ * // Uniform translation (move 5 units in all directions)
+ * const uniform = MatrixTranslation3D(5.0);
+ *
+ * // Independent translation
+ * const independent = MatrixTranslation3D(10, -5, 3);
+ *
+ * // Vector input
+ * const offset: TVector3 = [10, -5, 3];
+ * const vectorTranslation = MatrixTranslation3D(...offset);
+ * ```
+ */
+export declare function MatrixTranslation3D(translation: number): IMatrix4;
+export declare function MatrixTranslation3D(x: number, y: number, z: number): IMatrix4;
+export declare function MatrixTranslation3D(v: TVector3): IMatrix4;
+/**
+ * Transforms a 2D vector using a 3x3 transformation matrix with homogeneous coordinates.
+ *
+ * This function applies a transformation matrix to a 2D vector by:
+ * 1. Converting the 2D vector to homogeneous coordinates (adding w=1)
+ * 2. Performing matrix-vector multiplication
+ * 3. Converting back to 2D by dividing by the homogeneous w component
+ *
+ * This approach enables composition of multiple transformations and supports
+ * affine transformations including translation, rotation, scaling, and shearing.
+ *
+ * @param vector - The 2D vector to transform [x, y]
+ * @param matrix - A 3x3 transformation matrix to apply
+ * @returns {TVector2} The transformed 2D vector
+ *
+ * @throws {Error} If the homogeneous w component is near zero (degenerate transformation)
+ * @throws {Error} If inputs are not valid vector/matrix types
+ *
+ * @example
+ * ```typescript
+ * // Rotate a point 90 degrees counterclockwise
+ * const rotationMatrix = MatrixRotation2D(Math.PI / 2);
+ * const point: TVector2 = [1, 0];
+ * const rotatedPoint = MatrixTransform2D(point, rotationMatrix);
+ * // Result: approximately [0, 1]
+ *
+ * // Chain multiple transformations
+ * const scale = MatrixScale2D(2, 2);
+ * const translate = MatrixTranslation2D(5, 3);
+ * const combined = MatrixMultiply(translate, scale);
+ * const transformedPoint = MatrixTransform2D(point, combined);
+ * ```
+ */
+export declare function MatrixTransform2D(vector: TVector2, matrix: IMatrix3): TVector2;
+/**
+ * Transforms a 3D vector using a 4x4 transformation matrix with homogeneous coordinates.
+ * Converts to homogeneous coordinates, applies transformation, then converts back to 3D.
+ *
+ * @param transform - A 4x4 transformation matrix.
+ * @param vector - The 3D vector to transform.
+ * @returns {TVector3} The transformed 3D vector.
+ *
+ * @throws {Error} If the w component is near zero (degenerate transformation).
+ *
+ * @example
+ * ```typescript
+ * const rotationMatrix = Matrix_Transformation_Rotation3D_Yaw(Math.PI / 4);
+ * const point = [1, 0, 0];
+ * const rotatedPoint = Matrix_Transformation3D(rotationMatrix, point);
+ * ```
+ */
+export declare function MatrixTransform3D(vector: TVector3, transform: IMatrix4): TVector3;
+/**
+ * Transforms a 3D direction vector using a 3x3 matrix, ignoring translation components.
+ * Designed for direction vectors (normals, velocities) where translation should not apply.
+ *
+ * @param matrix - A 3x3 transformation matrix (rotation and/or scale only).
+ * @param direction - The 3D direction vector to transform.
+ * @returns {TVector3} The transformed direction vector.
+ *
+ * @example
+ * ```typescript
+ * const rotationMatrix = Matrix_Transformation_Rotation3D_Yaw(Math.PI / 4);
+ * const normal = [0, 0, 1];
+ * const rotatedNormal = Matrix_Transformation_Direction3D(rotationMatrix, normal);
+ * ```
+ */
+export declare function MatrixDirection3D(direction: TVector3, matrix: IMatrix3): TVector3;
+/**
+ * Creates a view matrix for positioning and orienting a 3D camera.
+ * Transforms world coordinates to camera coordinates using the "look-at" approach.
+ *
+ * @param eye - Camera position in world coordinates.
+ * @param target - Point the camera is looking at.
+ * @param up - Up direction vector (usually [0, 1, 0]).
+ * @returns {IMatrix4} A 4x4 view transformation matrix.
+ *
+ * @example
+ * ```typescript
+ * const viewMatrix = Matrix_Transformation_View(
+ *   [10, 5, 10],  // Camera position
+ *   [0, 0, 0],    // Looking at origin
+ *   [0, 1, 0]     // Y-axis is up
+ * );
+ * ```
+ */
+export declare function MatrixView(eye: TVector3, target: TVector3, up: TVector3): IMatrix4;
+/**
+ * Creates a perspective projection matrix for 3D rendering.
+ * Transforms 3D view coordinates to normalized device coordinates with perspective effect.
+ *
+ * @param fovY - Vertical field of view angle in radians.
+ * @param aspect - Aspect ratio of the viewport (width/height).
+ * @param near - Distance to near clipping plane (must be positive).
+ * @param far - Distance to far clipping plane (must be > near).
+ * @returns {IMatrix4} A 4x4 perspective projection matrix.
+ *
+ * @throws {Error} If parameters are invalid.
+ *
+ * @example
+ * ```typescript
+ * const perspectiveMatrix = Matrix_Transformation_Perspective(
+ *   Math.PI / 4,  // 45-degree field of view
+ *   16 / 9,       // Widescreen aspect ratio
+ *   0.1,          // Near plane
+ *   1000          // Far plane
+ * );
+ * ```
+ */
+export declare function MatrixPerspective(fovY: number, aspect: number, near: number, far: number): IMatrix4;
+/**
+ * Creates an orthographic projection matrix for 3D rendering.
+ * Maps a rectangular box to the unit cube [-1, 1]³ without perspective distortion.
+ *
+ * @param left - Left boundary of the orthographic volume.
+ * @param right - Right boundary of the orthographic volume.
+ * @param bottom - Bottom boundary of the orthographic volume.
+ * @param top - Top boundary of the orthographic volume.
+ * @param near - Near clipping plane distance.
+ * @param far - Far clipping plane distance.
+ * @returns {IMatrix4} A 4x4 orthographic projection matrix.
+ *
+ * @throws {Error} If any opposing boundaries are equal.
+ *
+ * @example
+ * ```typescript
+ * const orthoMatrix = Matrix_Transformation_Orthographic(
+ *   -10, 10,   // Left/Right: 20 units wide
+ *   -7.5, 7.5, // Bottom/Top: 15 units tall
+ *   -100, 100  // Near/Far: 200 units deep
+ * );
+ * ```
+ */
+export declare function MatrixOrthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): IMatrix4;
+//# sourceMappingURL=transformations.d.ts.map

package/build/matrices/transformations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../src/matrices/transformations.ts"],"names":[],"mappings":"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"}