Euler - Verge3D User Manual - Soft8Soft
Description: Learn how to use Euler in your interactive 3D apps made with Verge3D

# Euler

A class representing Euler Angles.

Euler angles describe a rotational transformation by rotating an object on its various axes in specified amounts per axis, and a specified axis order.

Iterating through a Euler instance will yield its components (x, y, z, order) in the corresponding order.

## Code Example

`const a = new v3d.Euler(0, 1, 1.57, 'XYZ'); const b = new v3d.Vector3(1, 0, 1); b.applyEuler(a);`

## Constructor

### Euler(x : Float, y : Float, z : Float, order : String)

- x — (optional) the angle of the x axis in radians. Default is `0`.
- y — (optional) the angle of the y axis in radians. Default is `0`.
- z — (optional) the angle of the z axis in radians. Default is `0`.
- order — (optional) a string representing the order that the rotations are applied, defaults to `'XYZ'` (must be upper case).

## Properties

### # .isEuler : Boolean

Read-only flag to check if a given object is of type Euler.

### # .order : String

The order in which to apply rotations. Default is `'XYZ'`, which means that the object will first be rotated around its X axis, then its Y axis and finally its Z axis. Other possibilities are: `'YZX'`, `'ZXY'`, `'XZY'`, `'YXZ'`, and `'ZYX'`. These must be in upper case.

Verge3D uses intrinsic Tait-Bryan angles. This means that rotations are performed with respect to the local coordinate system. That is, for order `'XYZ'`, the rotation is first around the local-X axis (which is the same as the world-X axis), then around local-Y (which may now be different from the world Y-axis), then local-Z (which may be different from the world Z-axis).

### # .x : Float

The current value of the x component.

### # .y : Float

The current value of the y component.

### # .z : Float

The current value of the z component.

## Methods

### # .copy(euler : Euler) → this

Copies value of euler to this euler.

### # .clone() → Euler

Returns a new Euler with the same parameters as this one.

### # .equals(euler : Euler) → Boolean

Checks for strict equality of this euler and euler.

### # .equalsEps(euler : Euler, eps : Float) → Boolean

Checks for equality of this euler and the given euler considering the given `eps` margin.

### # .fromArray(array : Array) → this

array of length 3 or 4. The optional 4th argument corresponds to the order.

Assigns this euler's x angle to `array[0]`.
Assigns this euler's y angle to `array[1]`.
Assigns this euler's z angle to `array[2]`.
Optionally assigns this euler's order to `array[3]`.

### # .makeAlternative() → Euler

Changes this euler to an alternative set of rotations in range [-π, π) corresponding to the same orientation, e.g: from `(0, 0, π)` to `(-π, -π, 0)`.

### # .reorder(newOrder : String) → this

Resets the euler angle with a new order by creating a quaternion from this euler angle and then setting this euler angle with the quaternion and the new order.

This method discards revolution information.

### # .set(x : Float, y : Float, z : Float, order : String) → this

- x — the angle of the x axis in radians.
- y — the angle of the y axis in radians.
- z — the angle of the z axis in radians.
- order — (optional) a string representing the order that the rotations are applied.

Sets the angles of this euler transform and optionally the order.

### # .setFromRotationMatrix(m : Matrix4, order : String) → this

- m — a Matrix4 of which the upper 3x3 of matrix is a pure rotation matrix (i.e. unscaled).
- order — (optional) a string representing the order that the rotations are applied.

Sets the angles of this euler transform from a pure rotation matrix based on the orientation specified by order.

### # .setFromQuaternion(q : Quaternion, order : String) → this

- q — a normalized quaternion.
- order — (optional) a string representing the order that the rotations are applied.

Sets the angles of this euler transform from a normalized quaternion based on the orientation specified by order.

### # .setFromVector3(vector : Vector3, order : String) → this

- vector — Vector3.
- order — (optional) a string representing the order that the rotations are applied.

Set the x, y and z, and optionally update the order.

### # .toArray(array : Array, offset : Integer) → Array

- array — (optional) array to store the euler in.
- offset — (optional) offset in the array.

Returns an array of the form [x, y, z, order].

## Source

For more info on how to obtain the source code of this module see this page.