Class Matrix

Class used to store matrix data (4x4) Note on matrix definitions in Babylon.js for setting values directly rather than using one of the methods available. Matrix size is given by rows x columns. A Vector3 is a 1 X 3 matrix [x, y, z].

In Babylon.js multiplying a 1 x 3 matrix by a 4 x 4 matrix is done using BABYLON.Vector4.TransformCoordinates(Vector3, Matrix). and extending the passed Vector3 to a Vector4, V = [x, y, z, 1]. Let M be a matrix with elements m(row, column), so that m(2, 3) is the element in row 2 column 3 of M.

Multiplication is of the form VM and has the resulting Vector4 VM = [xm(0, 0) + ym(1, 0) + zm(2, 0) + m(3, 0), xm(0, 1) + ym(1, 1) + zm(2, 1) + m(3, 1), xm(0, 2) + ym(1, 2) + zm(2, 2) + m(3, 2), xm(0, 3) + ym(1, 3) + zm(2, 3) + m(3, 3)]. On the web you will find many examples that use the opposite convention of MV, in which case to make use of the examples you will need to transpose the matrix.

Example Playground - Overview Linear Algebra - https://playground.babylonjs.com/#AV9X17 Example Playground - Overview Transformation - https://playground.babylonjs.com/#AV9X17#1 Example Playground - Overview Projection - https://playground.babylonjs.com/#AV9X17#2

Implements

Tensor<Tuple<Tuple<number, 4>, 4>, Matrix>

Index

Constructors

constructor

new Matrix(): Matrix
Creates an empty matrix (filled with zeros)

Returns Matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6213

Properties

`Readonly`dimension

dimension: readonly [4, 4]

See

Tensor.dimension

`Readonly`rank

rank: 2

See

Tensor.rank

updateFlag

updateFlag: number = -1

Gets the update flag of the matrix which is an unique number for the matrix. It will be incremented every time the matrix data change. You can use it to speed the comparison between two versions of the same matrix.

Accessors

m

get m(): DeepImmutableArray<number>
Gets the internal data of the matrix

Returns DeepImmutableArray<number>
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6188

`Static`IdentityReadOnly

get IdentityReadOnly(): DeepImmutable<Matrix>
Gets an identity matrix that must not be updated

Returns DeepImmutable<Matrix>
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7396

`Static`Use64Bits

get Use64Bits(): boolean
Gets the precision of matrix computations

Returns boolean
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6166

Methods

add

add(other: DeepImmutable<Matrix>): Matrix
Adds the current matrix with a second one Example Playground - https://playground.babylonjs.com/#AV9X17#44
Parameters
- other: DeepImmutable<Matrix>
  defines the matrix to add
Returns Matrix
a new matrix as the addition of the current matrix and the given one
Implementation of Tensor.add
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6448

addAtIndex

addAtIndex(index: number, value: number): this
add a value at the specified position in the current Matrix Example Playground - https://playground.babylonjs.com/#AV9X17#47
Parameters
- index: number
  the index of the value within the matrix. between 0 and 15.
- value: number
  the value to be added
Returns this
the current updated matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6592

addInPlace

addInPlace(other: DeepImmutable<Matrix>): this
Set the instance coordinates by adding the given instance coordinates
Parameters
- other: DeepImmutable<Matrix>
  defines the other instance
Returns this
the current updated instance
Implementation of Tensor.addInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6501

addInPlaceFromFloats

addInPlaceFromFloats(
    ...floats: [
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
    ],
): this
Adds the given coordinates to the current instance
Parameters
- ...floats: [
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
  ]
  the floats to add
Returns this
the current updated instance
Implementation of Tensor.addInPlaceFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6511

addToRef

addToRef<T extends Matrix>(other: DeepImmutable<Matrix>, result: T): T
Sets the given matrix "result" to the addition of the current matrix and the given one Example Playground - https://playground.babylonjs.com/#AV9X17#45
Type Parameters
- T extends Matrix
Parameters
- other: DeepImmutable<Matrix>
  defines the matrix to add
- result: T
  defines the target matrix
Returns T
result input
Implementation of Tensor.addToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6461

addToSelf

addToSelf(other: DeepImmutable<Matrix>): this
Adds in place the given matrix to the current matrix Example Playground - https://playground.babylonjs.com/#AV9X17#46
Parameters
- other: DeepImmutable<Matrix>
  defines the second operand
Returns this
the current updated matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6478

addTranslationFromFloats

addTranslationFromFloats(x: number, y: number, z: number): this
Adds the translation vector (using 3 floats) in the current matrix Example Playground - https://playground.babylonjs.com/#AV9X17#20 Example Playground - https://playground.babylonjs.com/#AV9X17#48
Parameters
- x: number
  defines the 1st component of the translation
- y: number
  defines the 2nd component of the translation
- z: number
  defines the 3rd component of the translation
Returns this
the current updated matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6635

asArray

asArray(): [
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
]

Returns the matrix as a Float32Array or Array Example Playground - https://playground.babylonjs.com/#AV9X17#114

Returns [
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
]

the matrix underlying array.

clone

clone(): Matrix
Clone the current matrix Example Playground - https://playground.babylonjs.com/#AV9X17#18

Returns Matrix
a new matrix from the current matrix
Implementation of Tensor.clone
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6986

copyFrom

copyFrom(other: DeepImmutable<Matrix>): this
Copy the current matrix from the given one Example Playground - https://playground.babylonjs.com/#AV9X17#21
Parameters
- other: DeepImmutable<Matrix>
  defines the source matrix
Returns this
the current updated matrix
Implementation of Tensor.copyFrom
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6692

copyFromFloats

copyFromFloats(
    ...floats: [
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
    ],
): this
Sets all the matrix values from a float array
Parameters
- ...floats: [
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
  ]
  the 16 float values to set
Returns this
the current updated matrix
Implementation of Tensor.copyFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6391

copyToArray

copyToArray(
array: number[] | Float32Array<ArrayBufferLike>,
offset?: number,
): this
Populates the given array from the starting index with the current matrix values
Parameters
- array: number[] | Float32Array<ArrayBufferLike>
  defines the target array
- offset: number = 0
  defines the offset in the target array where to start storing values
Returns this
the current matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6706

decompose

decompose(
    scale?: Vector3,
    rotation?: Quaternion,
    translation?: Vector3,
    preserveScalingNode?: TransformNode,
    useAbsoluteScaling?: boolean,
): boolean
Decomposes the current Matrix into a translation, rotation and scaling components Example Playground - https://playground.babylonjs.com/#AV9X17#12
Parameters
- Optionalscale: Vector3
  defines the scale vector3 given as a reference to update
- Optionalrotation: Quaternion
  defines the rotation quaternion given as a reference to update
- Optionaltranslation: Vector3
  defines the translation vector3 given as a reference to update
- OptionalpreserveScalingNode: TransformNode
  Use scaling sign coming from this node. Otherwise scaling sign might change.
- useAbsoluteScaling: boolean = true
  Use scaling sign coming from this absoluteScaling when true or scaling otherwise.
Returns boolean
true if operation was successful
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7032

decomposeToTransformNode

decomposeToTransformNode(node: TransformNode): boolean
Decomposes the current Matrix into a translation, rotation and scaling components of the provided node Example Playground - https://playground.babylonjs.com/#AV9X17#13
Parameters
- node: TransformNode
  the node to decompose the matrix to
Returns boolean
true if operation was successful
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7018

determinant

determinant(): number
Gets the determinant of the matrix Example Playground - https://playground.babylonjs.com/#AV9X17#34

Returns number
the matrix determinant
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6293

divide

