Class Quaternion

Class used to store quaternion data Example Playground - Overview - https://playground.babylonjs.com/#L49EJ7#100

See

Implements

Tensor<Tuple<number, 4>, Quaternion>

Index

Constructors

constructor

new Quaternion(x?: number, y?: number, z?: number, w?: number): Quaternion
Creates a new Quaternion from the given floats
Parameters
- x: number = 0.0
  defines the first component (0 by default)
- y: number = 0.0
  defines the second component (0 by default)
- z: number = 0.0
  defines the third component (0 by default)
- w: number = 1.0
  defines the fourth component (1.0 by default)
Returns Quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4565

Properties

`Readonly`dimension

dimension: readonly [4]

See

Tensor.dimension

`Readonly`rank

rank: 1

See

Tensor.rank

`Static`_V8PerformanceHack

_V8PerformanceHack: DeepImmutableObject<Quaternion> = ...

If the first quaternion is flagged with integers (as everything is 0,0,0,0), V8 stores all of the properties as integers internally because it doesn't know any better yet. If subsequent quaternion are created with non-integer values, V8 determines that it would be best to represent these properties as doubles instead of integers, and henceforth it will use floating-point representation for all quaternion instances that it creates. But the original quaternion instances are unchanged and has a "deprecated map". If we keep using the quaternion instances from step 1, it will now be a poison pill which will mess up optimizations in any code it touches.

Accessors

w

get w(): number
Gets or sets the w coordinate

Returns number
Implementation of IQuaternionLike.w
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4539
set w(value: number): void
Parameters
- value: number
Returns void
Implementation of IQuaternionLike.w
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4543

x

get x(): number
Gets or sets the x coordinate

Returns number
Implementation of IQuaternionLike.x
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4509
set x(value: number): void
Parameters
- value: number
Returns void
Implementation of IQuaternionLike.x
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4513

y

get y(): number
Gets or sets the y coordinate

Returns number
Implementation of IQuaternionLike.y
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4519
set y(value: number): void
Parameters
- value: number
Returns void
Implementation of IQuaternionLike.y
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4523

z

get z(): number
Gets or sets the z coordinate

Returns number
Implementation of IQuaternionLike.z
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4529
set z(value: number): void
Parameters
- value: number
Returns void
Implementation of IQuaternionLike.z
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4533

Methods

add

add(other: DeepImmutable<Quaternion>): Quaternion
Adds two quaternions Example Playground https://playground.babylonjs.com/#L49EJ7#10
Parameters
- other: DeepImmutable<Quaternion>
  defines the second operand
Returns Quaternion
a new quaternion as the addition result of the given one and the current quaternion
Implementation of Tensor.add
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4750

addInPlace

addInPlace(other: DeepImmutable<Quaternion>): this
Add a quaternion to the current one Example Playground https://playground.babylonjs.com/#L49EJ7#11
Parameters
- other: DeepImmutable<Quaternion>
  defines the quaternion to add
Returns this
the current quaternion
Implementation of Tensor.addInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4760

addInPlaceFromFloats

addInPlaceFromFloats(x: number, y: number, z: number, w: number): this
Adds in place the given floats to the current quaternion
Parameters
- x: number
  defines the x coordinate
- y: number
  defines the y coordinate
- z: number
  defines the z coordinate
- w: number
  defines the w coordinate
Returns this
the current updated quaternion
Implementation of Tensor.addInPlaceFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4786

addToRef

addToRef<T extends Quaternion>(other: DeepImmutable<this>, result: T): T
Sets the "result" coordinates with the addition of the current instance and the given one coordinates
Type Parameters
- T extends Quaternion
Parameters
- other: DeepImmutable<this>
  defines the other instance
- result: T
  defines the target instance
Returns T
result input
Implementation of Tensor.addToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4769

asArray

asArray(): [number, number, number, number]
Copy the quaternion to an array Example Playground https://playground.babylonjs.com/#L49EJ7#13

Returns [number, number, number, number]
a new array populated with 4 elements from the quaternion coordinates
Implementation of Tensor.asArray
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4610

clone

clone(): Quaternion
Clone the current quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#12

Returns Quaternion
a new quaternion copied from the current one
Implementation of Tensor.clone
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4685

conjugate

conjugate(): Quaternion
Conjugates (1-q) the current quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#83

Returns Quaternion
a new quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5123

conjugateInPlace

conjugateInPlace(): this
Conjugates in place the current quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#82

Returns this
the current updated quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5110

conjugateToRef

conjugateToRef<T extends Quaternion>(ref: T): T
Conjugates the current quaternion and stores the result in the given quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#81
Type Parameters
- T extends Quaternion
Parameters
- ref: T
  defines the target quaternion
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5100

copyFrom

copyFrom(other: DeepImmutable<Quaternion>): this
Copy a quaternion to the current one Example Playground https://playground.babylonjs.com/#L49EJ7#86
Parameters
- other: DeepImmutable<Quaternion>
  defines the other quaternion
Returns this
the updated current quaternion
Implementation of Tensor.copyFrom
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4695

copyFromFloats

copyFromFloats(x: number, y: number, z: number, w: number): this
Updates the current quaternion with the given float coordinates Example Playground https://playground.babylonjs.com/#L49EJ7#87
Parameters
- x: number
  defines the x coordinate
- y: number
  defines the y coordinate
- z: number
  defines the z coordinate
- w: number
  defines the w coordinate
