Class Matrix4

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

Matrix4 stocke une matrice de transformation 4×4 sous forme d’un tableau plat de 16 nombres en ordre row-major. C’est le type de Transform.transformMatrix et GlobalTransform.transformMatrix. m00–m33 propriétés, ou par indice via getItem(i) / setItem(i, v). Matrix4 est exporté depuis le @aspose/3d/utilities sous‑chemin.

export class Matrix4

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

Examples

Construisez une matrice TRS combinée et décomposez‑la à nouveau en composants.

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

Propriétés statiques

Examples

Les 16 éléments de la matrice sont accessibles en tant que propriétés nommées individuelles m00, m01, m02, m03, m10, …, m33, où le premier chiffre représente la ligne et le second la colonne. Toutes sont lisibles et modifiables.

Méthodes statiques

Matrix4.translate(v)

Crée une matrice de translation pure à partir d’un Vector3, ou à partir d’individuels (tx, ty, tz) nombres.

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)

Crée une matrice d’échelle pure à partir d’un Vector3, ou à partir d’un individu (sx, sy, sz) nombres.

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

Matrix4.rotate(q)

Crée une matrice de rotation à partir d’un Quaternion, ou à partir d’un angle (en radians) et d’un axe 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)

Crée une matrice de rotation à partir d’angles d’Euler en radians.

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

Méthodes d’instance

concatenate(m2)

Renvoie le produit matriciel this × m2. Utilisez ceci pour combiner les transformations (appliquer this d’abord, puis 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()

Renvoie l’inverse de cette matrice. Lève une exception si la matrice est singulière (déterminant proche de zéro).

inverse(): Matrix4

transpose()

Renvoie la transposée de cette matrice (les lignes deviennent des colonnes).

transpose(): Matrix4

normalize()

Renvoie une nouvelle matrice dont la sous-matrice de rotation (3×3 en haut à gauche) est orthonormalisée en divisant chaque ligne par sa longueur. La colonne de translation est conservée.

normalize(): Matrix4

decompose(translation, scaling, rotation)

Décompose cette matrice en composants de translation, d’échelle et de rotation. Les résultats sont écrits dans le premier élément de chaque tableau de sortie.

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

Examples

translation any[] — Tableau de sortie. Après l’appel, translation[0] est un objet {x, y, z} avec la traduction.

scaling any[] — Tableau de sortie. Après l’appel, scaling[0] est un objet {x, y, z} avec les facteurs d’échelle.

rotation any[] — Tableau de sortie. Après l’appel, rotation[0] est un objet {w, x, y, z} avec les composantes du quaternion de rotation.

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)

Définit cette matrice comme le produit d’une translation, d’une rotation et d’une mise à l’échelle. Les entrées peuvent être des objets simples avec x, y, z (et w pour la rotation) champs.

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

toArray()

Renvoie une copie du tableau interne de 16 éléments en ordre ligne-major.

toArray(): number[]

getItem(index) / setItem(index, value)

Accès aux éléments par indice linéaire (0–15, ordre ligne-major).

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

equals(other)

Examples true si tous les 16 éléments sont strictement égaux.

equals(other: Matrix4): boolean