divide(other: DeepImmutable<Matrix>): Matrix
Returns a new instance set with the instance coordinates divided by the given one coordinates
Parameters
- other: DeepImmutable<Matrix>
  defines the other instance
Returns Matrix
a new instance
Implementation of Tensor.divide
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6807

divideInPlace

divideInPlace(other: DeepImmutable<Matrix>): this
Divides the current instance coordinates by the given ones
Parameters
- other: DeepImmutable<Matrix>
  defines the other instance
Returns this
the current updated instance
Implementation of Tensor.divideInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6822

divideToRef

divideToRef<T extends Matrix>(other: DeepImmutable<Matrix>, result: T): T
Sets the "result" coordinates with the instance coordinates divided by the given one coordinates
Type Parameters
- T extends Matrix
Parameters
- other: DeepImmutable<Matrix>
  defines the other instance
- result: T
  defines the target instance
Returns T
result input
Implementation of Tensor.divideToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6811

equals

equals(value: DeepImmutable<Matrix>): boolean
Check equality between this matrix and a second one
Parameters
- value: DeepImmutable<Matrix>
  defines the second matrix to compare
Returns boolean
true is the current matrix and the given one values are strictly equal
Implementation of Tensor.equals
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6898

equalsToFloats

equalsToFloats(
    ...floats: [
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
    ],
): boolean
Returns true if the current Vectoe coordinates equals the given floats
Parameters
- ...floats: [
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
  ]
  defines the coordinates to compare against
Returns boolean
true if both instances are equal
Implementation of Tensor.equalsToFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6943

equalsWithEpsilon

equalsWithEpsilon(other: DeepImmutable<Matrix>, epsilon?: number): boolean
Gets a boolean if two instances are equals (using an epsilon value)
Parameters
- other: DeepImmutable<Matrix>
  defines the other instance
- epsilon: number = 0
  defines the minimal distance to consider equality
Returns boolean
true if the given instance 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:6932

floor

floor(): Matrix
Gets a new instance from current instance floored values eg (1.2, 2.31) returns (1, 2)

Returns Matrix
a new instance
Implementation of Tensor.floor
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6953

floorToRef

floorToRef<T extends Matrix>(result: T): T
Gets the current instance's floored values and stores them in result
Type Parameters
- T extends Matrix
Parameters
- result: T
  the instance to store the result in
Returns T
the result instance
Implementation of Tensor.floorToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6957

fract

fract(): Matrix
Gets a new instance from current instance fractional values eg (1.2, 2.31) returns (0.2, 0.31)

Returns Matrix
a new instance
Implementation of Tensor.fract
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6967

fractToRef

fractToRef<T extends Matrix>(result: T): T
Gets the current instance's fractional values and stores them in result
Type Parameters
- T extends Matrix
Parameters
- result: T
  the instance to store the result in
Returns T
the result instance
Implementation of Tensor.fractToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6971

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:6382

getClassName

getClassName(): string
Returns the name of the current matrix class

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

getHashCode

getHashCode(): number
Gets the hash code of the current matrix

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

getRotationMatrix

getRotationMatrix(): Matrix
Gets only rotation part of the current matrix

Returns Matrix
a new matrix sets to the extracted rotation matrix from the current one
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7264

getRotationMatrixToRef

getRotationMatrixToRef<T extends Matrix>(result: T): T
Extracts the rotation matrix from the current one and sets it as the given "result"
Type Parameters
- T extends Matrix
Parameters
- result: T
  defines the target matrix to store data to
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7275

getRow

getRow(index: number): Nullable<Vector4>
Gets specific row of the matrix Example Playground - https://playground.babylonjs.com/#AV9X17#36
Parameters
- index: number
  defines the number of the row to get
Returns Nullable<Vector4>
the index-th row of the current matrix as a new Vector4
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7114

getRowToRef

getRowToRef<T extends Vector4>(index: number, rowVector: T): T
Gets specific row of the matrix to ref Example Playground - https://playground.babylonjs.com/#AV9X17#36
Type Parameters
- T extends Vector4
Parameters
- index: number
  defines the number of the row to get
- rowVector: T
  vector to store the index-th row of the current matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7129

getTranslation

getTranslation(): Vector3
Gets the translation value of the current matrix Example Playground - https://playground.babylonjs.com/#AV9X17#122

Returns Vector3
a new Vector3 as the extracted translation from the matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6658

getTranslationToRef

getTranslationToRef<T extends Vector3>(result: T): T
Fill a Vector3 with the extracted translation from the matrix Example Playground - https://playground.babylonjs.com/#AV9X17#123
Type Parameters
- T extends Vector3
Parameters
- result: T
  defines the Vector3 where to store the translation
Returns T
the current matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6668

invert

invert(): this
Inverts the current matrix in place Example Playground - https://playground.babylonjs.com/#AV9X17#118

Returns this
the current inverted matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6428

invertToRef

invertToRef<T extends Matrix>(other: T): T
Sets the given matrix to the current inverted Matrix Example Playground - https://playground.babylonjs.com/#AV9X17#119
Type Parameters
- T extends Matrix
Parameters
- other: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6571

isIdentity

isIdentity(): boolean
Check if the current matrix is identity

Returns boolean
true is the matrix is the identity matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6229

isIdentityAs3x2

isIdentityAs3x2(): boolean
Check if the current matrix is identity as a texture matrix (3x2 store in 4x4)

Returns boolean
true is the matrix is the identity matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6259

markAsUpdated

markAsUpdated(): void
Update the updateFlag to indicate that the matrix has been updated

Returns void
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6195

maximizeInPlace

maximizeInPlace(other: DeepImmutable<Matrix>): this
Updates the current instance with the maximal coordinate values between its and the given instance ones.
Parameters
- other: DeepImmutable<Matrix>
  defines the other instance
Returns this
this current updated instance
Implementation of Tensor.maximizeInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6851

maximizeInPlaceFromFloats

maximizeInPlaceFromFloats(
    ...floats: [
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
    ],
): this
Updates the current instance with the maximal coordinate values between its and the given floats.
Parameters
- ...floats: [
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
  ]
  defines the floats to compare against
Returns this
this current updated instance
Implementation of Tensor.maximizeInPlaceFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6861

minimizeInPlace

minimizeInPlace(other: DeepImmutable<Matrix>): this
Updates the current instance with the minmal coordinate values between its and the given instance ones.
Parameters
- other: DeepImmutable<Matrix>
  defines the other instance
Returns this
this current updated instance
Implementation of Tensor.minimizeInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6832

minimizeInPlaceFromFloats

minimizeInPlaceFromFloats(
    ...floats: [
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
    ],
): this
Updates the current instance with the minmal coordinate values between its and the given floats.
Parameters
- ...floats: [
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
  ]
  defines the floats to compare against
Returns this
this current updated instance
Implementation of Tensor.minimizeInPlaceFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6842

multiply

multiply(other: DeepImmutable<Matrix>): Matrix
Multiply two matrices Example Playground - https://playground.babylonjs.com/#AV9X17#15 A.multiply(B) means apply B to A so result is B x A
Parameters
- other: DeepImmutable<Matrix>
  defines the second operand
Returns Matrix
a new matrix set with the multiplication result of the current Matrix and the given one
Implementation of Tensor.multiply
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6718

multiplyAtIndex

multiplyAtIndex(index: number, value: number): this
mutiply the specified position in the current Matrix by a value
Parameters
- index: number
  the index of the value within the matrix. between 0 and 15.
- value: number
  the value to be added
Returns this
the current updated matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6604

multiplyByFloats