Returns this
the updated current quaternion
Implementation of Tensor.copyFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4713

dot

dot(other: DeepImmutable<this>): number
Returns the dot product (float) between the current quaternions and "other"
Parameters
- other: DeepImmutable<this>
  defines the right operand
Returns number
the dot product
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5335

equals

equals(otherQuaternion: DeepImmutable<Quaternion>): boolean
Check if two quaternions are equals Example Playground https://playground.babylonjs.com/#L49EJ7#38
Parameters
- otherQuaternion: DeepImmutable<Quaternion>
  defines the second operand
Returns boolean
true if the current quaternion and the given one coordinates are strictly equals
Implementation of Tensor.equals
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4639

equalsToFloats

equalsToFloats(x: number, y: number, z: number, w: number): boolean
Determines if the current quaternion equals the given floats
Parameters
- x: number
  defines the x coordinate
- y: number
  defines the y coordinate
- z: number
  defines the z coordinate
- w: number
  defines the w coordinate
Returns boolean
true if the quaternion coordinates match the given floats
Implementation of Tensor.equalsToFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5058

equalsWithEpsilon

equalsWithEpsilon(
otherQuaternion: DeepImmutable<Quaternion>,
epsilon?: number,
): boolean
Gets a boolean if two quaternions are equals (using an epsilon value) Example Playground https://playground.babylonjs.com/#L49EJ7#37
Parameters
- otherQuaternion: DeepImmutable<Quaternion>
  defines the other quaternion
- epsilon: number = Epsilon
  defines the minimal distance to consider equality
Returns boolean
true if the given quaternion coordinates are close to the current ones by a distance of epsilon.
Implementation of Tensor.equalsWithEpsilon
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4650

fromArray

fromArray(array: FloatArray, index?: number): this
Update the current instance from an array
Parameters
- array: FloatArray
  defines the destination array
- index: number = 0
  defines the offset in the destination array
Returns this
the current instance
Implementation of Tensor.fromArray
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4629

fromRotationMatrix

fromRotationMatrix(matrix: DeepImmutable<Matrix>): this
Updates the current quaternion from the given rotation matrix values Example Playground https://playground.babylonjs.com/#L49EJ7#41
Parameters
- matrix: DeepImmutable<Matrix>
  defines the source matrix
Returns this
the current updated quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5325

getClassName

getClassName(): string
Gets the class name of the quaternion

Returns string
the string "Quaternion"
Implementation of Tensor.getClassName
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4584

getHashCode

getHashCode(): number
Gets a hash code for this quaternion

Returns number
the quaternion hash code
Implementation of Tensor.getHashCode
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4592

invert

invert(): Quaternion
Returns the inverse of the current quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#84

Returns Quaternion
a new quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5132

invertInPlace

invertInPlace(): this
Invert in place the current quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#85

Returns this
this quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5147

isApprox

isApprox(otherQuaternion: DeepImmutable<Quaternion>, epsilon?: number): boolean
Gets a boolean if two quaternions are equals (using an epsilon value), taking care of double cover : https://www.reedbeta.com/blog/why-quaternions-double-cover/
Parameters
- otherQuaternion: DeepImmutable<Quaternion>
  defines the other quaternion
- epsilon: number = Epsilon
  defines the minimal distance to consider equality
Returns boolean
true if the given quaternion coordinates are close to the current ones by a distance of epsilon.
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4666

length

length(): number
Gets length of current quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#28

Returns number
the quaternion length (float)
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5171

lengthSquared

lengthSquared(): number
Gets squared length of current quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#29

Returns number
the quaternion length (float)
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5162

multiply

multiply(q1: DeepImmutable<Quaternion>): Quaternion
Multiplies two quaternions Example Playground https://playground.babylonjs.com/#L49EJ7#43
Parameters
- q1: DeepImmutable<Quaternion>
  defines the second operand
Returns Quaternion
a new quaternion set as the multiplication result of the current one with the given one "q1"
Implementation of Tensor.multiply
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4923

multiplyByFloats

multiplyByFloats(x: number, y: number, z: number, w: number): this
Multiplies the current quaternion coordinates by the given floats
Parameters
- x: number
  defines the x coordinate
- y: number
  defines the y coordinate
- z: number
  defines the z coordinate
- w: number
  defines the w coordinate
Returns this
the current updated quaternion
Implementation of Tensor.multiplyByFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4963

multiplyInPlace

multiplyInPlace(other: DeepImmutable<Quaternion>): this
Updates the current quaternion with the multiplication of itself with the given one "q1" Example Playground https://playground.babylonjs.com/#L49EJ7#46
Parameters
- other: DeepImmutable<Quaternion>
  defines the second operand
Returns this
the currentupdated quaternion
Implementation of Tensor.multiplyInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4951

multiplyToRef

multiplyToRef<T extends Quaternion>(q1: DeepImmutable<Quaternion>, result: T): T
Sets the given "result" as the multiplication result of the current one with the given one "q1" Example Playground https://playground.babylonjs.com/#L49EJ7#45
Type Parameters
- T extends Quaternion
Parameters
- q1: DeepImmutable<Quaternion>
  defines the second operand
- result: T
  defines the target quaternion
Returns T
the current quaternion
Implementation of Tensor.multiplyToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4936

negate

negate(): Quaternion
Gets a new instance with current instance negated coordinates

Returns Quaternion
a new instance
Implementation of Tensor.negate
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5028

negateInPlace

negateInPlace(): this
Negate this instance in place

