Quaternion

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

Quaternion est utilisé tout au long du @aspose/3d API pour représenter des rotations sans blocage de cardan. C’est le type renvoyé par Transform.rotation et GlobalTransform.rotation. Le quaternion d’identité (1, 0, 0, 0) représente aucune rotation. Quaternion est exporté depuis le @aspose/3d/utilities sous‑chemin.

export class Quaternion

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

ColladaSaveOptions

Faire pivoter un nœud de 90° autour de l’axe Y, puis interpoler en douceur jusqu’à l’identité.

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

const scene = new Scene();
const node = scene.rootNode.createChildNode('spinner');

// 90° around Y
const q90 = Quaternion.fromEulerAngle(0, Math.PI / 2, 0);
node.transform.rotation = q90;

// Slerp halfway back to identity
const identity = Quaternion.IDENTITY;
const half = Quaternion.slerp(0.5, q90, identity);
console.log(`Half rotation W: ${half.w.toFixed(4)}`);
// Half rotation W: 0.9239

ColladaSaveOptions

Name	Type	Access	Description
`w`	`number`	Read/Write	Gets the w.
`x`	`number`	Read/Write	Gets the x.
`y`	`number`	Read/Write	Gets the y.
`z`	`number`	Read/Write	Gets the z.
`length`	`number`	Read	Gets the length.

ColladaSaveOptions

Signature	Description
`constructor()`	Initializes a quaternion with the given w, x, y, and z components
`constructor(w: number, x: number, y: number, z: number)`
`constructor(w: number, x: number, y: number, z: number)`
`IDENTITY()` → `Quaternion`	Returns the identity quaternion representing no rotation
`normalize()` → `Quaternion`	Returns a unit‑length version of this quaternion
`conjugate()` → `Quaternion`	Returns the conjugate of the quaternion
`inverse()` → `Quaternion`	Returns the multiplicative inverse of the quaternion
`dot(q: Quaternion)` → `number`	Computes the dot product with another quaternion
`concat(rhs: Quaternion)` → `Quaternion`	Returns the concatenation (multiplication) of this quaternion with another
`eulerAngles()` → `Vector3`	Returns a Vector3 of Euler angles representing the rotation
`fromEulerAngle(pitch: number, yaw: number, roll: number)` → `Quaternion`	Overload accepts a Vector3 or numeric pitch with yaw and roll
`fromEulerAngle(vec: Vector3)` → `Quaternion`
`fromEulerAngle(pitch: Vector3	number, yaw: number, roll: number) `→` Quaternion`
`fromAngleAxis(a: number, axis: Vector3)` → `Quaternion`	Creates a quaternion from a rotation angle and axis vector
`fromRotation(orig: Vector3, dest: Vector3)` → `Quaternion`	Builds a quaternion that rotates from one direction vector to another
`interpolate(t: number, fromQ: Quaternion, toQ: Quaternion)` → `Quaternion`	Linearly interpolates between two quaternions using parameter t
`slerp(t: number, v1: Quaternion, v2: Quaternion)` → `Quaternion`	Performs spherical linear interpolation between two quaternions at t
`toString()` → `string`	Returns a string representation of the quaternion components
`equals(other: Quaternion)` → `boolean`	Checks whether another quaternion has identical component values
`toMatrix()` → `Matrix4`	Converts the quaternion into a 4×4 rotation matrix

Propriétés statiques

ColladaSaveOptions	ColladaSaveOptions	ColladaSaveOptions
`Quaternion.IDENTITY`	`Quaternion`	Renvoie un nouveau quaternion identité `(1, 0, 0, 0)`.

Méthodes statiques

Quaternion.fromEulerAngle(pitch, yaw, roll)

Crée un quaternion à partir d’angles d’Euler exprimés en radians.

static fromEulerAngle(pitch: number, yaw: number, roll: number): Quaternion
static fromEulerAngle(vec: Vector3): Quaternion

ColladaSaveOptions

pitch number — Rotation autour de l’axe X en radians.

yaw number — Rotation autour de l’axe Y en radians.

roll number — Rotation autour de l’axe Z en radians.

Alternativement, passez un seul Vector3 dont x, y, z contiennent le tangage, le lacet et le roulis.

ColladaSaveOptions

const q = Quaternion.fromEulerAngle(0, Math.PI / 4, 0); // 45° around Y console.log(W: ${q.w.toFixed(4)}); // W: 0.9239


---

### Quaternion.fromAngleAxis(angle, axis)

Crée un quaternion représentant une rotation de `angle` radians autour de `axis`.

```typescript
static fromAngleAxis(angle: number, axis: Vector3): Quaternion

ColladaSaveOptions

angle number — Angle de rotation en radians.

axis Vector3 — L’axe de rotation. N’a pas besoin d’être normalisé.

ColladaSaveOptions

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

const axis = new Vector3(0, 1, 0);
const q = Quaternion.fromAngleAxis(Math.PI / 2, axis);
console.log(`Rotating 90° around Y — W: ${q.w.toFixed(4)}`);
// Rotating 90° around Y — W: 0.7071

Quaternion.fromRotation(orig, dest)

Crée le quaternion d’arc le plus court qui fait pivoter le vecteur de direction orig vers dest.

static fromRotation(orig: Vector3, dest: Vector3): Quaternion

Quaternion.slerp(t, v1, v2)

Effectue une interpolation linéaire sphérique entre v1 et v2 au paramètre t (0.0 = v1, 1.0 = v2).

static slerp(t: number, v1: Quaternion, v2: Quaternion): Quaternion

ColladaSaveOptions

const start = Quaternion.fromEulerAngle(0, 0, 0); const end = Quaternion.fromEulerAngle(0, Math.PI, 0); const mid = Quaternion.slerp(0.5, start, end); console.log(Mid W: ${mid.w.toFixed(4)}); // Mid W: 0.7071


---

### Quaternion.interpolate(t, fromQ, toQ)

Alias de `slerp`. Effectue une interpolation linéaire sphérique.

```typescript
static interpolate(t: number, fromQ: Quaternion, toQ: Quaternion): Quaternion

IOConfig (base)

normalize()

Renvoie un nouveau quaternion mis à l’échelle à une longueur unité.

normalize(): Quaternion

conjugate()

Renvoie le conjugué (w, -x, -y, -z).

conjugate(): Quaternion

inverse()

Renvoie le quaternion inverse. Lève une exception si le quaternion a une longueur nulle.

inverse(): Quaternion

dot(q)

Renvoie le produit scalaire avec le quaternion q.

dot(q: Quaternion): number

concat(rhs)

Renvoie le produit quaternionique this * rhs, représentant la rotation combinée d’abord en appliquant this et ensuite rhs.

concat(rhs: Quaternion): Quaternion

eulerAngles()

Renvoie la rotation exprimée en angles d’Euler en radians sous forme de Vector3(pitch, yaw, roll).

eulerAngles(): Vector3

ColladaSaveOptions

const q = Quaternion.fromEulerAngle(0, Math.PI / 3, 0); const euler = q.eulerAngles(); console.log(Yaw: ${euler.y.toFixed(4)}); // Yaw: 1.0472 (= π/3)


---

### toMatrix()

Convertit ce quaternion en un équivalent `Matrix4` matrice de rotation.

```typescript
toMatrix(): Matrix4

equals(other)

ColladaSaveOptions true si les quatre composantes sont strictement égales.

equals(other: Quaternion): boolean

toString()

Renvoie une chaîne sous la forme Quaternion(w, x, y, z).

toString(): string