multiplyByFloats(
    ...floats: [
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
    ],
): this
This method performs a component-by-component multiplication of the current matrix with the array of transmitted numbers. Use multiply or multiplyToRef for matrix multiplication.
Parameters
- ...floats: [
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
  ]
  defines the array of numbers to multiply the matrix by
Returns this
the current updated matrix
Implementation of Tensor.multiplyByFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6746

multiplyByFloatsToRef

multiplyByFloatsToRef<T extends Matrix>(
    ...args: [
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        T,
    ],
): T
Multiples the current matrix by the given floats and stores them in the given ref
Type Parameters
- T extends Matrix
Parameters
- ...args: [
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      T,
  ]
  The floats and ref
Returns T
The updated ref
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6760

multiplyInPlace

multiplyInPlace(other: DeepImmutable<Matrix>): this
This method performs component-by-component in-place multiplication, rather than true matrix multiplication. Use multiply or multiplyToRef for matrix multiplication.
Parameters
- other: DeepImmutable<Matrix>
  defines the second operand
Returns this
the current updated matrix
Implementation of Tensor.multiplyInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6730

multiplyToArray

multiplyToArray(
    other: DeepImmutable<Matrix>,
    result: number[] | Float32Array<ArrayBufferLike>,
    offset: number,
): this
Sets the Float32Array "result" from the given index "offset" with the multiplication of the current matrix and the given one
Parameters
- other: DeepImmutable<Matrix>
  defines the second operand
- result: number[] | Float32Array<ArrayBufferLike>
  defines the array where to store the multiplication
- offset: number
  defines the offset in the target array where to start storing values
Returns this
the current matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6802

multiplyToRef

multiplyToRef<T extends Matrix>(other: DeepImmutable<Matrix>, result: T): T
Sets the given matrix "result" with the multiplication result of the current Matrix and the given one A.multiplyToRef(B, R) means apply B to A and store in R and R = B x A Example Playground - https://playground.babylonjs.com/#AV9X17#16
Type Parameters
- T extends Matrix
Parameters
- other: DeepImmutable<Matrix>
  defines the second operand
- result: T
  defines the matrix where to store the multiplication
Returns T
result input
Implementation of Tensor.multiplyToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6780

negate

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

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

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:6874

negateToRef

negateToRef<T extends Matrix>(result: T): T
Negate the current instance and stores the result in the given instance "result" coordinates
Type Parameters
- T extends Matrix
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:6883

removeRotationAndScaling

removeRotationAndScaling(): this
Remove rotation and scaling part from the matrix

Returns this
the updated matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6679

reset

reset(): this
Sets all the matrix elements to zero

Returns this
the current matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6436

scale

scale(scale: number): Matrix
Compute a new matrix set with the current matrix values multiplied by scale (float)
Parameters
- scale: number
  defines the scale factor
Returns Matrix
a new matrix
Implementation of Tensor.scale
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7202

scaleAndAddToRef

scaleAndAddToRef<T extends Matrix>(scale: number, result: T): T
Scale the current matrix values by a factor and add the result to a given matrix
Type Parameters
- T extends Matrix
Parameters
- scale: number
  defines the scale factor
- result: T
  defines the Matrix to store the result
Returns T
result input
Implementation of Tensor.scaleAndAddToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7228

scaleInPlace

scaleInPlace(scale: number): this
Multiply the instance coordinates by
Parameters
- scale: number
  defines the scaling factor
Returns this
the current updated instance
Implementation of Tensor.scaleInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7236

scaleToRef

scaleToRef<T extends Matrix>(scale: number, result: T): T
Scale the current matrix values by a factor to a given result matrix
Type Parameters
- T extends Matrix
Parameters
- scale: number
  defines the scale factor
- result: T
  defines the matrix to store the result
Returns T
result input
Implementation of Tensor.scaleToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7214

set

set(
    ...values: [
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
    ],
): this
Sets the matrix values
Parameters
- ...values: [
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
  ]
  the 16 values to set
Returns this
the current updated matrix
Implementation of Tensor.set
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6400

setAll

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

setRow

setRow(index: number, row: Vector4): this
Sets the index-th row of the current matrix to the vector4 values Example Playground - https://playground.babylonjs.com/#AV9X17#36
Parameters
- index: number
  defines the number of the row to set
- row: Vector4
  defines the target vector4
Returns this
the updated current matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7147

setRowFromFloats

setRowFromFloats(
    index: number,
    x: number,
    y: number,
    z: number,
    w: number,
): this
Sets the index-th row of the current matrix with the given 4 x float values Example Playground - https://playground.babylonjs.com/#AV9X17#36
Parameters
- index: number
  defines the row index
- x: number
  defines the x component to set
- y: number
  defines the y component to set
- z: number
  defines the z component to set
- w: number
  defines the w component to set
Returns this
the updated current matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7183

setTranslation

setTranslation(vector3: DeepImmutable<Vector3>): this
Inserts the translation vector in the current matrix Example Playground - https://playground.babylonjs.com/#AV9X17#121
Parameters
- vector3: DeepImmutable<Vector3>
  defines the translation to insert
Returns this
the current updated matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6649

setTranslationFromFloats

setTranslationFromFloats(x: number, y: number, z: number): this
Inserts the translation vector (using 3 floats) in the current matrix Example Playground - https://playground.babylonjs.com/#AV9X17#120
Parameters
- x: number
  defines the 1st component of the translation
- y: number
  defines the 2nd component of the translation
- z: number
  defines the 3rd component of the translation
Returns this
the current updated matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6618

subtract

subtract(other: DeepImmutable<Matrix>): this
Returns a new instance set with the subtracted coordinates of other's coordinates from the current coordinates.
Parameters
- other: DeepImmutable<Matrix>
  defines the other instance
Returns this
a new instance
Implementation of Tensor.subtract
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6520

subtractFromFloats

subtractFromFloats(
    ...floats: [
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
    ],
): Matrix
Returns a new instance set with the subtraction of the given floats from the current instance coordinates
Parameters
- ...floats: [
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
  ]
  the coordinates to subtract
Returns Matrix
the resulting instance
Implementation of Tensor.subtractFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6549

subtractFromFloatsToRef

subtractFromFloatsToRef<T extends Matrix>(
    ...args: [
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        T,
    ],
): T
Subtracts the given floats from the current instance coordinates and set the given instance "result" with this result Note: Implementation uses array magic so types may be confusing.
Type Parameters
- T extends Matrix
Parameters
- ...args: [
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      number,
      T,
  ]
  the coordinates to subtract with the last element as the result
Returns T
the result
Implementation of Tensor.subtractFromFloatsToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6553

subtractInPlace

subtractInPlace(other: DeepImmutable<Matrix>): this
Sets the current instance coordinates by subtracting from it the given one coordinates
Parameters
- other: DeepImmutable<Matrix>
  defines the other instance
Returns this
the current updated instance
Implementation of Tensor.subtractInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6539

subtractToRef

subtractToRef<T extends Matrix>(other: DeepImmutable<Matrix>, result: T): T
Sets the "result" coordinates with the subtraction of the other's coordinates from the current coordinates.
Type Parameters
- T extends Matrix
Parameters
- other: DeepImmutable<Matrix>
  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:6529

toArray

toArray(): FloatArray

Returns the matrix as a Float32Array or Array

Returns FloatArray

Deprecated

Use asArray

toArray(array: FloatArray, index: number): this

Stores the matrix in a Float32Array or Array Example Playground - https://playground.babylonjs.com/#AV9X17#49

Parameters

array: FloatArray
The destination array
index: number
The destination index to start ay

Returns this

the matrix

toggleModelMatrixHandInPlace