Returns this
this
Implementation of Tensor.negateInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5032

negateToRef

negateToRef<T extends Quaternion>(result: T): T
Negate the current instance and stores the result in the given instance "result" coordinates
Type Parameters
- T extends Quaternion
Parameters
- result: T
  defines the instance object where to store the result
Returns T
the result
Implementation of Tensor.negateToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5041

normalize

normalize(): this
Normalize in place the current quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#54

Returns this
the current updated quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5180

normalizeFromLength

normalizeFromLength(len: number): this
Normalize the current quaternion with the given input length. Please note that this is an in place operation.
Parameters
- len: number
  the length of the quaternion
Returns this
the current updated Quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5190

normalizeToNew

normalizeToNew(): Quaternion
Normalize a copy of the current quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#55

Returns Quaternion
the normalized quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5203

normalizeToRef

normalizeToRef<T extends Quaternion>(reference: T): T
Normalize the current Quaternion to the reference
Type Parameters
- T extends Quaternion
Parameters
- reference: T
  define the Quaternion to update
Returns T
the updated Quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5214

scale

scale(value: number): Quaternion
Multiplies the current quaternion by a scale factor Example Playground https://playground.babylonjs.com/#L49EJ7#88
Parameters
- value: number
  defines the scale factor
Returns Quaternion
a new quaternion set by multiplying the current quaternion coordinates by the float "scale"
Implementation of Tensor.scale
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4865

scaleAndAddToRef

scaleAndAddToRef<T extends Quaternion>(scale: number, result: T): T
Scale the current quaternion values by a factor and add the result to a given quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#91
Type Parameters
- T extends Quaternion
Parameters
- scale: number
  defines the scale factor
- result: T
  defines the Quaternion object where to store the result
Returns T
result input
Implementation of Tensor.scaleAndAddToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4908

scaleInPlace

scaleInPlace(value: number): this
Multiplies in place the current quaternion by a scale factor Example Playground https://playground.babylonjs.com/#L49EJ7#90
Parameters
- value: number
  defines the scale factor
Returns this
the current modified quaternion
Implementation of Tensor.scaleInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4891

scaleToRef

scaleToRef<T extends Quaternion>(scale: number, result: T): T
Scale the current quaternion values by a factor and stores the result to a given quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#89
Type Parameters
- T extends Quaternion
Parameters
- scale: number
  defines the scale factor
- result: T
  defines the Quaternion object where to store the result
Returns T
result input
Implementation of Tensor.scaleToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4876

set

set(x: number, y: number, z: number, w: number): this
Updates the current quaternion from the given float coordinates Example Playground https://playground.babylonjs.com/#L49EJ7#56
Parameters
- x: number
  defines the x coordinate
- y: number
  defines the y coordinate
- z: number
  defines the z coordinate
- w: number
  defines the w coordinate
Returns this
the updated current quaternion
Implementation of Tensor.set
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4731

setAll

setAll(value: number): this
Sets all the quaternion coordinates to the given value
Parameters
- value: number
  the value to set
Returns this
the current updated quaternion
Implementation of Tensor.setAll
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4740

subtract

subtract(other: DeepImmutable<this>): Quaternion
Subtract two quaternions Example Playground https://playground.babylonjs.com/#L49EJ7#57
Parameters
- other: DeepImmutable<this>
  defines the second operand
Returns Quaternion
a new quaternion as the subtraction result of the given one from the current one
Implementation of Tensor.subtract
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4840

subtractFromFloats

subtractFromFloats(x: number, y: number, z: number, w: number): Quaternion
Subtracts the given floats from the current quaternion
Parameters
- x: number
  defines the x coordinate
- y: number
  defines the y coordinate
- z: number
  defines the z coordinate
- w: number
  defines the w coordinate
Returns Quaternion
a new quaternion as the subtraction result
Implementation of Tensor.subtractFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4812

subtractFromFloatsToRef

subtractFromFloatsToRef<T extends Quaternion>(
    x: number,
    y: number,
    z: number,
    w: number,
    result: T,
): T
Subtracts the given floats from the current quaternion and stores the result in the given one
Type Parameters
- T extends Quaternion
Parameters
- x: number
  defines the x coordinate
- y: number
  defines the y coordinate
- z: number
  defines the z coordinate
- w: number
  defines the w coordinate
- result: T
  defines the quaternion to store the result
Returns T
result input
Implementation of Tensor.subtractFromFloatsToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4825

subtractInPlace

subtractInPlace(other: DeepImmutable<Quaternion>): this
Subtract a quaternion to the current one Example Playground https://playground.babylonjs.com/#L49EJ7#58
Parameters
- other: DeepImmutable<Quaternion>
  defines the quaternion to subtract
Returns this
the current quaternion
Implementation of Tensor.subtractInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4850

subtractToRef

subtractToRef<T extends Quaternion>(other: DeepImmutable<this>, result: T): T
Sets the "result" coordinates with the subtraction of the other's coordinates from the current coordinates.
Type Parameters
- T extends Quaternion
Parameters
- other: DeepImmutable<this>
  defines the other instance
- result: T
  defines the target instance
Returns T
result input
Implementation of Tensor.subtractToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4795

toAlphaBetaGammaToRef

toAlphaBetaGammaToRef<T extends Vector3>(result: T): T
Sets the given vector3 "result" with the Alpha, Beta, Gamma Euler angles translated from the current quaternion
Type Parameters
- T extends Vector3
Parameters
- result: T
  defines the vector which will be filled with the Euler angles
