Class Matrix4

Paquete: @aspose/3d (v24.12.0)

Matrix4 almacena una matriz de transformación 4×4 como una matriz plana de 16 números en orden por filas. Es el tipo de Transform.transformMatrix y GlobalTransform.transformMatrix. Los elementos individuales son accesibles como m00–m33 propiedades, o por índice mediante getItem(i) / setItem(i, v). Matrix4 se exporta desde el @aspose/3d/utilities subruta.

export class Matrix4

import { Matrix4 } from '@aspose/3d/utilities';

Examples

Construye una matriz TRS combinada y descomponla nuevamente en sus componentes.

import { Matrix4, Vector3, Quaternion } from '@aspose/3d/utilities';

const t = Matrix4.translate(new Vector3(5, 0, 0));
const r = Matrix4.rotate(Quaternion.fromEulerAngle(0, Math.PI / 4, 0));
const s = Matrix4.scale(new Vector3(2, 2, 2));

const trs = t.concatenate(r).concatenate(s);

const translation: any[] = [null];
const scaling: any[] = [null];
const rotation: any[] = [null];
trs.decompose(translation, scaling, rotation);

console.log(`Translation X: ${translation[0].x}`); // Translation X: 5
console.log(`Scale X: ${scaling[0].x.toFixed(4)}`); // Scale X: 2.0000

Examples

Propiedades estáticas

Examples

Los 16 elementos de la matriz son accesibles como propiedades nombradas individuales. m00, m01, m02, m03, m10, …, m33, donde el primer dígito es la fila y el segundo es la columna. Todas son legibles y escribibles.

Métodos estáticos

Matrix4.translate(v)

Crea una matriz de traslación pura a partir de un Vector3, o a partir de individual (tx, ty, tz) números.

static translate(v: Vector3): Matrix4
static translate(tx: number, ty?: number, tz?: number): Matrix4

Examples

import { Matrix4, Vector3 } from '@aspose/3d/utilities';

const m = Matrix4.translate(new Vector3(3, 0, 0));
console.log(`m03: ${m.m03}`); // m03: 3

Matrix4.scale(v)

Crea una matriz de escalado puro a partir de un Vector3, o de individual (sx, sy, sz) números.

static scale(v: Vector3): Matrix4
static scale(sx: number, sy?: number, sz?: number): Matrix4

Matrix4.rotate(q)

Crea una matriz de rotación a partir de una Quaternion, o a partir de un ángulo (en radianes) y un eje Vector3.

static rotate(q: Quaternion): Matrix4
static rotate(angle: number, axis: Vector3): Matrix4

Examples

import { Matrix4, Quaternion } from '@aspose/3d/utilities';

const q = Quaternion.fromEulerAngle(0, Math.PI / 2, 0);
const m = Matrix4.rotate(q);
console.log(`Rotation matrix m00: ${m.m00.toFixed(4)}`);
// Rotation matrix m00: 0.0000

Matrix4.rotateFromEuler(rx, ry, rz)

Crea una matriz de rotación a partir de ángulos de Euler en radianes.

static rotateFromEuler(rx: number, ry?: number, rz?: number): Matrix4
static rotateFromEuler(v: Vector3): Matrix4

Métodos de instancia

concatenate(m2)

Devuelve el producto de matrices this × m2. Utiliza esto para combinar transformaciones (aplicar this primero, luego m2).

concatenate(m2: Matrix4): Matrix4

Examples

import { Matrix4, Vector3 } from '@aspose/3d/utilities';

const translate = Matrix4.translate(new Vector3(1, 0, 0));
const scale = Matrix4.scale(new Vector3(2, 2, 2));
const combined = translate.concatenate(scale);
console.log(`m03: ${combined.m03}`); // m03: 1

inverse()

Devuelve la inversa de esta matriz. Lanza una excepción si la matriz es singular (determinante cercano a cero).

inverse(): Matrix4

transpose()

Devuelve la transpuesta de esta matriz (las filas se convierten en columnas).

transpose(): Matrix4

normalize()

Devuelve una nueva matriz con la submatriz de rotación (3×3 superior izquierda) ortonormalizada dividiendo cada fila por su longitud. La columna de traslación se conserva.

normalize(): Matrix4

decompose(translation, scaling, rotation)

Descompone esta matriz en componentes de traslación, escala y rotación. Los resultados se escriben en el primer elemento de cada arreglo de salida.

decompose(translation: any[], scaling: any[], rotation: any[]): void

Examples

translation any[] — Matriz de salida. Después de la llamada, translation[0] es un objeto {x, y, z} con la traducción.

scaling any[] — Matriz de salida. Después de la llamada, scaling[0] es un objeto {x, y, z} con los factores de escala.

rotation any[] — Matriz de salida. Después de la llamada, rotation[0] es un objeto {w, x, y, z} con los componentes del cuaternión de rotación.

Examples

import { Matrix4, Vector3, Quaternion } from '@aspose/3d/utilities';

const m = Matrix4.translate(new Vector3(0, 5, 0));
const trans: any[] = [null], scale: any[] = [null], rot: any[] = [null];
m.decompose(trans, scale, rot);
console.log(`Y: ${trans[0].y}`); // Y: 5

setTRS(translation, rotation, scale)

Establece esta matriz al producto de una traslación, rotación y escala. Las entradas pueden ser objetos simples con x, y, z (y w para rotación) campos.

setTRS(translation: any, rotation: any, scale: any): void

toArray()

Devuelve una copia del array interno de 16 elementos en orden fila mayor.

toArray(): number[]

getItem(index) / setItem(index, value)

Acceso a elementos mediante índice lineal (0–15, orden fila mayor).

getItem(key: number): number
setItem(key: number, value: number): void

equals(other)

Examples true si todos los 16 elementos son estrictamente iguales.

equals(other: Matrix4): boolean