toggleModelMatrixHandInPlace(): this
Toggles model matrix from being right handed to left handed in place and vice versa

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

toggleProjectionMatrixHandInPlace

toggleProjectionMatrixHandInPlace(): this
Toggles projection matrix from being right handed to left handed in place and vice versa

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

toNormalMatrix

toNormalMatrix<T extends Matrix>(ref: T): T
Writes to the given matrix a normal matrix, computed from this one (using values from identity matrix for fourth row and column). Example Playground - https://playground.babylonjs.com/#AV9X17#17
Type Parameters
- T extends Matrix
Parameters
- ref: T
  matrix to store the result
Returns T
the reference matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7251

toString

toString(): string
Gets a string with the Matrix values

Returns string
a string with the Matrix values
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:6344

transpose

transpose(): Matrix
Compute the transpose of the matrix Example Playground - https://playground.babylonjs.com/#AV9X17#40

Returns Matrix
the new transposed matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7156

transposeToRef

transposeToRef<T extends Matrix>(result: T): T
Compute the transpose of the matrix and store it in a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#41
Type Parameters
- T extends Matrix
Parameters
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7168

`Static`Compose

Compose(
    scale: DeepImmutable<Vector3>,
    rotation: DeepImmutable<Quaternion>,
    translation: DeepImmutable<Vector3>,
): Matrix
Creates a new matrix composed by merging scale (vector3), rotation (quaternion) and translation (vector3) Example Playground - https://playground.babylonjs.com/#AV9X17#24
Parameters
- scale: DeepImmutable<Vector3>
  defines the scale vector3
- rotation: DeepImmutable<Quaternion>
  defines the rotation quaternion
- translation: DeepImmutable<Vector3>
  defines the translation vector3
Returns Matrix
a new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7528

`Static`ComposeToRef

ComposeToRef<T extends Matrix>(
    scale: DeepImmutable<Vector3>,
    rotation: DeepImmutable<Quaternion>,
    translation: DeepImmutable<Vector3>,
    result: T,
): T
Sets a matrix to a value composed by merging scale (vector3), rotation (quaternion) and translation (vector3) Example Playground - https://playground.babylonjs.com/#AV9X17#25
Type Parameters
- T extends Matrix
Parameters
- scale: DeepImmutable<Vector3>
  defines the scale vector3
- rotation: DeepImmutable<Quaternion>
  defines the rotation quaternion
- translation: DeepImmutable<Vector3>
  defines the translation vector3
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7543

`Static`DecomposeLerp

DecomposeLerp(
    startValue: DeepImmutable<Matrix>,
    endValue: DeepImmutable<Matrix>,
    gradient: number,
): Matrix
Builds a new matrix whose values are computed by:
- decomposing the "startValue" and "endValue" matrices into their respective scale, rotation and translation matrices
- interpolating for "gradient" (float) the values between each of these decomposed matrices between the start and the end
- recomposing a new matrix from these 3 interpolated scale, rotation and translation matrices Example Playground - https://playground.babylonjs.com/#AV9X17#22 Example Playground - https://playground.babylonjs.com/#AV9X17#51
Parameters
- startValue: DeepImmutable<Matrix>
  defines the first matrix
- endValue: DeepImmutable<Matrix>
  defines the second matrix
- gradient: number
  defines the gradient between the two matrices
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7957

`Static`DecomposeLerpToRef

DecomposeLerpToRef<T extends Matrix>(
    startValue: DeepImmutable<Matrix>,
    endValue: DeepImmutable<Matrix>,
    gradient: number,
    result: T,
): T
Update a matrix to values which are computed by:
- decomposing the "startValue" and "endValue" matrices into their respective scale, rotation and translation matrices
- interpolating for "gradient" (float) the values between each of these decomposed matrices between the start and the end
- recomposing a new matrix from these 3 interpolated scale, rotation and translation matrices Example Playground - https://playground.babylonjs.com/#AV9X17#23 Example Playground - https://playground.babylonjs.com/#AV9X17#53
Type Parameters
- T extends Matrix
Parameters
- startValue: DeepImmutable<Matrix>
  defines the first matrix
- endValue: DeepImmutable<Matrix>
  defines the second matrix
- gradient: number
  defines the gradient between the two matrices
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7976

`Static`FromArray

FromArray(array: DeepImmutable<ArrayLike<number>>, offset?: number): Matrix
Creates a matrix from an array Example Playground - https://playground.babylonjs.com/#AV9X17#42
Parameters
- array: DeepImmutable<ArrayLike<number>>
  defines the source array
- offset: number = 0
  defines an offset in the source array
Returns Matrix
a new Matrix set from the starting index of the given array
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7341

`Static`FromArrayToRef

FromArrayToRef<T extends Matrix>(
    array: DeepImmutable<ArrayLike<number>>,
    offset: number,
    result: T,
): T
Copy the content of an array into a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#43
Type Parameters
- T extends Matrix
Parameters
- array: DeepImmutable<ArrayLike<number>>
  defines the source array
- offset: number
  defines an offset in the source array
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7355

`Static`FromFloat32ArrayToRefScaled

FromFloat32ArrayToRefScaled<T extends Matrix>(
    array: DeepImmutable<number[] | Float32Array<ArrayBufferLike>>,
    offset: number,
    scale: number,
    result: T,
): T
Stores an array into a matrix after having multiplied each component by a given factor Example Playground - https://playground.babylonjs.com/#AV9X17#50
Type Parameters
- T extends Matrix
Parameters
- array: DeepImmutable<number[] | Float32Array<ArrayBufferLike>>
  defines the source array
- offset: number
  defines the offset in the source array
- scale: number
  defines the scaling factor
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7372

`Static`FromQuaternionToRef

FromQuaternionToRef<T extends Matrix>(
quat: DeepImmutable<Quaternion>,
result: T,
): T
Creates a rotation matrix from a quaternion and stores it in a target matrix
Type Parameters
- T extends Matrix
Parameters
- quat: DeepImmutable<Quaternion>
  defines the quaternion to use
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8863

`Static`FromValues

FromValues(
    initialM11: number,
    initialM12: number,
    initialM13: number,
    initialM14: number,
    initialM21: number,
    initialM22: number,
    initialM23: number,
    initialM24: number,
    initialM31: number,
    initialM32: number,
    initialM33: number,
    initialM34: number,
    initialM41: number,
    initialM42: number,
    initialM43: number,
    initialM44: number,
): Matrix
Creates new matrix from a list of values (16)
Parameters
- initialM11: number
  defines 1st value of 1st row
- initialM12: number
  defines 2nd value of 1st row
- initialM13: number
  defines 3rd value of 1st row
- initialM14: number
  defines 4th value of 1st row
- initialM21: number
  defines 1st value of 2nd row
- initialM22: number
  defines 2nd value of 2nd row
- initialM23: number
  defines 3rd value of 2nd row
- initialM24: number
  defines 4th value of 2nd row
- initialM31: number
  defines 1st value of 3rd row
- initialM32: number
  defines 2nd value of 3rd row
- initialM33: number
  defines 3rd value of 3rd row
- initialM34: number
  defines 4th value of 3rd row
- initialM41: number
  defines 1st value of 4th row
- initialM42: number
  defines 2nd value of 4th row
- initialM43: number
  defines 3rd value of 4th row
- initialM44: number
  defines 4th value of 4th row
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7480

`Static`FromValuesToRef

FromValuesToRef(
    initialM11: number,
    initialM12: number,
    initialM13: number,
    initialM14: number,
    initialM21: number,
    initialM22: number,
    initialM23: number,
    initialM24: number,
    initialM31: number,
    initialM32: number,
    initialM33: number,
    initialM34: number,
    initialM41: number,
    initialM42: number,
    initialM43: number,
    initialM44: number,
    result: Matrix,
): void
Stores a list of values (16) inside a given matrix
Parameters
- initialM11: number
  defines 1st value of 1st row