Returns T
result input

See
https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms/center_origin/rotation_conventions
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5281

toArray

toArray(array: FloatArray, index?: number): this
Stores from the starting index in the given array the Quaternion successive values Example Playground https://playground.babylonjs.com/#L49EJ7#59
Parameters
- array: FloatArray
  defines the array where to store the x,y,z,w components
- index: number = 0
  defines an optional index in the target array to define where to start storing values
Returns this
the current Quaternion object
Implementation of Tensor.toArray
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4621

toAxisAngle

toAxisAngle(): { angle: number; axis: Vector3 }
Converts the current quaternion to an axis angle representation

Returns { angle: number; axis: Vector3 }
the axis and angle in radians
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5343

toAxisAngleToRef

toAxisAngleToRef<T extends Vector3>(axis: T): number
Converts the current quaternion to an axis angle representation
Type Parameters
- T extends Vector3
Parameters
- axis: T
  defines the target axis vector
Returns number
the angle in radians
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5354

toEulerAngles

toEulerAngles(): Vector3
Returns a new Vector3 set with the Euler angles translated from the current quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#32

Returns Vector3
a new Vector3 containing the Euler angles

See
https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms/center_origin/rotation_conventions
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5229

toEulerAnglesToRef

toEulerAnglesToRef<T extends Vector3>(result: T): T
Sets the given vector3 "result" with the Euler angles translated from the current quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#31
Type Parameters
- T extends Vector3
Parameters
- result: T
  defines the vector which will be filled with the Euler angles
Returns T
result input

See
https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms/center_origin/rotation_conventions
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5242

toRotationMatrix

toRotationMatrix<T extends Matrix>(result: T): T
Updates the given rotation matrix with the current quaternion values Example Playground https://playground.babylonjs.com/#L49EJ7#67
Type Parameters
- T extends Matrix
Parameters
- result: T
  defines the target matrix
Returns T
the updated matrix with the rotation
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5314

toString

toString(): string
Gets a string representation for the current quaternion

Returns string
a string with the Quaternion coordinates
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4576

`Static`AreClose

AreClose(
    quat0: DeepImmutable<Quaternion>,
    quat1: DeepImmutable<Quaternion>,
    epsilon?: number,
): boolean
Checks if the orientations of two rotation quaternions are close to each other Example Playground https://playground.babylonjs.com/#L49EJ7#60
Parameters
- quat0: DeepImmutable<Quaternion>
  defines the first quaternion to check
- quat1: DeepImmutable<Quaternion>
  defines the second quaternion to check
- epsilon: number = 0.1
  defines closeness, 0 same orientation, 1 PI apart, default 0.1
Returns boolean
true if the two quaternions are close to each other within epsilon
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5460

`Static`Center

Center(
value1: DeepImmutable<Quaternion>,
value2: DeepImmutable<Quaternion>,
): Quaternion
Returns a new Quaternion located at the center between the quaternions "value1" and "value2".
Parameters
- value1: DeepImmutable<Quaternion>
  value to calulate the center between
- value2: DeepImmutable<Quaternion>
  value to calulate the center between
Returns Quaternion
the center between the two quaternions
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6113

`Static`CenterToRef

CenterToRef<T extends Quaternion>(
    value1: DeepImmutable<Quaternion>,
    value2: DeepImmutable<Quaternion>,
    ref: T,
): T
Gets the center of the quaternions "value1" and "value2" and stores the result in the quaternion "ref"
Type Parameters
- T extends Quaternion
Parameters
- value1: DeepImmutable<Quaternion>
  defines first quaternion
- value2: DeepImmutable<Quaternion>
  defines second quaternion
- ref: T
  defines third quaternion
Returns T
ref
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6124

`Static`Clamp

Clamp(
    value: DeepImmutable<Quaternion>,
    min: DeepImmutable<Quaternion>,
    max: DeepImmutable<Quaternion>,
): Quaternion
Returns a new Quaternion set with the coordinates of "value", if the quaternion "value" is in the cube defined by the quaternions "min" and "max" If a coordinate value of "value" is lower than one of the "min" coordinate, then this "value" coordinate is set with the "min" one If a coordinate value of "value" is greater than one of the "max" coordinate, then this "value" coordinate is set with the "max" one
Parameters
- value: DeepImmutable<Quaternion>
  defines the current value
- min: DeepImmutable<Quaternion>
  defines the lower range value
- max: DeepImmutable<Quaternion>
  defines the upper range value
Returns Quaternion
the new Quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6026

`Static`ClampToRef

ClampToRef<T extends Quaternion>(
    value: DeepImmutable<Quaternion>,
    min: DeepImmutable<Quaternion>,
    max: DeepImmutable<Quaternion>,
    result: T,
): T
Sets the given quaternion "result" with the coordinates of "value", if the quaternion "value" is in the cube defined by the quaternions "min" and "max" If a coordinate value of "value" is lower than one of the "min" coordinate, then this "value" coordinate is set with the "min" one If a coordinate value of "value" is greater than one of the "max" coordinate, then this "value" coordinate is set with the "max" one
Type Parameters
- T extends Quaternion
Parameters
- value: DeepImmutable<Quaternion>
  defines the current value
- min: DeepImmutable<Quaternion>
  defines the lower range value
- max: DeepImmutable<Quaternion>
  defines the upper range value
- result: T
  defines the Quaternion where to store the result
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6042

`Static`Distance

