rhodonite
    Preparing search index...

    Class Matrix22

    A 2x2 matrix class for 2D transformations and linear algebra operations.

    This immutable matrix class supports common 2D transformations including rotation, scaling, and general linear transformations. The matrix data is stored in column-major order as a Float32Array for WebGL compatibility.

    Matrix layout:

    | m00 m01 |
    | m10 m11 |

    // Create identity matrix
    const identity = Matrix22.identity();

    // Create rotation matrix
    const rotation = Matrix22.rotate(Math.PI / 4);

    // Create scale matrix
    const scale = Matrix22.scale(Vector2.fromCopyArray2([2, 3]));

    Hierarchy (View Summary)

    Implements

    Index

    Constructors

    constructor

    Properties

    _v

    Accessors

    className glslStrAsFloat glslStrAsInt glslStrAsUint isIdentityMatrixClass m00 m01 m10 m11 wgslStrAsFloat wgslStrAsInt wgslStrAsUint compositionType

    Methods

    at clone determinant flattenAsArray getScale getScaleTo isDummy isEqual isStrictEqual isTheSourceSame multiplyVector multiplyVectorTo toString toStringApproximately v dummy fromCopy4ColumnMajor fromCopy4RowMajor fromCopyArray9ColumnMajor fromCopyArray9RowMajor fromCopyArrayColumnMajor fromCopyArrayRowMajor fromCopyFloat32ArrayColumnMajor fromCopyFloat32ArrayRowMajor fromCopyMatrix22 fromFloat32ArrayColumnMajor identity invert invertTo multiply multiplyTo rotate scale transpose zero

    Constructors

    Properties

    _v

    _v: Float32Array = ...

    Internal Float32Array storage for matrix elements

    Accessors

    • get glslStrAsFloat(): string

      Gets the GLSL string representation of the matrix as float values.

      Returns string

      GLSL-formatted string for float values

      Error - Must be implemented by subclasses

    • get glslStrAsInt(): string

      Gets the GLSL string representation of the matrix as integer values.

      Returns string

      GLSL-formatted string for integer values

      Error - Must be implemented by subclasses

    • get glslStrAsUint(): string

      Gets the GLSL string representation of the matrix as unsigned integer values.

      Returns string

      GLSL-formatted string for unsigned integer values with 'u' suffix

      Error - Must be implemented by subclasses

    • get isIdentityMatrixClass(): boolean

      Indicates whether this matrix is an identity matrix class.

      This property should be overridden in derived classes that represent identity matrices to return true.

      Returns boolean

      False for the base AbstractMatrix class

    • get wgslStrAsFloat(): string

      Gets the WGSL string representation of the matrix as float values.

      Returns string

      WGSL-formatted string for float values

      Error - Must be implemented by subclasses

    • get wgslStrAsInt(): string

      Gets the WGSL string representation of the matrix as integer values.

      Returns string

      WGSL-formatted string for integer values

      Error - Must be implemented by subclasses

    • get wgslStrAsUint(): string

      Gets the WGSL string representation of the matrix as unsigned integer values.

      Returns string

      WGSL-formatted string for unsigned integer values with 'u' suffix

      Error - Must be implemented by subclasses

    • get compositionType(): CompositionTypeClass<"MAT2">

      Gets the composition type for this matrix.

      Returns CompositionTypeClass<"MAT2">

      The CompositionType.Mat2 enum value

    Methods

    • Gets the matrix element at the specified row and column.

      Parameters

      • row_i: number

        The row index (0 or 1)

      • column_i: number

        The column index (0 or 1)

      Returns number

      The matrix element at the specified position

      const mat = Matrix22.identity();
      const m01 = mat.at(0, 1); // Returns 0

    • Calculates the determinant of this 2x2 matrix.

      For a 2x2 matrix | a b |, the determinant is ad - bc. | c d |

      Returns number

      The determinant value

      const mat = Matrix22.fromCopy4RowMajor(2, 3, 1, 4);
      const det = mat.determinant(); // Returns 2*4 - 3*1 = 5

    • Extracts the scale factors from this transformation matrix. Calculates the length of each column vector to determine the scale.

      Returns Vector2

      A Vector2 containing the scale factors for x and y axes

      const scaleAndRotation = Matrix22.multiply(
        Matrix22.scale(Vector2.fromCopyArray2([2, 3])),
        Matrix22.rotate(Math.PI / 4)
      );
      const scale = scaleAndRotation.getScale(); // Returns approximately [2, 3]

    • Checks if this matrix is approximately equal to another matrix within a tolerance.

      Parameters

      • mat: Matrix22

        The matrix to compare with

      • delta: number = Number.EPSILON

        The tolerance for comparison (default: Number.EPSILON)

      Returns boolean

      True if all corresponding elements are within the tolerance

    • Checks if this matrix is exactly equal to another matrix. Uses strict equality comparison for all elements.

      Parameters

      • mat: Matrix22

        The matrix to compare with

      Returns boolean

      True if all corresponding elements are exactly equal

    • Checks if the matrix's internal storage shares the same ArrayBuffer as the provided one.

      This method is useful for determining if two matrices share the same underlying memory, which can be important for performance optimizations and avoiding unnecessary data copying.

      Parameters

      • arrayBuffer: ArrayBuffer

        The ArrayBuffer to compare against

      Returns boolean

      True if the internal storage uses the same ArrayBuffer, false otherwise

    • Multiplies this matrix by a 2D vector and returns the result.

      Parameters

      • vec: Vector2

        The 2D vector to multiply

      Returns Vector2

      A new Vector2 containing the transformed vector

      const rotation = Matrix22.rotate(Math.PI / 2);
      const vec = Vector2.fromCopyArray2([1, 0]);
      const result = rotation.multiplyVector(vec); // Rotates (1,0) to (0,1)

    • Gets the matrix element at the specified flat index.

      This provides direct access to the underlying Float32Array storage using a single index rather than row/column coordinates.

      Parameters

      • i: number

        The zero-based flat index into the matrix storage

      Returns number

      The matrix element value at the specified index

    • Creates a new Matrix22 from individual components in column-major order.

      Column-major means you specify values column by column: First column: m00, m10 Second column: m01, m11

      Note: WebGL matrices are stored in column-major order internally.

      Parameters

      • m00: number

        Element at row 0, column 0

      • m10: number

        Element at row 1, column 0

      • m01: number

        Element at row 0, column 1

      • m11: number

        Element at row 1, column 1

      Returns Matrix22

      A new Matrix22 with the specified values

    • Creates a new Matrix22 from individual components in row-major order.

      Row-major means you specify values as they appear visually:

      | m00 m01 |
      | m10 m11 |

      Note: Internally, WebGL matrices are stored in column-major order.

      Parameters

      • m00: number

        Element at row 0, column 0

      • m01: number

        Element at row 0, column 1

      • m10: number

        Element at row 1, column 0

      • m11: number

        Element at row 1, column 1

      Returns Matrix22

      A new Matrix22 with the specified values

      const mat = Matrix22.fromCopy4RowMajor(1, 2, 3, 4);
      // Creates:
      // | 1 2 |
      // | 3 4 |

    • Creates a new Matrix22 from a 4-element array in column-major order.

      Parameters

      • array: Array4<number>

        Array4 containing exactly 4 numbers in column-major order

      Returns Matrix22

      A new Matrix22 with the array values

    • Creates a new Matrix22 from a 4-element array in row-major order.

      Parameters

      • array: Array4<number>

        Array4 containing exactly 4 numbers in row-major order

      Returns Matrix22

      A new Matrix22 with values converted to column-major order

    • Creates a new Matrix22 from a variable-length array in column-major order. Only the first 4 elements are used.

      Parameters

      • array: number[]

        Array containing matrix values in column-major order

      Returns Matrix22

      A new Matrix22 with the first 4 array values

    • Creates a new Matrix22 from a variable-length array in row-major order. Only the first 4 elements are used.

      Parameters

      • array: number[]

        Array containing matrix values in row-major order

      Returns Matrix22

      A new Matrix22 with values converted to column-major order

    • Creates a new Matrix22 by copying values from a Float32Array in column-major order.

      Parameters

      • float32Array: Float32Array

        Float32Array containing matrix values in column-major order

      Returns Matrix22

      A new Matrix22 with copied values

    • Creates a new Matrix22 by copying values from a Float32Array in row-major order.

      Parameters

      • array: Float32Array

        Float32Array containing matrix values in row-major order

      Returns Matrix22

      A new Matrix22 with values converted to column-major order

    • Creates a new Matrix22 that directly uses the provided Float32Array. The array is used as-is without copying, so modifications to the array will affect the matrix.

      Parameters

      • float32Array: Float32Array

        Float32Array containing matrix values in column-major order

      Returns Matrix22

      A new Matrix22 using the provided array

    • Creates the inverse of the given matrix.

      For a 2x2 matrix, the inverse is calculated using the formula: A^(-1) = (1/det(A)) * | d -b | |-c a | where A = | a b | and det(A) = ad - bc | c d |

      Parameters

      Returns Matrix22

      A new Matrix22 that is the inverse of the input matrix

      Error if the matrix is singular (determinant is 0)

      const mat = Matrix22.fromCopy4RowMajor(2, 0, 0, 2);
      const inverse = Matrix22.invert(mat);
      // Returns:
      // | 0.5   0 |
      // |   0 0.5 |

    • Multiplies two 2x2 matrices and returns the result. Matrix multiplication is not commutative: A * B ≠ B * A in general.

      Parameters

      Returns Matrix22

      A new Matrix22 containing the product l_mat * r_mat

      const a = Matrix22.scale(Vector2.fromCopyArray2([2, 2]));
      const b = Matrix22.rotate(Math.PI / 4);
      const result = Matrix22.multiply(a, b); // Scale then rotate

    • Multiplies two matrices and stores the result in the output matrix. This method avoids creating a new matrix instance for better performance.

      Note: The parameter types suggest Matrix33, but this appears to be a bug as this should operate on Matrix22 instances.

      Parameters

      Returns MutableMatrix22

      The output matrix containing the product

    • Creates a 2D rotation matrix for the given angle.

      The rotation matrix is: | cos(θ) -sin(θ) | | sin(θ) cos(θ) |

      Parameters

      • radian: number

        The rotation angle in radians (positive values rotate counter-clockwise)

      Returns Matrix22

      A new Matrix22 representing the rotation transformation

      // 90-degree counter-clockwise rotation
      const rotation = Matrix22.rotate(Math.PI / 2);

    • Creates a 2D scaling matrix from a 2D vector.

      The scaling matrix is: | sx 0 | | 0 sy |

      Parameters

      • vec: IVector2

        A Vector2 containing the scale factors for x and y axes

      Returns Matrix22

      A new Matrix22 representing the scaling transformation

      const scale = Matrix22.scale(Vector2.fromCopyArray2([2, 3]));
      // Creates a matrix that scales x by 2 and y by 3

    • Creates the transpose of the given matrix. The transpose swaps rows and columns: (i,j) becomes (j,i).

      Parameters

      Returns Matrix22

      A new Matrix22 that is the transpose of the input matrix

      const mat = Matrix22.fromCopy4RowMajor(1, 2, 3, 4);
      const transposed = Matrix22.transpose(mat);
      // Original:    Transposed:
      // | 1 2 |  ->  | 1 3 |
      // | 3 4 |      | 2 4 |

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Accessors
    Methods