- initialM12: number
  defines 2nd value of 1st row
- initialM13: number
  defines 3rd value of 1st row
- initialM14: number
  defines 4th value of 1st row
- initialM21: number
  defines 1st value of 2nd row
- initialM22: number
  defines 2nd value of 2nd row
- initialM23: number
  defines 3rd value of 2nd row
- initialM24: number
  defines 4th value of 2nd row
- initialM31: number
  defines 1st value of 3rd row
- initialM32: number
  defines 2nd value of 3rd row
- initialM33: number
  defines 3rd value of 3rd row
- initialM34: number
  defines 4th value of 3rd row
- initialM41: number
  defines 1st value of 4th row
- initialM42: number
  defines 2nd value of 4th row
- initialM43: number
  defines 3rd value of 4th row
- initialM44: number
  defines 4th value of 4th row
- result: Matrix
  defines the target matrix
Returns void
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7420

`Static`FromXYZAxesToRef

FromXYZAxesToRef<T extends Matrix>(
    xaxis: DeepImmutable<Vector3>,
    yaxis: DeepImmutable<Vector3>,
    zaxis: DeepImmutable<Vector3>,
    result: T,
): T
Sets the given matrix as a rotation matrix composed from the 3 left handed axes
Type Parameters
- T extends Matrix
Parameters
- xaxis: DeepImmutable<Vector3>
  defines the value of the 1st axis
- yaxis: DeepImmutable<Vector3>
  defines the value of the 2nd axis
- zaxis: DeepImmutable<Vector3>
  defines the value of the 3rd axis
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8852

`Static`GetAsMatrix2x2

GetAsMatrix2x2(
matrix: DeepImmutable<Matrix>,
): number[] | Float32Array<ArrayBufferLike>
Extracts a 2x2 matrix from a given matrix and store the result in a Float32Array
Parameters
- matrix: DeepImmutable<Matrix>
  defines the matrix to use
Returns number[] | Float32Array<ArrayBufferLike>
a new Float32Array array with 4 elements : the 2x2 matrix extracted from the given matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8714

`Static`GetAsMatrix3x3

GetAsMatrix3x3(
matrix: DeepImmutable<Matrix>,
): number[] | Float32Array<ArrayBufferLike>
Extracts a 3x3 matrix from a given matrix and store the result in a Float32Array
Parameters
- matrix: DeepImmutable<Matrix>
  defines the matrix to use
Returns number[] | Float32Array<ArrayBufferLike>
a new Float32Array array with 9 elements : the 3x3 matrix extracted from the given matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8724

`Static`GetFinalMatrix

GetFinalMatrix(
    viewport: DeepImmutable<Viewport>,
    world: DeepImmutable<Matrix>,
    view: DeepImmutable<Matrix>,
    projection: DeepImmutable<Matrix>,
    zmin: number,
    zmax: number,
): Matrix
Computes a complete transformation matrix Example Playground - https://playground.babylonjs.com/#AV9X17#113
Parameters
- viewport: DeepImmutable<Viewport>
  defines the viewport to use
- world: DeepImmutable<Matrix>
  defines the world matrix
- view: DeepImmutable<Matrix>
  defines the view matrix
- projection: DeepImmutable<Matrix>
  defines the projection matrix
- zmin: number
  defines the near clip plane
- zmax: number
  defines the far clip plane
Returns Matrix
the transformation matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8688

`Static`Identity

Identity(): Matrix
Creates a new identity matrix

Returns Matrix
a new identity matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7594

`Static`IdentityToRef

IdentityToRef<T extends Matrix>(result: T): T
Creates a new identity matrix and stores the result in a given matrix
Type Parameters
- T extends Matrix
Parameters
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7605

`Static`Invert

Invert(source: DeepImmutable<Matrix>): Matrix
Creates a new matrix as the invert of a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#124
Parameters
- source: DeepImmutable<Matrix>
  defines the source matrix
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7639

`Static`Lerp

Lerp(
    startValue: DeepImmutable<Matrix>,
    endValue: DeepImmutable<Matrix>,
    gradient: number,
): Matrix
Returns a new Matrix whose values are the interpolated values for "gradient" (float) between the ones of the matrices "startValue" and "endValue". Example Playground - https://playground.babylonjs.com/#AV9X17#55
Parameters
- startValue: DeepImmutable<Matrix>
  defines the start value
- endValue: DeepImmutable<Matrix>
  defines the end value
- gradient: number
  defines the gradient factor
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7919

`Static`LerpToRef

LerpToRef<T extends Matrix>(
    startValue: DeepImmutable<Matrix>,
    endValue: DeepImmutable<Matrix>,
    gradient: number,
    result: T,
): T
Set the given matrix "result" as the interpolated values for "gradient" (float) between the ones of the matrices "startValue" and "endValue". Example Playground - https://playground.babylonjs.com/#AV9X17#54
Type Parameters
- T extends Matrix
Parameters
- startValue: DeepImmutable<Matrix>
  defines the start value
- endValue: DeepImmutable<Matrix>
  defines the end value
- gradient: number
  defines the gradient factor
- result: T
  defines the Matrix object where to store data
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7934

`Static`LookAtLH

LookAtLH(
    eye: DeepImmutable<Vector3>,
    target: DeepImmutable<Vector3>,
    up: DeepImmutable<Vector3>,
): Matrix
Creates a new matrix that transforms vertices from world space to camera space. It takes three vectors as arguments that together describe the position and orientation of the camera. This function generates a matrix suitable for a left handed coordinate system Example Playground - https://playground.babylonjs.com/#AV9X17#58 Example Playground - https://playground.babylonjs.com/#AV9X17#59
Parameters
- eye: DeepImmutable<Vector3>
  defines the final position of the entity
- target: DeepImmutable<Vector3>
  defines where the entity should look at
- up: DeepImmutable<Vector3>
  defines the up vector for the entity
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8009

`Static`LookAtLHToRef

LookAtLHToRef(
    eye: DeepImmutable<Vector3>,
    target: DeepImmutable<Vector3>,
    up: DeepImmutable<Vector3>,
    result: Matrix,
): Matrix
Sets the given "result" Matrix to a matrix that transforms vertices from world space to camera space. It takes three vectors as arguments that together describe the position and orientation of the camera. This function generates a matrix suitable for a left handed coordinate system Example Playground - https://playground.babylonjs.com/#AV9X17#60 Example Playground - https://playground.babylonjs.com/#AV9X17#61
Parameters
- eye: DeepImmutable<Vector3>
  defines the final position of the entity
- target: DeepImmutable<Vector3>
  defines where the entity should look at
- up: DeepImmutable<Vector3>
  defines the up vector for the entity
- result: Matrix
  defines the target matrix
Returns Matrix
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8026

`Static`LookAtRH

LookAtRH(
    eye: DeepImmutable<Vector3>,
    target: DeepImmutable<Vector3>,
    up: DeepImmutable<Vector3>,
): Matrix
Creates a new matrix that transforms vertices from world space to camera space. It takes three vectors as arguments that together describe the position and orientation of the camera. This function generates a matrix suitable for a right handed coordinate system Example Playground - https://playground.babylonjs.com/#AV9X17#62 Example Playground - https://playground.babylonjs.com/#AV9X17#63
Parameters
- eye: DeepImmutable<Vector3>
  defines the final position of the entity
- target: DeepImmutable<Vector3>
  defines where the entity should look at
- up: DeepImmutable<Vector3>
  defines the up vector for the entity
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8068