Distance(
value1: DeepImmutable<Quaternion>,
value2: DeepImmutable<Quaternion>,
): number
Returns the distance (float) between the quaternions "value1" and "value2".
Parameters
- value1: DeepImmutable<Quaternion>
  value to calulate the distance between
- value2: DeepImmutable<Quaternion>
  value to calulate the distance between
Returns number
the distance between the two quaternions
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6089

`Static`DistanceSquared

DistanceSquared(
value1: DeepImmutable<Quaternion>,
value2: DeepImmutable<Quaternion>,
): number
Returns the squared distance (float) between the quaternions "value1" and "value2".
Parameters
- value1: DeepImmutable<Quaternion>
  value to calulate the distance between
- value2: DeepImmutable<Quaternion>
  value to calulate the distance between
Returns number
the distance between the two quaternions squared
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6098

`Static`Dot

Dot(left: DeepImmutable<Quaternion>, right: DeepImmutable<Quaternion>): number
Returns the dot product (float) between the quaternions "left" and "right" Example Playground https://playground.babylonjs.com/#L49EJ7#61
Parameters
- left: DeepImmutable<Quaternion>
  defines the left operand
- right: DeepImmutable<Quaternion>
  defines the right operand
Returns number
the dot product
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5448

`Static`FromArray

FromArray(array: DeepImmutable<ArrayLike<number>>, offset?: number): Quaternion
Creates a new quaternion from data stored into an array Example Playground https://playground.babylonjs.com/#L49EJ7#63
Parameters
- array: DeepImmutable<ArrayLike<number>>
  defines the data source
- Optionaloffset: number
  defines the offset in the source array where the data starts
Returns Quaternion
a new quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5567

`Static`FromArrayToRef

FromArrayToRef<T extends Quaternion>(
    array: DeepImmutable<ArrayLike<number>>,
    offset: number,
    result: T,
): T
Updates the given quaternion "result" from the starting index of the given array. Example Playground https://playground.babylonjs.com/#L49EJ7#64
Type Parameters
- T extends Quaternion
Parameters
- array: DeepImmutable<ArrayLike<number>>
  the array to pull values from
- offset: number
  the offset into the array to start at
- result: T
  the quaternion to store the result in
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5582

`Static`FromEulerAngles

FromEulerAngles(x: number, y: number, z: number): Quaternion
Create a quaternion from Euler rotation angles Example Playground https://playground.babylonjs.com/#L49EJ7#33
Parameters
- x: number
  Pitch
- y: number
  Yaw
- z: number
  Roll
Returns Quaternion
the new Quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5613

`Static`FromEulerAnglesToRef

FromEulerAnglesToRef<T extends Quaternion>(
    x: number,
    y: number,
    z: number,
    result: T,
): T
Updates a quaternion from Euler rotation angles Example Playground https://playground.babylonjs.com/#L49EJ7#34
Type Parameters
- T extends Quaternion
Parameters
- x: number
  Pitch
- y: number
  Yaw
- z: number
  Roll
- result: T
  the quaternion to store the result
Returns T
the updated quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5628

`Static`FromEulerVector

FromEulerVector(vec: DeepImmutable<Vector3>): Quaternion
Create a quaternion from Euler rotation vector Example Playground https://playground.babylonjs.com/#L49EJ7#35
Parameters
- vec: DeepImmutable<Vector3>
  the Euler vector (x Pitch, y Yaw, z Roll)
Returns Quaternion
the new Quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5639

`Static`FromEulerVectorToRef

FromEulerVectorToRef<T extends Quaternion>(
vec: DeepImmutable<Vector3>,
result: T,
): T
Updates a quaternion from Euler rotation vector Example Playground https://playground.babylonjs.com/#L49EJ7#36
Type Parameters
- T extends Quaternion
Parameters
- vec: DeepImmutable<Vector3>
  the Euler vector (x Pitch, y Yaw, z Roll)
- result: T
  the quaternion to store the result
Returns T
the updated quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5652

`Static`FromFloatsToRef

FromFloatsToRef<T extends Quaternion = Quaternion>(
    x: number,
    y: number,
    z: number,
    w: number,
    result: T,
): T
Sets the given quaternion "result" with the given floats.
Type Parameters
- T extends Quaternion = Quaternion
Parameters
- x: number
  defines the x coordinate of the source
- y: number
  defines the y coordinate of the source
- z: number
  defines the z coordinate of the source
- w: number
  defines the w coordinate of the source
- result: T
  defines the quaternion where to store the result
Returns T
the result quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5600

`Static`FromLookDirectionLH

FromLookDirectionLH(
forward: DeepImmutable<Vector3>,
up: DeepImmutable<Vector3>,
): Quaternion
Creates a new rotation value to orient an object to look towards the given forward direction, the up direction being oriented like "up". This function works in left handed mode Example Playground https://playground.babylonjs.com/#L49EJ7#96
Parameters
- forward: DeepImmutable<Vector3>
  defines the forward direction - Must be normalized and orthogonal to up.
- up: DeepImmutable<Vector3>
  defines the up vector for the entity - Must be normalized and orthogonal to forward.
Returns Quaternion
A new quaternion oriented toward the specified forward and up.
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5805

`Static`FromLookDirectionLHToRef

FromLookDirectionLHToRef<T extends Quaternion>(
    forward: DeepImmutable<Vector3>,
    up: DeepImmutable<Vector3>,
    ref: T,
): T
Creates a new rotation value to orient an object to look towards the given forward direction with the up direction being oriented like "up", and stores it in the target quaternion. This function works in left handed mode Example Playground https://playground.babylonjs.com/#L49EJ7#97
Type Parameters
- T extends Quaternion
Parameters
- forward: DeepImmutable<Vector3>
  defines the forward direction - Must be normalized and orthogonal to up.
- up: DeepImmutable<Vector3>
  defines the up vector for the entity - Must be normalized and orthogonal to forward.
- ref: T
  defines the target quaternion.
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5820

`Static`FromLookDirectionRH

FromLookDirectionRH(
forward: DeepImmutable<Vector3>,
up: DeepImmutable<Vector3>,
): Quaternion
Creates a new rotation value to orient an object to look towards the given forward direction, the up direction being oriented like "up". This function works in right handed mode Example Playground https://playground.babylonjs.com/#L49EJ7#98
Parameters
- forward: DeepImmutable<Vector3>
  defines the forward direction - Must be normalized and orthogonal to up.
- up: DeepImmutable<Vector3>
  defines the up vector for the entity - Must be normalized and orthogonal to forward.
Returns Quaternion
A new quaternion oriented toward the specified forward and up.
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5835

`Static`FromLookDirectionRHToRef

FromLookDirectionRHToRef<T extends Quaternion>(
    forward: DeepImmutable<Vector3>,
    up: DeepImmutable<Vector3>,
    ref: T,
): T
Creates a new rotation value to orient an object to look towards the given forward direction with the up direction being oriented like "up", and stores it in the target quaternion. This function works in right handed mode Example Playground https://playground.babylonjs.com/#L49EJ7#105
Type Parameters
- T extends Quaternion
Parameters
- forward: DeepImmutable<Vector3>
  defines the forward direction - Must be normalized and orthogonal to up.
- up: DeepImmutable<Vector3>
  defines the up vector for the entity - Must be normalized and orthogonal to forward.
- ref: T
  defines the target quaternion.
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5850

`Static`FromRotationMatrix

FromRotationMatrix(matrix: DeepImmutable<Matrix>): Quaternion
Creates a new quaternion from a rotation matrix Example Playground https://playground.babylonjs.com/#L49EJ7#101
Parameters
- matrix: DeepImmutable<Matrix>
  defines the source matrix
Returns Quaternion
a new quaternion created from the given rotation matrix values
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5378

`Static`FromRotationMatrixToRef

FromRotationMatrixToRef<T extends Quaternion>(
matrix: DeepImmutable<Matrix>,
result: T,
): T
Updates the given quaternion with the given rotation matrix values Example Playground https://playground.babylonjs.com/#L49EJ7#102
Type Parameters
- T extends Quaternion
Parameters
- matrix: DeepImmutable<Matrix>
  defines the source matrix
- result: T
  defines the target quaternion
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5391

`Static`FromUnitVectorsToRef

FromUnitVectorsToRef<T extends Quaternion>(
    vecFrom: DeepImmutable<Vector3>,
    vecTo: DeepImmutable<Vector3>,
    result: T,
    epsilon?: number,
): T
Updates a quaternion so that it rotates vector vecFrom to vector vecTo Example Playground - https://playground.babylonjs.com/#L49EJ7#70
Type Parameters
- T extends Quaternion
Parameters
- vecFrom: DeepImmutable<Vector3>
  defines the direction vector from which to rotate
- vecTo: DeepImmutable<Vector3>
  defines the direction vector to which to rotate
- result: T
  the quaternion to store the result
- epsilon: number = Epsilon
  defines the minimal dot value to define vecs as opposite. Default: BABYLON.Epsilon
Returns T
the updated quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5666

`Static`Hermite

Hermite(
    value1: DeepImmutable<Quaternion>,
    tangent1: DeepImmutable<Quaternion>,
    value2: DeepImmutable<Quaternion>,
    tangent2: DeepImmutable<Quaternion>,
    amount: number,
): Quaternion
Interpolate between two quaternions using Hermite interpolation Example Playground https://playground.babylonjs.com/#L49EJ7#47
Parameters
- value1: DeepImmutable<Quaternion>
  defines first quaternion
- tangent1: DeepImmutable<Quaternion>
  defines the incoming tangent
- value2: DeepImmutable<Quaternion>
  defines second quaternion
- tangent2: DeepImmutable<Quaternion>
  defines the outgoing tangent
- amount: number
  defines the target quaternion
Returns Quaternion
the new interpolated quaternion

See
https://doc.babylonjs.com/features/featuresDeepDive/mesh/drawCurves#hermite-quaternion-spline
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5921

`Static`Hermite1stDerivative

Hermite1stDerivative(
    value1: DeepImmutable<Quaternion>,
    tangent1: DeepImmutable<Quaternion>,
    value2: DeepImmutable<Quaternion>,
    tangent2: DeepImmutable<Quaternion>,
    time: number,
): Quaternion
Returns a new Quaternion which is the 1st derivative of the Hermite spline defined by the quaternions "value1", "value2", "tangent1", "tangent2". Example Playground https://playground.babylonjs.com/#L49EJ7#48
Parameters
- value1: DeepImmutable<Quaternion>
  defines the first control point
- tangent1: DeepImmutable<Quaternion>
  defines the first tangent
- value2: DeepImmutable<Quaternion>
  defines the second control point
- tangent2: DeepImmutable<Quaternion>
  defines the second tangent
- time: number
  define where the derivative must be done