`Static`LookAtRHToRef

LookAtRHToRef<T extends Matrix>(
    eye: DeepImmutable<Vector3>,
    target: DeepImmutable<Vector3>,
    up: DeepImmutable<Vector3>,
    result: T,
): T
Sets the given "result" Matrix to a matrix that transforms vertices from world space to camera space. It takes three vectors as arguments that together describe the position and orientation of the camera. This function generates a matrix suitable for a right handed coordinate system Example Playground - https://playground.babylonjs.com/#AV9X17#64 Example Playground - https://playground.babylonjs.com/#AV9X17#65
Type Parameters
- T extends Matrix
Parameters
- eye: DeepImmutable<Vector3>
  defines the final position of the entity
- target: DeepImmutable<Vector3>
  defines where the entity should look at
- up: DeepImmutable<Vector3>
  defines the up vector for the entity
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8085

`Static`LookDirectionLH

LookDirectionLH(
forward: DeepImmutable<Vector3>,
up: DeepImmutable<Vector3>,
): Matrix
Creates a new matrix that transforms vertices from world space to camera space. It takes two vectors as arguments that together describe the orientation of the camera. The position is assumed to be at the origin (0,0,0) This function generates a matrix suitable for a left handed coordinate system Example Playground - https://playground.babylonjs.com/#AV9X17#66
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 Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8125

`Static`LookDirectionLHToRef

LookDirectionLHToRef<T extends Matrix>(
    forward: DeepImmutable<Vector3>,
    up: DeepImmutable<Vector3>,
    result: T,
): T
Sets the given "result" Matrix to a matrix that transforms vertices from world space to camera space. It takes two vectors as arguments that together describe the orientation of the camera. The position is assumed to be at the origin (0,0,0) This function generates a matrix suitable for a left handed coordinate system Example Playground - https://playground.babylonjs.com/#AV9X17#67
Type Parameters
- T extends Matrix
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.
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8140

`Static`LookDirectionRH

LookDirectionRH(
forward: DeepImmutable<Vector3>,
up: DeepImmutable<Vector3>,
): Matrix
Creates a new matrix that transforms vertices from world space to camera space. It takes two vectors as arguments that together describe the orientation of the camera. The position is assumed to be at the origin (0,0,0) This function generates a matrix suitable for a right handed coordinate system Example Playground - https://playground.babylonjs.com/#AV9X17#68
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 Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8160

`Static`LookDirectionRHToRef

LookDirectionRHToRef<T extends Matrix>(
    forward: DeepImmutable<Vector3>,
    up: DeepImmutable<Vector3>,
    result: T,
): T
Sets the given "result" Matrix to a matrix that transforms vertices from world space to camera space. It takes two vectors as arguments that together describe the orientation of the camera. The position is assumed to be at the origin (0,0,0) This function generates a matrix suitable for a right handed coordinate system Example Playground - https://playground.babylonjs.com/#AV9X17#69
Type Parameters
- T extends Matrix
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.
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8175

`Static`ObliqueOffCenterLHToRef

ObliqueOffCenterLHToRef<T extends Matrix>(
    left: number,
    right: number,
    bottom: number,
    top: number,
    znear: number,
    zfar: number,
    length: number,
    angle: number,
    distance: number,
    result: T,
    halfZRange?: boolean,
): T
Stores a left-handed oblique projection into a given matrix
Type Parameters
- T extends Matrix
Parameters
- left: number
  defines the viewport left coordinate
- right: number
  defines the viewport right coordinate
- bottom: number
  defines the viewport bottom coordinate
- top: number
  defines the viewport top coordinate
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane
- length: number
  Length of the shear
- angle: number
  Angle (along X/Y Plane) to apply shear
- distance: number
  Distance from shear point
- result: T
  defines the target matrix
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8306

`Static`ObliqueOffCenterRHToRef

ObliqueOffCenterRHToRef<T extends Matrix>(
    left: number,
    right: number,
    bottom: number,
    top: number,
    znear: number,
    zfar: number,
    length: number,
    angle: number,
    distance: number,
    result: T,
    halfZRange?: boolean,
): T
Stores a right-handed oblique projection into a given matrix
Type Parameters
- T extends Matrix
Parameters
- left: number
  defines the viewport left coordinate
- right: number
  defines the viewport right coordinate
- bottom: number
  defines the viewport bottom coordinate
- top: number
  defines the viewport top coordinate
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane
- length: number
  Length of the shear
- angle: number
  Angle (along X/Y Plane) to apply shear
- distance: number
  Distance from shear point
- result: T
  defines the target matrix
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8395

`Static`OrthoLH

OrthoLH(
    width: number,
    height: number,
    znear: number,
    zfar: number,
    halfZRange?: boolean,
): Matrix
Create a left-handed orthographic projection matrix Example Playground - https://playground.babylonjs.com/#AV9X17#70
Parameters
- width: number
  defines the viewport width
- height: number
  defines the viewport height
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
Returns Matrix
a new matrix as a left-handed orthographic projection matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8194

`Static`OrthoLHToRef

OrthoLHToRef<T extends Matrix>(
    width: number,
    height: number,
    znear: number,
    zfar: number,
    result: T,
    halfZRange?: boolean,
): T
Store a left-handed orthographic projection to a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#71
Type Parameters
- T extends Matrix
Parameters
- width: number
  defines the viewport width
- height: number
  defines the viewport height
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane
- result: T
  defines the target matrix
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8211

`Static`OrthoOffCenterLH

OrthoOffCenterLH(
    left: number,
    right: number,
    bottom: number,
    top: number,
    znear: number,
    zfar: number,
    halfZRange?: boolean,
): Matrix
Create a left-handed orthographic projection matrix Example Playground - https://playground.babylonjs.com/#AV9X17#72
Parameters
- left: number
  defines the viewport left coordinate
- right: number
  defines the viewport right coordinate
- bottom: number
  defines the viewport bottom coordinate
- top: number
  defines the viewport top coordinate
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
Returns Matrix
a new matrix as a left-handed orthographic projection matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8242

`Static`OrthoOffCenterLHToRef

OrthoOffCenterLHToRef<T extends Matrix>(
    left: number,
    right: number,
    bottom: number,
    top: number,
    znear: number,
    zfar: number,
    result: T,
    halfZRange?: boolean,
): T
Stores a left-handed orthographic projection into a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#73
Type Parameters
- T extends Matrix
Parameters
- left: number
  defines the viewport left coordinate
- right: number
  defines the viewport right coordinate
- bottom: number
  defines the viewport bottom coordinate
- top: number
  defines the viewport top coordinate
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane
- result: T
  defines the target matrix
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8261

`Static`OrthoOffCenterRH

OrthoOffCenterRH(
    left: number,
    right: number,
    bottom: number,
    top: number,
    znear: number,
    zfar: number,
    halfZRange?: boolean,
): Matrix
Creates a right-handed orthographic projection matrix Example Playground - https://playground.babylonjs.com/#AV9X17#76
Parameters
- left: number
  defines the viewport left coordinate
- right: number
  defines the viewport right coordinate
- bottom: number
  defines the viewport bottom coordinate
- top: number
  defines the viewport top coordinate
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
Returns Matrix
a new matrix as a right-handed orthographic projection matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8346

`Static`OrthoOffCenterRHToRef

OrthoOffCenterRHToRef<T extends Matrix>(
    left: number,
    right: number,
    bottom: number,
    top: number,
    znear: number,
    zfar: number,
    result: T,
    halfZRange?: boolean,
): T
Stores a right-handed orthographic projection into a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#77
Type Parameters
- T extends Matrix
Parameters
- left: number
  defines the viewport left coordinate