Returns Quaternion
1st derivative
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5952

`Static`Hermite1stDerivativeToRef

Hermite1stDerivativeToRef<T extends Quaternion>(
    value1: DeepImmutable<Quaternion>,
    tangent1: DeepImmutable<Quaternion>,
    value2: DeepImmutable<Quaternion>,
    tangent2: DeepImmutable<Quaternion>,
    time: number,
    result: T,
): T
Update a Quaternion with the 1st derivative of the Hermite spline defined by the quaternions "value1", "value2", "tangent1", "tangent2". Example Playground https://playground.babylonjs.com/#L49EJ7#49
Type Parameters
- T extends Quaternion
Parameters
- value1: DeepImmutable<Quaternion>
  defines the first control point
- tangent1: DeepImmutable<Quaternion>
  defines the first tangent
- value2: DeepImmutable<Quaternion>
  defines the second control point
- tangent2: DeepImmutable<Quaternion>
  defines the second tangent
- time: number
  define where the derivative must be done
- result: T
  define where to store the derivative
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5977

`Static`Identity

Identity(): Quaternion
Creates an identity quaternion

Returns Quaternion
the identity quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5518

`Static`Inverse

Inverse(q: DeepImmutable<Quaternion>): Quaternion
Inverse a given quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#103
Parameters
- q: DeepImmutable<Quaternion>
  defines the source quaternion
Returns Quaternion
a new quaternion as the inverted current quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5498

`Static`InverseToRef

InverseToRef<T extends Quaternion>(q: Quaternion, result: T): T
Inverse a given quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#104
Type Parameters
- T extends Quaternion
Parameters
- q: Quaternion
  defines the source quaternion
- result: T
  the quaternion the result will be stored in
Returns T
the result quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5509

`Static`IsIdentity

IsIdentity(quaternion: DeepImmutable<Quaternion>): boolean
Gets a boolean indicating if the given quaternion is identity
Parameters
- quaternion: DeepImmutable<Quaternion>
  defines the quaternion to check
Returns boolean
true if the quaternion is identity
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5527

`Static`Normalize

Normalize(quat: DeepImmutable<Quaternion>): Quaternion
Returns a new Quaternion as the normalization of the given Quaternion
Parameters
- quat: DeepImmutable<Quaternion>
  defines the Quaternion to normalize
Returns Quaternion
the new Quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6000

`Static`NormalizeToRef

NormalizeToRef<T extends Quaternion>(
quat: DeepImmutable<Quaternion>,
result: T,
): T
Sets the given Quaternion "result" with the normalization of the given first Quaternion
Type Parameters
- T extends Quaternion
Parameters
- quat: DeepImmutable<Quaternion>
  defines the Quaternion to normalize
- result: T
  defines the Quaternion where to store the result
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6012

`Static`Random

Random(min?: number, max?: number): Quaternion
Returns a new Quaternion with random values between min and max
Parameters
- min: number = 0
  the minimum random value
- max: number = 1
  the maximum random value
Returns Quaternion
a Quaternion with random values between min and max
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6052

`Static`RandomToRef

RandomToRef<T extends Quaternion>(min?: number, max?: number, ref: T): T
Sets a Quaternion with random values between min and max
Type Parameters
- T extends Quaternion
Parameters
- min: number = 0
  the minimum random value
- max: number = 1
  the maximum random value
- ref: T
  the ref to store the values in
Returns T
the ref with random values between min and max
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6063

`Static`RotationAlphaBetaGamma

RotationAlphaBetaGamma(alpha: number, beta: number, gamma: number): Quaternion
Creates a new quaternion from the given Euler float angles expressed in z-x-z orientation Example Playground https://playground.babylonjs.com/#L49EJ7#68
Parameters
- alpha: number
  defines the rotation around first axis
- beta: number
  defines the rotation around second axis
- gamma: number
  defines the rotation around third axis
Returns Quaternion
the new quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5735

`Static`RotationAlphaBetaGammaToRef

RotationAlphaBetaGammaToRef<T extends Quaternion>(
    alpha: number,
    beta: number,
    gamma: number,
    result: T,
): T
Creates a new quaternion from the given Euler float angles expressed in z-x-z orientation and stores it in the target quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#69
Type Parameters
- T extends Quaternion
Parameters
- alpha: number
  defines the rotation around first axis
- beta: number
  defines the rotation around second axis
- gamma: number
  defines the rotation around third axis
- result: T
  defines the target quaternion
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5750

`Static`RotationAxis

RotationAxis(axis: DeepImmutable<Vector3>, angle: number): Quaternion
Creates a quaternion from a rotation around an axis Example Playground https://playground.babylonjs.com/#L49EJ7#72
Parameters
- axis: DeepImmutable<Vector3>
  defines the axis to use
- angle: number
  defines the angle to use
Returns Quaternion
a new quaternion created from the given axis (Vector3) and angle in radians (float)
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5538

`Static`RotationAxisToRef

RotationAxisToRef<T extends Quaternion>(
    axis: DeepImmutable<Vector3>,
    angle: number,
    result: T,
): T
Creates a rotation around an axis and stores it into the given quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#73
Type Parameters
- T extends Quaternion
Parameters
- axis: DeepImmutable<Vector3>
  defines the axis to use
- angle: number
  defines the angle to use
- result: T
  defines the target quaternion
Returns T
the target quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5550

`Static`RotationQuaternionFromAxis