- right: number
  defines the viewport right coordinate
- bottom: number
  defines the viewport bottom coordinate
- top: number
  defines the viewport top coordinate
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane
- result: T
  defines the target matrix
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8365

`Static`PerspectiveFovLH

PerspectiveFovLH(
    fov: number,
    aspect: number,
    znear: number,
    zfar: number,
    halfZRange?: boolean,
    projectionPlaneTilt?: number,
    reverseDepthBufferMode?: boolean,
): Matrix
Creates a left-handed perspective projection matrix Example Playground - https://playground.babylonjs.com/#AV9X17#78
Parameters
- fov: number
  defines the horizontal field of view
- aspect: number
  defines the aspect ratio
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane. If 0, assume we are in "infinite zfar" mode
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
- projectionPlaneTilt: number = 0
  optional tilt angle of the projection plane around the X axis (horizontal)
- reverseDepthBufferMode: boolean = false
  true to indicate that we are in a reverse depth buffer mode (meaning znear and zfar have been inverted when calling the function)
Returns Matrix
a new matrix as a left-handed perspective projection matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8468

`Static`PerspectiveFovLHToRef

PerspectiveFovLHToRef<T extends Matrix>(
    fov: number,
    aspect: number,
    znear: number,
    zfar: number,
    result: T,
    isVerticalFovFixed?: boolean,
    halfZRange?: boolean,
    projectionPlaneTilt?: number,
    reverseDepthBufferMode?: boolean,
): T
Stores a left-handed perspective projection into a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#81
Type Parameters
- T extends Matrix
Parameters
- fov: number
  defines the horizontal field of view
- aspect: number
  defines the aspect ratio
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane. If 0, assume we are in "infinite zfar" mode
- result: T
  defines the target matrix
- isVerticalFovFixed: boolean = true
  defines it the fov is vertically fixed (default) or horizontally
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
- projectionPlaneTilt: number = 0
  optional tilt angle of the projection plane around the X axis (horizontal)
- reverseDepthBufferMode: boolean = false
  true to indicate that we are in a reverse depth buffer mode (meaning znear and zfar have been inverted when calling the function)
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8496

`Static`PerspectiveFovReverseLHToRef

PerspectiveFovReverseLHToRef<T extends Matrix>(
    fov: number,
    aspect: number,
    znear: number,
    zfar: number,
    result: T,
    isVerticalFovFixed?: boolean,
    halfZRange?: boolean,
    projectionPlaneTilt?: number,
): T
Stores a left-handed perspective projection into a given matrix with depth reversed Example Playground - https://playground.babylonjs.com/#AV9X17#89
Type Parameters
- T extends Matrix
Parameters
- fov: number
  defines the horizontal field of view
- aspect: number
  defines the aspect ratio
- znear: number
  defines the near clip plane
- zfar: number
  not used as infinity is used as far clip
- result: T
  defines the target matrix
- isVerticalFovFixed: boolean = true
  defines it the fov is vertically fixed (default) or horizontally
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
- projectionPlaneTilt: number = 0
  optional tilt angle of the projection plane around the X axis (horizontal)
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8540

`Static`PerspectiveFovReverseRHToRef

PerspectiveFovReverseRHToRef<T extends Matrix>(
    fov: number,
    aspect: number,
    znear: number,
    zfar: number,
    result: T,
    isVerticalFovFixed?: boolean,
    halfZRange?: boolean,
    projectionPlaneTilt?: number,
): T
Stores a right-handed perspective projection into a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#90
Type Parameters
- T extends Matrix
Parameters
- fov: number
  defines the horizontal field of view
- aspect: number
  defines the aspect ratio
- znear: number
  defines the near clip plane
- zfar: number
  not used as infinity is used as far clip
- result: T
  defines the target matrix
- isVerticalFovFixed: boolean = true
  defines it the fov is vertically fixed (default) or horizontally
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
- projectionPlaneTilt: number = 0
  optional tilt angle of the projection plane around the X axis (horizontal)
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8652

`Static`PerspectiveFovRH

PerspectiveFovRH(
    fov: number,
    aspect: number,
    znear: number,
    zfar: number,
    halfZRange?: boolean,
    projectionPlaneTilt?: number,
    reverseDepthBufferMode?: boolean,
): Matrix
Creates a right-handed perspective projection matrix Example Playground - https://playground.babylonjs.com/#AV9X17#83
Parameters
- fov: number
  defines the horizontal field of view
- aspect: number
  defines the aspect ratio
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane. If 0, assume we are in "infinite zfar" mode
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
- projectionPlaneTilt: number = 0
  optional tilt angle of the projection plane around the X axis (horizontal)
- reverseDepthBufferMode: boolean = false
  true to indicate that we are in a reverse depth buffer mode (meaning znear and zfar have been inverted when calling the function)
Returns Matrix
a new matrix as a right-handed perspective projection matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8575

`Static`PerspectiveFovRHToRef

PerspectiveFovRHToRef<T extends Matrix>(
    fov: number,
    aspect: number,
    znear: number,
    zfar: number,
    result: T,
    isVerticalFovFixed?: boolean,
    halfZRange?: boolean,
    projectionPlaneTilt?: number,
    reverseDepthBufferMode?: boolean,
): T
Stores a right-handed perspective projection into a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#84
Type Parameters
- T extends Matrix
Parameters
- fov: number
  defines the horizontal field of view
- aspect: number
  defines the aspect ratio
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane. If 0, assume we are in "infinite zfar" mode
- result: T
  defines the target matrix
- isVerticalFovFixed: boolean = true
  defines it the fov is vertically fixed (default) or horizontally
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
- projectionPlaneTilt: number = 0
  optional tilt angle of the projection plane around the X axis (horizontal)
- reverseDepthBufferMode: boolean = false
  true to indicate that we are in a reverse depth buffer mode (meaning znear and zfar have been inverted when calling the function)
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8603

`Static`PerspectiveLH

PerspectiveLH(
    width: number,
    height: number,
    znear: number,
    zfar: number,
    halfZRange?: boolean,
    projectionPlaneTilt?: number,
): Matrix
Creates a left-handed perspective projection matrix Example Playground - https://playground.babylonjs.com/#AV9X17#85
Parameters
- width: number
  defines the viewport width
- height: number
  defines the viewport height
- znear: number
  defines the near clip plane
- zfar: number
  defines the far clip plane
- OptionalhalfZRange: boolean
  true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
- projectionPlaneTilt: number = 0
  optional tilt angle of the projection plane around the X axis (horizontal)
Returns Matrix
a new matrix as a left-handed perspective projection matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8434

`Static`Reflection

Reflection(plane: DeepImmutable<IPlaneLike>): Matrix
Computes a reflection matrix from a plane Example Playground - https://playground.babylonjs.com/#AV9X17#87
Parameters
- plane: DeepImmutable<IPlaneLike>
  defines the reflection plane
Returns Matrix
a new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8801

`Static`ReflectionToRef

ReflectionToRef<T extends Matrix>(
plane: DeepImmutable<IPlaneLike>,
result: T,
): T
Computes a reflection matrix from a plane Example Playground - https://playground.babylonjs.com/#AV9X17#88
Type Parameters
- T extends Matrix
Parameters
- plane: DeepImmutable<IPlaneLike>
  defines the reflection plane
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8814

`Static`RotationAlignToRef

RotationAlignToRef<T extends Matrix>(
    from: DeepImmutable<Vector3>,
    to: DeepImmutable<Vector3>,
    result: T,
    useYAxisForCoplanar?: boolean,
): T
Takes normalised vectors and returns a rotation matrix to align "from" with "to". Taken from http://www.iquilezles.org/www/articles/noacos/noacos.htm Example Playground - https://playground.babylonjs.com/#AV9X17#93
Type Parameters
- T extends Matrix
Parameters
- from: DeepImmutable<Vector3>
  defines the vector to align
- to: DeepImmutable<Vector3>
  defines the vector to align to
- result: T
  defines the target matrix
- useYAxisForCoplanar: boolean = false
  defines a boolean indicating that we should favor Y axis for coplanar vectors (default is false)
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7779

`Static`RotationAxis

RotationAxis(axis: DeepImmutable<Vector3>, angle: number): Matrix
Creates a new rotation matrix for "angle" radians around the given axis Example Playground - https://playground.babylonjs.com/#AV9X17#96
Parameters
- axis: DeepImmutable<Vector3>
  defines the axis to use
- angle: number
  defines the angle (in radians) to use
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7724

`Static`RotationAxisToRef

RotationAxisToRef<T extends Matrix>(
    axis: DeepImmutable<Vector3>,
    angle: number,
    result: T,
): T
Creates a new rotation matrix for "angle" radians around the given axis and stores it in a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#94
Type Parameters
- T extends Matrix
Parameters
- axis: DeepImmutable<Vector3>
  defines the axis to use
- angle: number
  defines the angle (in radians) to use
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7738

`Static`RotationX

RotationX(angle: number): Matrix
Creates a new rotation matrix for "angle" radians around the X axis Example Playground - https://playground.babylonjs.com/#AV9X17#97
Parameters
- angle: number
  defines the angle (in radians) to use
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7627

`Static`RotationXToRef

RotationXToRef<T extends Matrix>(angle: number, result: T): T
Creates a new rotation matrix for "angle" radians around the X axis and stores it in a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#98
Type Parameters
- T extends Matrix
Parameters
- angle: number
  defines the angle (in radians) to use
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7652

`Static`RotationY

RotationY(angle: number): Matrix
Creates a new rotation matrix for "angle" radians around the Y axis Example Playground - https://playground.babylonjs.com/#AV9X17#99
Parameters
- angle: number
  defines the angle (in radians) to use
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7667

`Static`RotationYawPitchRoll

RotationYawPitchRoll(yaw: number, pitch: number, roll: number): Matrix
Creates a rotation matrix Example Playground - https://playground.babylonjs.com/#AV9X17#103 Example Playground - https://playground.babylonjs.com/#AV9X17#105
Parameters
- yaw: number
  defines the yaw angle in radians (Y axis)
- pitch: number
  defines the pitch angle in radians (X axis)
- roll: number
  defines the roll angle in radians (Z axis)
Returns Matrix
the new rotation matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7831

`Static`RotationYawPitchRollToRef

RotationYawPitchRollToRef<T extends Matrix>(
    yaw: number,
    pitch: number,
    roll: number,
    result: T,
): T
Creates a rotation matrix and stores it in a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#104
Type Parameters
- T extends Matrix
Parameters
- yaw: number
  defines the yaw angle in radians (Y axis)
- pitch: number
  defines the pitch angle in radians (X axis)
- roll: number
  defines the roll angle in radians (Z axis)
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7846

`Static`RotationYToRef

RotationYToRef<T extends Matrix>(angle: number, result: T): T
Creates a new rotation matrix for "angle" radians around the Y axis and stores it in a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#100
Type Parameters
- T extends Matrix
Parameters
- angle: number
  defines the angle (in radians) to use
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7680

`Static`RotationZ

RotationZ(angle: number): Matrix
Creates a new rotation matrix for "angle" radians around the Z axis Example Playground - https://playground.babylonjs.com/#AV9X17#101
Parameters
- angle: number
  defines the angle (in radians) to use
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7695

`Static`RotationZToRef

RotationZToRef<T extends Matrix>(angle: number, result: T): T
Creates a new rotation matrix for "angle" radians around the Z axis and stores it in a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#102
Type Parameters
- T extends Matrix
Parameters
- angle: number
  defines the angle (in radians) to use
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7708

`Static`Scaling

Scaling(x: number, y: number, z: number): Matrix
Creates a scaling matrix Example Playground - https://playground.babylonjs.com/#AV9X17#107
Parameters
- x: number
  defines the scale factor on X axis
- y: number
  defines the scale factor on Y axis
- z: number
  defines the scale factor on Z axis
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7860

`Static`ScalingToRef

ScalingToRef<T extends Matrix>(x: number, y: number, z: number, result: T): T
Creates a scaling matrix and stores it in a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#108
Type Parameters
- T extends Matrix
Parameters
- x: number
  defines the scale factor on X axis
- y: number
  defines the scale factor on Y axis
- z: number
  defines the scale factor on Z axis
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7875

`Static`Translation

Translation(x: number, y: number, z: number): Matrix
Creates a translation matrix Example Playground - https://playground.babylonjs.com/#AV9X17#109
Parameters
- x: number
  defines the translation on X axis
- y: number
  defines the translation on Y axis
- z: number
  defines the translationon Z axis
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7890

`Static`TranslationToRef

TranslationToRef<T extends Matrix>(
    x: number,
    y: number,
    z: number,
    result: T,
): T
Creates a translation matrix and stores it in a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#110
Type Parameters
- T extends Matrix
Parameters
- x: number
  defines the translation on X axis
- y: number
  defines the translation on Y axis
- z: number
  defines the translationon Z axis
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7905

`Static`Transpose

Transpose(matrix: DeepImmutable<Matrix>): Matrix
Compute the transpose of a given matrix Example Playground - https://playground.babylonjs.com/#AV9X17#111
Parameters
- matrix: DeepImmutable<Matrix>
  defines the matrix to transpose
Returns Matrix
the new matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8736

`Static`TransposeToRef

TransposeToRef<T extends Matrix>(matrix: DeepImmutable<Matrix>, result: T): T
Compute the transpose of a matrix and store it in a target matrix Example Playground - https://playground.babylonjs.com/#AV9X17#112
Type Parameters
- T extends Matrix
Parameters
- matrix: DeepImmutable<Matrix>
  defines the matrix to transpose
- result: T
  defines the target matrix
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:8749

`Static`Zero

Zero(): Matrix
Creates a new zero matrix

Returns Matrix
a new zero matrix
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:7615

Class Matrix

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Returns Matrix

Properties

Readonlydimension

See

Readonlyrank

See

updateFlag

Accessors

m

Returns DeepImmutableArray<number>

StaticIdentityReadOnly

Returns DeepImmutable<Matrix>

StaticUse64Bits

Returns boolean

Methods

add

Parameters

Returns Matrix

addAtIndex

Parameters

Returns this

addInPlace

Parameters

Returns this

addInPlaceFromFloats

Parameters

Returns this

addToRef

Type Parameters

Parameters

Returns T

addToSelf

Parameters

Returns this

addTranslationFromFloats

Parameters

Returns this

asArray

Returns [ number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number,]

clone

Returns Matrix

copyFrom

Parameters

Returns this

copyFromFloats

Parameters

Returns this

copyToArray

Parameters

Returns this

decompose

Parameters

Returns boolean

decomposeToTransformNode

Parameters

Returns boolean

determinant

Returns number

divide

Parameters

Returns Matrix

divideInPlace

Parameters

Returns this

divideToRef

Type Parameters

Parameters

Returns T

equals

Parameters

Returns boolean

`Readonly`dimension

`Readonly`rank

`Static`IdentityReadOnly

`Static`Use64Bits

Returns [
number,
number,
number,
number,
number,
number,
number,
number,
number,
number,
number,
number,
number,
number,
number,
number,
]