RotationQuaternionFromAxis(
    axis1: DeepImmutable<Vector3>,
    axis2: DeepImmutable<Vector3>,
    axis3: DeepImmutable<Vector3>,
): Quaternion
Creates a new quaternion containing the rotation value to reach the target (axis1, axis2, axis3) orientation as a rotated XYZ system (axis1, axis2 and axis3 are normalized during this operation) Example Playground https://playground.babylonjs.com/#L49EJ7#75
Parameters
- axis1: DeepImmutable<Vector3>
  defines the first axis
- axis2: DeepImmutable<Vector3>
  defines the second axis
- axis3: DeepImmutable<Vector3>
  defines the third axis
Returns Quaternion
the new quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5772

`Static`RotationQuaternionFromAxisToRef

RotationQuaternionFromAxisToRef<T extends Quaternion>(
    axis1: DeepImmutable<Vector3>,
    axis2: DeepImmutable<Vector3>,
    axis3: DeepImmutable<Vector3>,
    ref: T,
): T
Creates a rotation value to reach the target (axis1, axis2, axis3) orientation as a rotated XYZ system (axis1, axis2 and axis3 are normalized during this operation) and stores it in the target quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#76
Type Parameters
- T extends Quaternion
Parameters
- axis1: DeepImmutable<Vector3>
  defines the first axis
- axis2: DeepImmutable<Vector3>
  defines the second axis
- axis3: DeepImmutable<Vector3>
  defines the third axis
- ref: T
  defines the target quaternion
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5787

`Static`RotationYawPitchRoll

RotationYawPitchRoll(yaw: number, pitch: number, roll: number): Quaternion
Creates a new quaternion from the given Euler float angles (y, x, z) Example Playground https://playground.babylonjs.com/#L49EJ7#77
Parameters
- yaw: number
  defines the rotation around Y axis
- pitch: number
  defines the rotation around X axis
- roll: number
  defines the rotation around Z axis
Returns Quaternion
the new quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5691

`Static`RotationYawPitchRollToRef

RotationYawPitchRollToRef<T extends Quaternion>(
    yaw: number,
    pitch: number,
    roll: number,
    result: T,
): T
Creates a new rotation from the given Euler float angles (y, x, z) and stores it in the target quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#561
Type Parameters
- T extends Quaternion
Parameters
- yaw: number
  defines the rotation around Y axis
- pitch: number
  defines the rotation around X axis
- roll: number
  defines the rotation around Z axis
- result: T
  defines the target quaternion
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5706

`Static`Slerp

Slerp(
    left: DeepImmutable<Quaternion>,
    right: DeepImmutable<Quaternion>,
    amount: number,
): Quaternion
Interpolates between two quaternions Example Playground https://playground.babylonjs.com/#L49EJ7#79
Parameters
- left: DeepImmutable<Quaternion>
  defines first quaternion
- right: DeepImmutable<Quaternion>
  defines second quaternion
- amount: number
  defines the gradient to use
Returns Quaternion
the new interpolated quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5864

`Static`SlerpToRef

SlerpToRef<T extends Quaternion>(
    left: DeepImmutable<Quaternion>,
    right: DeepImmutable<Quaternion>,
    amount: number,
    result: T,
): T
Interpolates between two quaternions and stores it into a target quaternion Example Playground https://playground.babylonjs.com/#L49EJ7#92
Type Parameters
- T extends Quaternion
Parameters
- left: DeepImmutable<Quaternion>
  defines first quaternion
- right: DeepImmutable<Quaternion>
  defines second quaternion
- amount: number
  defines the gradient to use
- result: T
  defines the target quaternion
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5881

`Static`SmoothToRef

SmoothToRef<T extends Quaternion>(
    source: Quaternion,
    goal: Quaternion,
    deltaTime: number,
    lerpTime: number,
    result: T,
): T
Smooth interpolation between two quaternions using Slerp Example Playground https://playground.babylonjs.com/#L49EJ7#93
Type Parameters
- T extends Quaternion
Parameters
- source: Quaternion
  source quaternion
- goal: Quaternion
  goal quaternion
- deltaTime: number
  current interpolation frame
- lerpTime: number
  total interpolation time
- result: T
  the smoothed quaternion
Returns T
the smoothed quaternion
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5476

`Static`Zero

Zero(): Quaternion
Creates an empty quaternion

Returns Quaternion
a new quaternion set to (0.0, 0.0, 0.0)
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:5488

Class Quaternion

See

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

Returns Quaternion

Properties

Readonlydimension

See

Readonlyrank

See

Static_V8PerformanceHack

Accessors

w

Returns number

Parameters

Returns void

x

Returns number

Parameters

Returns void

y

Returns number

Parameters

Returns void

z

Returns number

Parameters

Returns void

Methods

add

Parameters

Returns Quaternion

addInPlace

Parameters

Returns this

addInPlaceFromFloats

Parameters

Returns this

addToRef

Type Parameters

Parameters

Returns T

asArray

Returns [number, number, number, number]

clone

Returns Quaternion

conjugate

Returns Quaternion

conjugateInPlace

Returns this

conjugateToRef

Type Parameters

Parameters

Returns T

copyFrom

Parameters

Returns this

copyFromFloats

Parameters

Returns this

dot

Parameters

Returns number

equals

Parameters

Returns boolean

equalsToFloats

Parameters

Returns boolean

equalsWithEpsilon

Parameters

Returns boolean

fromArray

`Readonly`dimension

`Readonly`rank

`Static`_V8PerformanceHack