Class Vector3

Class used to store (x,y,z) vector representation A Vector3 is the main object used in 3D geometry It can represent either the coordinates of a point the space, either a direction Reminder: js uses a left handed forward facing system Example Playground - Overview - https://playground.babylonjs.com/#R1F8YU

Hierarchy

Vector3

Index

Constructors

constructor

new Vector3(x?: number, y?: number, z?: number): Vector3
Creates a new Vector3 object from the given x, y, z (floats) coordinates.
Parameters
- Optional x: number
  
  defines the first coordinates (on X axis)
- Optional y: number
  
  defines the second coordinates (on Y axis)
- Optional z: number
  
  defines the third coordinates (on Z axis)
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:556

Accessors

hasAZeroComponent

get hasAZeroComponent(): boolean
Gets a boolean indicating if the vector contains a zero in one of its components Example Playground https://playground.babylonjs.com/#R1F8YU#1

Returns boolean
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:921

isNonUniform

get isNonUniform(): boolean
Gets a boolean indicating that the vector is non uniform meaning x, y or z are not all the same

Returns boolean
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:892

x

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

Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:542
set x(value: number): void
Parameters
- value: number
Returns void
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:543

y

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

Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:545
set y(value: number): void
Parameters
- value: number
Returns void
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:546

z

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

Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:548
set z(value: number): void
Parameters
- value: number
Returns void
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:549

`Static` DownReadOnly

get DownReadOnly(): DeepImmutableObject<Vector3>
Gets a down Vector3 that must not be updated

Returns DeepImmutableObject<Vector3>
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1153

`Static` LeftHandedBackwardReadOnly

get LeftHandedBackwardReadOnly(): DeepImmutableObject<Vector3>
Gets a backward Vector3 that must not be updated

Returns DeepImmutableObject<Vector3>
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1173

`Static` LeftHandedForwardReadOnly

get LeftHandedForwardReadOnly(): DeepImmutableObject<Vector3>
Gets a forward Vector3 that must not be updated

Returns DeepImmutableObject<Vector3>
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1165

`Static` LeftReadOnly

get LeftReadOnly(): DeepImmutableObject<Vector3>
Gets a left Vector3 that must not be updated

Returns DeepImmutableObject<Vector3>
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1161

`Static` OneReadOnly

get OneReadOnly(): DeepImmutableObject<Vector3>
Gets a one Vector3 that must not be updated

Returns DeepImmutableObject<Vector3>
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1185

`Static` RightHandedBackwardReadOnly

get RightHandedBackwardReadOnly(): DeepImmutableObject<Vector3>
Gets a backward Vector3 that must not be updated

Returns DeepImmutableObject<Vector3>
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1177

`Static` RightHandedForwardReadOnly

get RightHandedForwardReadOnly(): DeepImmutableObject<Vector3>
Gets a forward Vector3 that must not be updated

Returns DeepImmutableObject<Vector3>
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1169

`Static` RightReadOnly

get RightReadOnly(): DeepImmutableObject<Vector3>
Gets a right Vector3 that must not be updated

Returns DeepImmutableObject<Vector3>
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1157

`Static` UpReadOnly

get UpReadOnly(): DeepImmutableObject<Vector3>
Gets an up Vector3 that must not be updated

Returns DeepImmutableObject<Vector3>
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1149

`Static` ZeroReadOnly

get ZeroReadOnly(): DeepImmutableObject<Vector3>
Gets a zero Vector3 that must not be updated

Returns DeepImmutableObject<Vector3>
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1181

Methods

add

add(otherVector: DeepImmutableObject<Vector3>): Vector3
Gets a new Vector3, result of the addition the current Vector3 and the given vector Example Playground https://playground.babylonjs.com/#R1F8YU#3

Returns
the resulting Vector3
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:623

addInPlace

addInPlace(otherVector: DeepImmutableObject<Vector3>): Vector3
Adds the given vector to the current Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#4

Returns
the current updated Vector3
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:607

addInPlaceFromFloats

addInPlaceFromFloats(x: number, y: number, z: number): Vector3
Adds the given coordinates to the current Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#5

Returns
the current updated Vector3
Parameters
- x: number
  
  defines the x coordinate of the operand
- y: number
  
  defines the y coordinate of the operand
- z: number
  
  defines the z coordinate of the operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:616

addToRef

addToRef<T>(otherVector: DeepImmutableObject<Vector3>, result: T): T
Adds the current Vector3 to the given one and stores the result in the vector "result" Example Playground https://playground.babylonjs.com/#R1F8YU#6

Returns
the result
Type Parameters
- T extends Vector3<T>
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
- result: T
  
  defines the Vector3 object where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:631

applyRotationQuaternion

applyRotationQuaternion(q: Quaternion): Vector3
Rotates the vector using the given unit quaternion and returns the new vector Example Playground https://playground.babylonjs.com/#R1F8YU#7

Returns
a new Vector3
Parameters
- q: Quaternion
  
  the unit quaternion representing the rotation
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:747

applyRotationQuaternionInPlace

applyRotationQuaternionInPlace(q: Quaternion): Vector3
Rotates the vector in place using the given unit quaternion Example Playground https://playground.babylonjs.com/#R1F8YU#8

Returns
the current updated Vector3
Parameters
- q: Quaternion
  
  the unit quaternion representing the rotation
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:740

applyRotationQuaternionToRef

applyRotationQuaternionToRef<T>(q: Quaternion, result: T): T
Rotates the vector using the given unit quaternion and stores the new vector in result Example Playground https://playground.babylonjs.com/#R1F8YU#9

Returns
the result
Type Parameters
- T extends Vector3<T>
Parameters
- q: Quaternion
  
  the unit quaternion representing the rotation
- result: T
  
  the output vector
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:733

asArray

asArray(): number[]
Creates an array containing three elements : the coordinates of the Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#10

Returns
a new array of numbers

Returns number[]
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:578

clone

clone(): Vector3
Creates a new Vector3 copied from the current Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#11

Returns
the new Vector3

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:987

copyFrom

copyFrom(source: DeepImmutableObject<Vector3>): Vector3
Copies the given vector coordinates to the current Vector3 ones Example Playground https://playground.babylonjs.com/#R1F8YU#12

Returns
the current updated Vector3
Parameters
- source: DeepImmutableObject<Vector3>
  
  defines the source Vector3
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:994

copyFromFloats

copyFromFloats(x: number, y: number, z: number): Vector3
Copies the given floats to the current Vector3 coordinates Example Playground https://playground.babylonjs.com/#R1F8YU#13

Returns
the current updated Vector3
Parameters
- x: number
  
  defines the x coordinate of the operand
- y: number
  
  defines the y coordinate of the operand
- z: number
  
  defines the z coordinate of the operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1003

cross

cross(other: Vector3): Vector3
Returns a new Vector3 as the cross product of the current vector and the "other" one The cross product is then orthogonal to both current and "other" Example Playground https://playground.babylonjs.com/#R1F8YU#14

Returns
the cross product
Parameters
- other: Vector3
  
  defines the right operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:960

divide

divide(otherVector: DeepImmutableObject<Vector3>): Vector3
Returns a new Vector3 set with the result of the division of the current Vector3 coordinates by the given ones Example Playground https://playground.babylonjs.com/#R1F8YU#16

Returns
the new Vector3
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:834

divideInPlace

divideInPlace(otherVector: Vector3): Vector3
Divides the current Vector3 coordinates by the given ones. Example Playground https://playground.babylonjs.com/#R1F8YU#17

Returns
the current updated Vector3
Parameters
- otherVector: Vector3
  
  defines the second operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:849

divideToRef

divideToRef<T>(otherVector: DeepImmutableObject<Vector3>, result: T): T
Divides the current Vector3 coordinates by the given ones and stores the result in the given vector "result" Example Playground https://playground.babylonjs.com/#R1F8YU#18

Returns
the result
Type Parameters
- T extends Vector3<T>
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
- result: T
  
  defines the Vector3 object where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:842

equals

equals(otherVector: DeepImmutableObject<Vector3>): boolean
Returns true if the current Vector3 and the given vector coordinates are strictly equal Example Playground https://playground.babylonjs.com/#R1F8YU#19

Returns
true if both vectors are equals
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns boolean
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:779

equalsToFloats

equalsToFloats(x: number, y: number, z: number): boolean
Returns true if the current Vector3 coordinates equals the given floats Example Playground https://playground.babylonjs.com/#R1F8YU#20

Returns
true if both vectors are equal
Parameters
- x: number
  
  defines the x coordinate of the operand
- y: number
  
  defines the y coordinate of the operand
- z: number
  
  defines the z coordinate of the operand
Returns boolean
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:796

equalsWithEpsilon

equalsWithEpsilon(otherVector: DeepImmutableObject<Vector3>, epsilon?: number): boolean
Returns true if the current Vector3 and the given vector coordinates are distant less than epsilon Example Playground https://playground.babylonjs.com/#R1F8YU#21

Returns
true if both vectors are distant less than epsilon
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
- Optional epsilon: number
  
  defines the minimal distance to define values as equals
Returns boolean
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:787

floor

floor(): Vector3
Gets a new Vector3 from current Vector3 floored values Example Playground https://playground.babylonjs.com/#R1F8YU#22

Returns
a new Vector3

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:898

fract

fract(): Vector3
Gets a new Vector3 from current Vector3 fractional values Example Playground https://playground.babylonjs.com/#R1F8YU#23

Returns
a new Vector3

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:904

fromArray

fromArray(array: FloatArray, index?: number): Vector3
Update the current vector from an array Example Playground https://playground.babylonjs.com/#R1F8YU#24

Returns
the current Vector3
Parameters
- array: FloatArray
  
  defines the destination array
- Optional index: number
  
  defines the offset in the destination array
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:594

getClassName

getClassName(): string
Gets the class name

Returns
the string "Vector3"

Returns string
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:567

getHashCode

getHashCode(): number
Creates the Vector3 hash code

Returns
a number which tends to be unique between Vector3 instances

Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:572

getNormalToRef

getNormalToRef(result: DeepImmutableObject<Vector3>): Vector3
Creates a vector normal (perpendicular) to the current Vector3 and stores the result in the given vector Out of the infinite possibilities the normal chosen is the one formed by rotating the current vector 90 degrees about an axis which lies perpendicular to the current vector and its projection on the xz plane. In the case of a current vector in the xz plane the normal is calculated to be along the y axis. Example Playground https://playground.babylonjs.com/#R1F8YU#230 Example Playground https://playground.babylonjs.com/#R1F8YU#231
Parameters
- result: DeepImmutableObject<Vector3>
  
  defines the Vector3 object where to store the resultant normal returns the result
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:725

isNonUniformWithinEpsilon

isNonUniformWithinEpsilon(epsilon: number): boolean
Due to float precision, scale of a mesh could be uniform but float values are off by a small fraction Check if is non uniform within a certain amount of decimal places to account for this

Returns
if the the vector is non uniform to a certain number of decimal places
Parameters
- epsilon: number
  
  the amount the values can differ
Returns boolean
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:888

length

length(): number
Gets the length of the Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#25

Returns
the length of the Vector3

Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:910

lengthSquared

lengthSquared(): number
Gets the squared length of the Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#26

Returns
squared length of the Vector3

Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:916

maximizeInPlace

maximizeInPlace(other: DeepImmutableObject<Vector3>): Vector3
Updates the current Vector3 with the maximal coordinate values between its and the given vector ones. Example Playground https://playground.babylonjs.com/#R1F8YU#27

Returns
the current updated Vector3
Parameters
- other: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:863

maximizeInPlaceFromFloats

maximizeInPlaceFromFloats(x: number, y: number, z: number): Vector3
Updates the current Vector3 with the maximal coordinate values between its and the given coordinates. Example Playground https://playground.babylonjs.com/#R1F8YU#28

Returns
the current updated Vector3
Parameters
- x: number
  
  defines the x coordinate of the operand
- y: number
  
  defines the y coordinate of the operand
- z: number
  
  defines the z coordinate of the operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:881

minimizeInPlace

minimizeInPlace(other: DeepImmutableObject<Vector3>): Vector3
Updates the current Vector3 with the minimal coordinate values between its and the given vector ones Example Playground https://playground.babylonjs.com/#R1F8YU#29

Returns
the current updated Vector3
Parameters
- other: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:856

minimizeInPlaceFromFloats

minimizeInPlaceFromFloats(x: number, y: number, z: number): Vector3
Updates the current Vector3 with the minimal coordinate values between its and the given coordinates Example Playground https://playground.babylonjs.com/#R1F8YU#30

Returns
the current updated Vector3
Parameters
- x: number
  
  defines the x coordinate of the operand
- y: number
  
  defines the y coordinate of the operand
- z: number
  
  defines the z coordinate of the operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:872

multiply

multiply(otherVector: DeepImmutableObject<Vector3>): Vector3
Returns a new Vector3, result of the multiplication of the current Vector3 by the given vector Example Playground https://playground.babylonjs.com/#R1F8YU#31

Returns
the new Vector3
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:810

multiplyByFloats

multiplyByFloats(x: number, y: number, z: number): Vector3
Returns a new Vector3 set with the result of the multiplication of the current Vector3 coordinates by the given floats Example Playground https://playground.babylonjs.com/#R1F8YU#34

Returns
the new Vector3
Parameters
- x: number
  
  defines the x coordinate of the operand
- y: number
  
  defines the y coordinate of the operand
- z: number
  
  defines the z coordinate of the operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:827

multiplyInPlace

multiplyInPlace(otherVector: DeepImmutableObject<Vector3>): Vector3
Multiplies the current Vector3 coordinates by the given ones Example Playground https://playground.babylonjs.com/#R1F8YU#32

Returns
the current updated Vector3
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:803

multiplyToRef

multiplyToRef<T>(otherVector: DeepImmutableObject<Vector3>, result: T): T
Multiplies the current Vector3 by the given one and stores the result in the given vector "result" Example Playground https://playground.babylonjs.com/#R1F8YU#33

Returns
the result
Type Parameters
- T extends Vector3<T>
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
- result: T
  
  defines the Vector3 object where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:818

negate

negate(): Vector3
Gets a new Vector3 set with the current Vector3 negated coordinates Example Playground https://playground.babylonjs.com/#R1F8YU#35

Returns
a new Vector3

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:678

negateInPlace

negateInPlace(): Vector3
Negate this vector in place Example Playground https://playground.babylonjs.com/#R1F8YU#36

Returns
this

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:684

negateToRef

negateToRef<T>(result: T): T
Negate the current Vector3 and stores the result in the given vector "result" coordinates Example Playground https://playground.babylonjs.com/#R1F8YU#37

Returns
the result
Type Parameters
- T extends Vector3<T> = Vector3
Parameters
- result: T
  
  defines the Vector3 object where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:691

normalize

normalize(): Vector3
Normalize the current Vector3. Please note that this is an in place operation. Example Playground https://playground.babylonjs.com/#R1F8YU#122

Returns
the current updated Vector3

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:928

normalizeFromLength

normalizeFromLength(len: number): Vector3
Normalize the current Vector3 with the given input length. Please note that this is an in place operation. Example Playground https://playground.babylonjs.com/#R1F8YU#123

Returns
the current updated Vector3
Parameters
- len: number
  
  the length of the vector
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:968

normalizeToNew

normalizeToNew(): Vector3
Normalize the current Vector3 to a new vector Example Playground https://playground.babylonjs.com/#R1F8YU#124

Returns
the new Vector3

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:974

normalizeToRef

normalizeToRef<T>(reference: T): T
Normalize the current Vector3 to the reference Example Playground https://playground.babylonjs.com/#R1F8YU#125

Returns
the updated Vector3
Type Parameters
- T extends Vector3<T>
Parameters
- reference: T
  
  define the Vector3 to update
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:981

projectOnPlane

projectOnPlane<T>(plane: Plane, origin: Vector3): T
Projects the current point Vector3 to a plane along a ray starting from a specified origin and passing through the current point Vector3. Example Playground https://playground.babylonjs.com/#R1F8YU#48

Returns
the projected vector3
Type Parameters
- T extends Vector3<T>
Parameters
- plane: Plane
  
  defines the plane to project to
- origin: Vector3
  
  defines the origin of the projection ray
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:763

projectOnPlaneToRef

projectOnPlaneToRef<T>(plane: Plane, origin: Vector3, result: T): T
Projects the current point Vector3 to a plane along a ray starting from a specified origin and passing through the current point Vector3. Example Playground https://playground.babylonjs.com/#R1F8YU#49

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- plane: Plane
  
  defines the plane to project to
- origin: Vector3
  
  defines the origin of the projection ray
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:772

reorderInPlace

reorderInPlace(order: string): Vector3
Reorders the x y z properties of the vector in place Example Playground https://playground.babylonjs.com/#R1F8YU#44

Returns
the current updated vector
Parameters
- order: string
  
  new ordering of the properties (eg. for vector 1,2,3 with "ZYX" will produce 3,2,1)
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:935

rotateByQuaternionAroundPointToRef

rotateByQuaternionAroundPointToRef<T>(quaternion: Quaternion, point: Vector3, result: T): T
Rotates a vector around a given point Example Playground https://playground.babylonjs.com/#R1F8YU#46

Returns
the resulting vector
Type Parameters
- T extends Vector3<T>
Parameters
- quaternion: Quaternion
  
  the rotation quaternion
- point: Vector3
  
  the point to rotate around
- result: T
  
  vector to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:952

rotateByQuaternionToRef

rotateByQuaternionToRef<T>(quaternion: Quaternion, result: T): T
Rotates the vector around 0,0,0 by a quaternion Example Playground https://playground.babylonjs.com/#R1F8YU#47

Returns
the resulting vector
Type Parameters
- T extends Vector3<T>
Parameters
- quaternion: Quaternion
  
  the rotation quaternion
- result: T
  
  vector to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:943

scale

scale(scale: number): Vector3
Returns a new Vector3 set with the current Vector3 coordinates multiplied by the float "scale" Example Playground https://playground.babylonjs.com/#R1F8YU#53

Returns
a new Vector3
Parameters
- scale: number
  
  defines the multiplier factor
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:705

scaleAndAddToRef

scaleAndAddToRef<T>(scale: number, result: T): T
Scale the current Vector3 values by a factor and add the result to a given Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#55

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- scale: number
  
  defines the scale factor
- result: T
  
  defines the Vector3 object where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:755

scaleInPlace

scaleInPlace(scale: number): Vector3
Multiplies the Vector3 coordinates by the float "scale" Example Playground https://playground.babylonjs.com/#R1F8YU#56

Returns
the current updated Vector3
Parameters
- scale: number
  
  defines the multiplier factor
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:698

scaleToRef

scaleToRef<T>(scale: number, result: T): T
Multiplies the current Vector3 coordinates by the float "scale" and stores the result in the given vector "result" coordinates Example Playground https://playground.babylonjs.com/#R1F8YU#57

Returns
the result
Type Parameters
- T extends Vector3<T>
Parameters
- scale: number
  
  defines the multiplier factor
- result: T
  
  defines the Vector3 object where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:713

set

set(x: number, y: number, z: number): Vector3
Copies the given floats to the current Vector3 coordinates Example Playground https://playground.babylonjs.com/#R1F8YU#58

Returns
the current updated Vector3
Parameters
- x: number
  
  defines the x coordinate of the operand
- y: number
  
  defines the y coordinate of the operand
- z: number
  
  defines the z coordinate of the operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1012

setAll

setAll(v: number): Vector3
Copies the given float to the current Vector3 coordinates Example Playground https://playground.babylonjs.com/#R1F8YU#59

Returns
the current updated Vector3
Parameters
- v: number
  
  defines the x, y and z coordinates of the operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1019

subtract

subtract(otherVector: DeepImmutableObject<Vector3>): Vector3
Returns a new Vector3, result of the subtraction of the given vector from the current Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#60

Returns
the resulting Vector3
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:645

subtractFromFloats

subtractFromFloats(x: number, y: number, z: number): Vector3
Returns a new Vector3 set with the subtraction of the given floats from the current Vector3 coordinates Example Playground https://playground.babylonjs.com/#R1F8YU#62

Returns
the resulting Vector3
Parameters
- x: number
  
  defines the x coordinate of the operand
- y: number
  
  defines the y coordinate of the operand
- z: number
  
  defines the z coordinate of the operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:662

subtractFromFloatsToRef

subtractFromFloatsToRef<T>(x: number, y: number, z: number, result: T): T
Subtracts the given floats from the current Vector3 coordinates and set the given vector "result" with this result Example Playground https://playground.babylonjs.com/#R1F8YU#64

Returns
the result
Type Parameters
- T extends Vector3<T>
Parameters
- x: number
  
  defines the x coordinate of the operand
- y: number
  
  defines the y coordinate of the operand
- z: number
  
  defines the z coordinate of the operand
- result: T
  
  defines the Vector3 object where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:672

subtractInPlace

subtractInPlace(otherVector: DeepImmutableObject<Vector3>): Vector3
Subtract the given vector from the current Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#61

Returns
the current updated Vector3
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:638

subtractToRef

subtractToRef<T>(otherVector: DeepImmutableObject<Vector3>, result: T): T
Subtracts the given vector from the current Vector3 and stores the result in the vector "result". Example Playground https://playground.babylonjs.com/#R1F8YU#63

Returns
the result
Type Parameters
- T extends Vector3<T>
Parameters
- otherVector: DeepImmutableObject<Vector3>
  
  defines the second operand
- result: T
  
  defines the Vector3 object where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:653

toArray

toArray(array: FloatArray, index?: number): Vector3
Populates the given array or Float32Array from the given index with the successive coordinates of the Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#65

Returns
the current Vector3
Parameters
- array: FloatArray
  
  defines the destination array
- Optional index: number
  
  defines the offset in the destination array
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:586

toQuaternion

toQuaternion(): Quaternion
Converts the current Vector3 into a quaternion (considering that the Vector3 contains Euler angles representation of a rotation) Example Playground https://playground.babylonjs.com/#R1F8YU#66

Returns
a new Quaternion object, computed from the Vector3 coordinates

Returns Quaternion
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:600

toString

toString(): string
Creates a string representation of the Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#67

Returns
a string with the Vector3 coordinates.

Returns string
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:562

`Static` Backward

Backward(rightHandedSystem?: boolean): Vector3
Returns a new Vector3 set to (0.0, 0.0, -1.0) Example Playground https://playground.babylonjs.com/#R1F8YU#71

Returns
a new Backward Vector3
Parameters
- Optional rightHandedSystem: boolean
  
  is the scene right-handed (negative-z)
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1205

`Static` CatmullRom

CatmullRom<T>(value1: DeepImmutable<T>, value2: DeepImmutableObject<Vector3>, value3: DeepImmutableObject<Vector3>, value4: DeepImmutableObject<Vector3>, amount: number): T
Returns a new Vector3 located for "amount" on the CatmullRom interpolation spline defined by the vectors "value1", "value2", "value3", "value4" Example Playground https://playground.babylonjs.com/#R1F8YU#69

Returns
the new Vector3
Type Parameters
- T extends Vector3<T>
Parameters
- value1: DeepImmutable<T>
  
  defines the first control point
- value2: DeepImmutableObject<Vector3>
  
  defines the second control point
- value3: DeepImmutableObject<Vector3>
  
  defines the third control point
- value4: DeepImmutableObject<Vector3>
  
  defines the fourth control point
- amount: number
  
  defines the amount on the spline to use
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1297

`Static` Center

Center(value1: DeepImmutableObject<Vector3>, value2: DeepImmutableObject<Vector3>): Vector3
Returns a new Vector3 located at the center between "value1" and "value2" Example Playground https://playground.babylonjs.com/#R1F8YU#72

Returns
the new Vector3
Parameters
- value1: DeepImmutableObject<Vector3>
  
  defines the first operand
- value2: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1568

`Static` CenterToRef

CenterToRef<T>(value1: DeepImmutableObject<Vector3>, value2: DeepImmutableObject<Vector3>, ref: T): T
Gets the center of the vectors "value1" and "value2" and stores the result in the vector "ref" Example Playground https://playground.babylonjs.com/#R1F8YU#73

Returns
ref
Type Parameters
- T extends Vector3<T>
Parameters
- value1: DeepImmutableObject<Vector3>
  
  defines first vector
- value2: DeepImmutableObject<Vector3>
  
  defines second vector
- ref: T
  
  defines third vector
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1577

`Static` CheckExtends

CheckExtends(v: Vector3, min: Vector3, max: Vector3): void
Checks if a given vector is inside a specific range Example Playground https://playground.babylonjs.com/#R1F8YU#75
Parameters
- v: Vector3
  
  defines the vector to test
- min: Vector3
  
  defines the minimum range
- max: Vector3
  
  defines the maximum range
Returns void
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1328

`Static` Clamp

Clamp<T>(value: DeepImmutable<T>, min: DeepImmutableObject<Vector3>, max: DeepImmutableObject<Vector3>): T
Returns a new Vector3 set with the coordinates of "value", if the vector "value" is in the cube defined by the vectors "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 Example Playground https://playground.babylonjs.com/#R1F8YU#76

Returns
the new Vector3
Type Parameters
- T extends Vector3<T>
Parameters
- value: DeepImmutable<T>
  
  defines the current value
- min: DeepImmutableObject<Vector3>
  
  defines the lower range value
- max: DeepImmutableObject<Vector3>
  
  defines the upper range value
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1308

`Static` ClampToRef

ClampToRef<T>(value: DeepImmutableObject<Vector3>, min: DeepImmutableObject<Vector3>, max: DeepImmutableObject<Vector3>, result: T): T
Sets the given vector "result" with the coordinates of "value", if the vector "value" is in the cube defined by the vectors "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 Example Playground https://playground.babylonjs.com/#R1F8YU#77

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- value: DeepImmutableObject<Vector3>
  
  defines the current value
- min: DeepImmutableObject<Vector3>
  
  defines the lower range value
- max: DeepImmutableObject<Vector3>
  
  defines the upper range value
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1320

`Static` Cross

Cross<T>(left: DeepImmutable<T>, right: DeepImmutableObject<Vector3>): T
Returns a new Vector3 as the cross product of the vectors "left" and "right" The cross product is then orthogonal to both "left" and "right" Example Playground https://playground.babylonjs.com/#R1F8YU#15

Returns
the cross product
Type Parameters
- T extends Vector3<T>
Parameters
- left: DeepImmutable<T>
  
  defines the left operand
- right: DeepImmutableObject<Vector3>
  
  defines the right operand
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1398

`Static` CrossToRef

CrossToRef<T>(left: DeepImmutableObject<Vector3>, right: DeepImmutableObject<Vector3>, result: T): T
Sets the given vector "result" with the cross product of "left" and "right" The cross product is then orthogonal to both "left" and "right" Example Playground https://playground.babylonjs.com/#R1F8YU#78

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- left: DeepImmutableObject<Vector3>
  
  defines the left operand
- right: DeepImmutableObject<Vector3>
  
  defines the right operand
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1408

`Static` Distance

Distance(value1: DeepImmutableObject<Vector3>, value2: DeepImmutableObject<Vector3>): number
Returns the distance between the vectors "value1" and "value2" Example Playground https://playground.babylonjs.com/#R1F8YU#81

Returns
the distance
Parameters
- value1: DeepImmutableObject<Vector3>
  
  defines the first operand
- value2: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1538

`Static` DistanceSquared

DistanceSquared(value1: DeepImmutableObject<Vector3>, value2: DeepImmutableObject<Vector3>): number
Returns the squared distance between the vectors "value1" and "value2" Example Playground https://playground.babylonjs.com/#R1F8YU#80

Returns
the squared distance
Parameters
- value1: DeepImmutableObject<Vector3>
  
  defines the first operand
- value2: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1546

`Static` Dot

Dot(left: DeepImmutableObject<Vector3>, right: DeepImmutableObject<Vector3>): number
Returns the dot product (float) between the vectors "left" and "right" Example Playground https://playground.babylonjs.com/#R1F8YU#82

Returns
the dot product
Parameters
- left: DeepImmutableObject<Vector3>
  
  defines the left operand
- right: DeepImmutableObject<Vector3>
  
  defines the right operand
Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1389

`Static` Down

Down(): Vector3
Returns a new Vector3 set to (0.0, -1.0, 0.0) Example Playground https://playground.babylonjs.com/#R1F8YU#71

Returns
a new down Vector3

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1191

`Static` Forward

Forward(rightHandedSystem?: boolean): Vector3
Returns a new Vector3 set to (0.0, 0.0, 1.0) Example Playground https://playground.babylonjs.com/#R1F8YU#71

Returns
a new forward Vector3
Parameters
- Optional rightHandedSystem: boolean
  
  is the scene right-handed (negative z)
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1198

`Static` FromArray

FromArray(array: DeepImmutableObject<ArrayLike<number>>, offset?: number): Vector3
Returns a new Vector3 set from the index "offset" of the given array Example Playground https://playground.babylonjs.com/#R1F8YU#83

Returns
the new Vector3
Parameters
- array: DeepImmutableObject<ArrayLike<number>>
  
  defines the source array
- Optional offset: number
  
  defines the offset in the source array
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1095

`Static` FromArrayToRef

FromArrayToRef<T>(array: DeepImmutableObject<ArrayLike<number>>, offset: number, result: T): T
Sets the given vector "result" with the element values from the index "offset" of the given array Example Playground https://playground.babylonjs.com/#R1F8YU#84

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- array: DeepImmutableObject<ArrayLike<number>>
  
  defines the source array
- offset: number
  
  defines the offset in the source array
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1112

`Static` FromFloatArray

FromFloatArray(array: DeepImmutableObject<Float32Array>, offset?: number): Vector3
Returns a new Vector3 set from the index "offset" of the given Float32Array

Returns
the new Vector3

Deprecated
Please use FromArray instead.
Parameters
- array: DeepImmutableObject<Float32Array>
  
  defines the source array
- Optional offset: number
  
  defines the offset in the source array
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1103

`Static` FromFloatArrayToRef

FromFloatArrayToRef<T>(array: DeepImmutableObject<Float32Array>, offset: number, result: T): T
Sets the given vector "result" with the element values from the index "offset" of the given Float32Array

Deprecated
Please use FromArrayToRef instead.
Type Parameters
- T extends Vector3<T>
Parameters
- array: DeepImmutableObject<Float32Array>
  
  defines the source array
- offset: number
  
  defines the offset in the source array
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1120

`Static` FromFloatsToRef

FromFloatsToRef<T>(x: number, y: number, z: number, result: T): T
Sets the given vector "result" with the given floats. Example Playground https://playground.babylonjs.com/#R1F8YU#85
Type Parameters
- T extends Vector3<T> = Vector3
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
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1129

`Static` GetAngleBetweenVectors

GetAngleBetweenVectors(vector0: DeepImmutableObject<Vector3>, vector1: DeepImmutableObject<Vector3>, normal: DeepImmutableObject<Vector3>): number
Get angle between two vectors Example Playground https://playground.babylonjs.com/#R1F8YU#86

Returns
the angle between vector0 and vector1
Parameters
- vector0: DeepImmutableObject<Vector3>
  
  the starting point
- vector1: DeepImmutableObject<Vector3>
  
  the ending point
- normal: DeepImmutableObject<Vector3>
  
  direction of the normal
Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1038

`Static` GetAngleBetweenVectorsOnPlane

GetAngleBetweenVectorsOnPlane(vector0: Vector3, vector1: Vector3, normal: Vector3): number
Get angle between two vectors projected on a plane Example Playground https://playground.babylonjs.com/#R1F8YU#87 Expectation compute time: 0.01 ms (median) and 0.02 ms (percentile 95%)

Returns
the angle in radians (float) between vector0 and vector1 projected on the plane with the specified normal
Parameters
- vector0: Vector3
  
  angle between vector0 and vector1
- vector1: Vector3
  
  angle between vector0 and vector1
- normal: Vector3
  
  Normal of the projection plane
Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1048

`Static` GetClipFactor

GetClipFactor(vector0: DeepImmutableObject<Vector3>, vector1: DeepImmutableObject<Vector3>, axis: DeepImmutableObject<Vector3>, size: number): number
Get the clip factor between two vectors Example Playground https://playground.babylonjs.com/#R1F8YU#126

Returns
the clip factor
Parameters
- vector0: DeepImmutableObject<Vector3>
  
  defines the first operand
- vector1: DeepImmutableObject<Vector3>
  
  defines the second operand
- axis: DeepImmutableObject<Vector3>
  
  defines the axis to use
- size: number
  
  defines the size along the axis
Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1029

`Static` Hermite

Hermite<T>(value1: DeepImmutable<T>, tangent1: DeepImmutableObject<Vector3>, value2: DeepImmutableObject<Vector3>, tangent2: DeepImmutableObject<Vector3>, amount: number): T
Returns a new Vector3 located for "amount" (float) on the Hermite interpolation spline defined by the vectors "value1", "tangent1", "value2", "tangent2" Example Playground https://playground.babylonjs.com/#R1F8YU#89

Returns
the new Vector3
Type Parameters
- T extends Vector3<T>
Parameters
- value1: DeepImmutable<T>
  
  defines the first control point
- tangent1: DeepImmutableObject<Vector3>
  
  defines the first tangent vector
- value2: DeepImmutableObject<Vector3>
  
  defines the second control point
- tangent2: DeepImmutableObject<Vector3>
  
  defines the second tangent vector
- amount: number
  
  defines the amount on the interpolation spline (between 0 and 1)
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1339

`Static` Hermite1stDerivative

Hermite1stDerivative<T>(value1: DeepImmutable<T>, tangent1: DeepImmutableObject<Vector3>, value2: DeepImmutableObject<Vector3>, tangent2: DeepImmutableObject<Vector3>, time: number): T
Returns a new Vector3 which is the 1st derivative of the Hermite spline defined by the vectors "value1", "value2", "tangent1", "tangent2". Example Playground https://playground.babylonjs.com/#R1F8YU#90

Returns
1st derivative
Type Parameters
- T extends Vector3<T>
Parameters
- value1: DeepImmutable<T>
  
  defines the first control point
- tangent1: DeepImmutableObject<Vector3>
  
  defines the first tangent
- value2: DeepImmutableObject<Vector3>
  
  defines the second control point
- tangent2: DeepImmutableObject<Vector3>
  
  defines the second tangent
- time: number
  
  define where the derivative must be done
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1350

`Static` Hermite1stDerivativeToRef

Hermite1stDerivativeToRef<T>(value1: DeepImmutableObject<Vector3>, tangent1: DeepImmutableObject<Vector3>, value2: DeepImmutableObject<Vector3>, tangent2: DeepImmutableObject<Vector3>, time: number, result: T): T
Update a Vector3 with the 1st derivative of the Hermite spline defined by the vectors "value1", "value2", "tangent1", "tangent2". Example Playground https://playground.babylonjs.com/#R1F8YU#91

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- value1: DeepImmutableObject<Vector3>
  
  defines the first control point
- tangent1: DeepImmutableObject<Vector3>
  
  defines the first tangent
- value2: DeepImmutableObject<Vector3>
  
  defines the second control point
- tangent2: DeepImmutableObject<Vector3>
  
  defines the second tangent
- time: number
  
  define where the derivative must be done
- result: T
  
  define where to store the derivative
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1362

`Static` Left

Left(): Vector3
Returns a new Vector3 set to (-1.0, 0.0, 0.0) Example Playground https://playground.babylonjs.com/#R1F8YU#71

Returns
a new left Vector3

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1217

`Static` Lerp

Lerp<T>(start: DeepImmutable<T>, end: DeepImmutableObject<Vector3>, amount: number): T
Returns a new Vector3 located for "amount" (float) on the linear interpolation between the vectors "start" and "end" Example Playground https://playground.babylonjs.com/#R1F8YU#95

Returns
the new Vector3
Type Parameters
- T extends Vector3<T>
Parameters
- start: DeepImmutable<T>
  
  defines the start value
- end: DeepImmutableObject<Vector3>
  
  defines the end value
- amount: number
  
  max defines amount between both (between 0 and 1)
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1371

`Static` LerpToRef

LerpToRef<T>(start: DeepImmutableObject<Vector3>, end: DeepImmutableObject<Vector3>, amount: number, result: T): T
Sets the given vector "result" with the result of the linear interpolation from the vector "start" for "amount" to the vector "end" Example Playground https://playground.babylonjs.com/#R1F8YU#93

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- start: DeepImmutableObject<Vector3>
  
  defines the start value
- end: DeepImmutableObject<Vector3>
  
  defines the end value
- amount: number
  
  max defines amount between both (between 0 and 1)
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1381

`Static` Maximize

Maximize<T>(left: DeepImmutable<T>, right: DeepImmutableObject<Vector3>): T
Gets the maximal coordinate values between two Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#96

Returns
the new Vector3
Type Parameters
- T extends Vector3<T>
Parameters
- left: DeepImmutable<T>
  
  defines the first operand
- right: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1530

`Static` Minimize

Minimize<T>(left: DeepImmutable<T>, right: DeepImmutableObject<Vector3>): T
Gets the minimal coordinate values between two Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#97

Returns
the new Vector3
Type Parameters
- T extends Vector3<T>
Parameters
- left: DeepImmutable<T>
  
  defines the first operand
- right: DeepImmutableObject<Vector3>
  
  defines the second operand
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1522

`Static` Normalize

Normalize(vector: DeepImmutableObject<Vector3>): Vector3
Returns a new Vector3 as the normalization of the given vector Example Playground https://playground.babylonjs.com/#R1F8YU#98

Returns
the new Vector3
Parameters
- vector: DeepImmutableObject<Vector3>
  
  defines the Vector3 to normalize
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1415

`Static` NormalizeToRef

NormalizeToRef<T>(vector: DeepImmutableObject<Vector3>, result: T): T
Sets the given vector "result" with the normalization of the given first vector Example Playground https://playground.babylonjs.com/#R1F8YU#98

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- vector: DeepImmutableObject<Vector3>
  
  defines the Vector3 to normalize
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1423

`Static` One

One(): Vector3
Returns a new Vector3 set to (1.0, 1.0, 1.0)

Returns
a new Vector3

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1139

`Static` PitchYawRollToMoveBetweenPoints

PitchYawRollToMoveBetweenPoints(start: Vector3, target: Vector3): Vector3
Gets the rotation that aligns the roll axis (Y) to the line joining the start point to the target point Example PG https://playground.babylonjs.com/#R1F8YU#188

Returns
the rotation in the form (pitch, yaw, 0)
Parameters
- start: Vector3
  
  the starting point
- target: Vector3
  
  the target point
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1065

`Static` PitchYawRollToMoveBetweenPointsToRef

PitchYawRollToMoveBetweenPointsToRef<T>(start: Vector3, target: Vector3, ref: T): T
Gets the rotation that aligns the roll axis (Y) to the line joining the start point to the target point and stores it in the ref Vector3 Example PG https://playground.babylonjs.com/#R1F8YU#189

Returns
ref in the form (pitch, yaw, 0)
Type Parameters
- T extends Vector3<T>
Parameters
- start: Vector3
  
  the starting point
- target: Vector3
  
  the target point
- ref: T
  
  the vector3 to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1057

`Static` Project

Project<T>(vector: DeepImmutable<T>, world: DeepImmutableObject<Matrix>, transform: DeepImmutableObject<Matrix>, viewport: DeepImmutableObject<Viewport>): T
Project a Vector3 onto screen space Example Playground https://playground.babylonjs.com/#R1F8YU#101

Returns
the new Vector3
Type Parameters
- T extends Vector3<T>
Parameters
- vector: DeepImmutable<T>
  
  defines the Vector3 to project
- world: DeepImmutableObject<Matrix>
  
  defines the world matrix to use
- transform: DeepImmutableObject<Matrix>
  
  defines the transform (view x projection) matrix to use
- viewport: DeepImmutableObject<Viewport>
  
  defines the screen viewport to use
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1433

`Static` ProjectOnTriangleToRef

ProjectOnTriangleToRef(vector: DeepImmutableObject<Vector3>, p0: DeepImmutableObject<Vector3>, p1: DeepImmutableObject<Vector3>, p2: DeepImmutableObject<Vector3>, ref: Vector3): number
Projects "vector" on the triangle determined by its extremities "p0", "p1" and "p2", stores the result in "ref" and returns the distance to the projected point. Example Playground https://playground.babylonjs.com/#R1F8YU#104 From http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.104.4264&rep=rep1&type=pdf

Returns
The distance between "ref" and "vector"
Parameters
- vector: DeepImmutableObject<Vector3>
  
  the vector to get distance from
- p0: DeepImmutableObject<Vector3>
  
  extremity of the triangle
- p1: DeepImmutableObject<Vector3>
  
  extremity of the triangle
- p2: DeepImmutableObject<Vector3>
  
  extremity of the triangle
- ref: Vector3
  
  variable to store the result to
Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1560

`Static` ProjectToRef

ProjectToRef<T>(vector: DeepImmutableObject<Vector3>, world: DeepImmutableObject<Matrix>, transform: DeepImmutableObject<Matrix>, viewport: DeepImmutableObject<Viewport>, result: T): T
Project a Vector3 onto screen space to reference Example Playground https://playground.babylonjs.com/#R1F8YU#102

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- vector: DeepImmutableObject<Vector3>
  
  defines the Vector3 to project
- world: DeepImmutableObject<Matrix>
  
  defines the world matrix to use
- transform: DeepImmutableObject<Matrix>
  
  defines the transform (view x projection) matrix to use
- viewport: DeepImmutableObject<Viewport>
  
  defines the screen viewport to use
- result: T
  
  the vector in which the screen space will be stored
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1444

`Static` Random

Random(min?: number, max?: number): Vector3
Returns a new Vector3 with random values between min and max

Returns
a Vector3 with random values between min and max
Parameters
- Optional min: number
  
  the minimum random value
- Optional max: number
  
  the maximum random value
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1224

`Static` Reflect

Reflect<T>(inDirection: DeepImmutableObject<Vector3>, normal: DeepImmutableObject<Vector3>): Vector3
Reflects a vector off the plane defined by a normalized normal

Returns
the resulting vector
Type Parameters
- T extends Vector3<T>
Parameters
- inDirection: DeepImmutableObject<Vector3>
  
  defines the vector direction
- normal: DeepImmutableObject<Vector3>
  
  defines the normal - Must be normalized
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1451

`Static` ReflectToRef

ReflectToRef<T>(inDirection: DeepImmutableObject<Vector3>, normal: DeepImmutableObject<Vector3>, ref: T): T
Reflects a vector off the plane defined by a normalized normal to reference

Returns
the resulting vector
Type Parameters
- T extends Vector3<T>
Parameters
- inDirection: DeepImmutableObject<Vector3>
  
  defines the vector direction
- normal: DeepImmutableObject<Vector3>
  
  defines the normal - Must be normalized
- ref: T
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1459

`Static` Right

Right(): Vector3
Returns a new Vector3 set to (1.0, 0.0, 0.0) Example Playground https://playground.babylonjs.com/#R1F8YU#71

Returns
a new right Vector3

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1211

`Static` RotationFromAxis

RotationFromAxis<T>(axis1: DeepImmutable<T>, axis2: DeepImmutableObject<Vector3>, axis3: DeepImmutableObject<Vector3>): T
Given three orthogonal normalized left-handed oriented Vector3 axis in space (target system), RotationFromAxis() returns the rotation Euler angles (ex : rotation.x, rotation.y, rotation.z) to apply to something in order to rotate it from its local system to the given target system Note: axis1, axis2 and axis3 are normalized during this operation Example Playground https://playground.babylonjs.com/#R1F8YU#106

Returns
a new Vector3

See
https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms/center_origin/target_align
Type Parameters
- T extends Vector3<T>
Parameters
- axis1: DeepImmutable<T>
  
  defines the first axis
- axis2: DeepImmutableObject<Vector3>
  
  defines the second axis
- axis3: DeepImmutableObject<Vector3>
  
  defines the third axis
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1590

`Static` RotationFromAxisToRef

RotationFromAxisToRef<T>(axis1: DeepImmutableObject<Vector3>, axis2: DeepImmutableObject<Vector3>, axis3: DeepImmutableObject<Vector3>, ref: T): T
The same than RotationFromAxis but updates the given ref Vector3 parameter instead of returning a new Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#107

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- axis1: DeepImmutableObject<Vector3>
  
  defines the first axis
- axis2: DeepImmutableObject<Vector3>
  
  defines the second axis
- axis3: DeepImmutableObject<Vector3>
  
  defines the third axis
- ref: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1600

`Static` SlerpToRef

SlerpToRef<T>(vector0: Vector3, vector1: Vector3, slerp: number, result: T): T
Slerp between two vectors. See also SmoothToRef Slerp is a spherical linear interpolation giving a slow in and out effect Example Playground 1 https://playground.babylonjs.com/#R1F8YU#108 Example Playground 2 https://playground.babylonjs.com/#R1F8YU#109
Type Parameters
- T extends Vector3<T> = Vector3
Parameters
- vector0: Vector3
  
  Start vector
- vector1: Vector3
  
  End vector
- slerp: number
  
  amount (will be clamped between 0 and 1)
- result: T
  
  The slerped vector
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1077

`Static` SmoothToRef

SmoothToRef<T>(source: Vector3, goal: Vector3, deltaTime: number, lerpTime: number, result: T): T
Smooth interpolation between two vectors using Slerp Example Playground https://playground.babylonjs.com/#R1F8YU#110
Type Parameters
- T extends Vector3<T> = Vector3
Parameters
- source: Vector3
  
  source vector
- goal: Vector3
  
  goal vector
- deltaTime: number
  
  current interpolation frame
- lerpTime: number
  
  total interpolation time
- result: T
  
  the smoothed vector
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1087

`Static` TransformCoordinates

TransformCoordinates<T>(vector: DeepImmutableObject<Vector3>, transformation: DeepImmutableObject<Matrix>): Vector3
Returns a new Vector3 set with the result of the transformation by the given matrix of the given vector. This method computes transformed coordinates only, not transformed direction vectors (ie. it takes translation in account) Example Playground https://playground.babylonjs.com/#R1F8YU#111

Returns
the transformed Vector3
Type Parameters
- T extends Vector3<T>
Parameters
- vector: DeepImmutableObject<Vector3>
  
  defines the Vector3 to transform
- transformation: DeepImmutableObject<Matrix>
  
  defines the transformation matrix
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1233

`Static` TransformCoordinatesFromFloatsToRef

TransformCoordinatesFromFloatsToRef<T>(x: number, y: number, z: number, transformation: DeepImmutableObject<Matrix>, result: T): T
Sets the given vector "result" coordinates with the result of the transformation by the given matrix of the given floats (x, y, z) This method computes transformed coordinates only, not transformed direction vectors Example Playground https://playground.babylonjs.com/#R1F8YU#115

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- x: number
  
  define the x coordinate of the source vector
- y: number
  
  define the y coordinate of the source vector
- z: number
  
  define the z coordinate of the source vector
- transformation: DeepImmutableObject<Matrix>
  
  defines the transformation matrix
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1255

`Static` TransformCoordinatesToRef

TransformCoordinatesToRef<T>(vector: DeepImmutableObject<Vector3>, transformation: DeepImmutableObject<Matrix>, result: T): T
Sets the given vector "result" coordinates with the result of the transformation by the given matrix of the given vector This method computes transformed coordinates only, not transformed direction vectors (ie. it takes translation in account) Example Playground https://playground.babylonjs.com/#R1F8YU#113

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- vector: DeepImmutableObject<Vector3>
  
  defines the Vector3 to transform
- transformation: DeepImmutableObject<Matrix>
  
  defines the transformation matrix
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1243

`Static` TransformNormal

TransformNormal(vector: DeepImmutableObject<Vector3>, transformation: DeepImmutableObject<Matrix>): Vector3
Returns a new Vector3 set with the result of the normal transformation by the given matrix of the given vector This methods computes transformed normalized direction vectors only (ie. it does not apply translation) Example Playground https://playground.babylonjs.com/#R1F8YU#112

Returns
the new Vector3
Parameters
- vector: DeepImmutableObject<Vector3>
  
  defines the Vector3 to transform
- transformation: DeepImmutableObject<Matrix>
  
  defines the transformation matrix
Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1264

`Static` TransformNormalFromFloatsToRef

TransformNormalFromFloatsToRef<T>(x: number, y: number, z: number, transformation: DeepImmutableObject<Matrix>, result: T): T
Sets the given vector "result" with the result of the normal transformation by the given matrix of the given floats (x, y, z) This methods computes transformed normalized direction vectors only (ie. it does not apply translation) Example Playground https://playground.babylonjs.com/#R1F8YU#116

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- x: number
  
  define the x coordinate of the source vector
- y: number
  
  define the y coordinate of the source vector
- z: number
  
  define the z coordinate of the source vector
- transformation: DeepImmutableObject<Matrix>
  
  defines the transformation matrix
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1286

`Static` TransformNormalToRef

TransformNormalToRef<T>(vector: DeepImmutableObject<Vector3>, transformation: DeepImmutableObject<Matrix>, result: T): T
Sets the given vector "result" with the result of the normal transformation by the given matrix of the given vector This methods computes transformed normalized direction vectors only (ie. it does not apply translation) Example Playground https://playground.babylonjs.com/#R1F8YU#114

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- vector: DeepImmutableObject<Vector3>
  
  defines the Vector3 to transform
- transformation: DeepImmutableObject<Matrix>
  
  defines the transformation matrix
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1274

`Static` Unproject

Unproject<T>(source: DeepImmutable<T>, viewportWidth: number, viewportHeight: number, world: DeepImmutableObject<Matrix>, view: DeepImmutableObject<Matrix>, projection: DeepImmutableObject<Matrix>): T
Unproject from screen space to object space Example Playground https://playground.babylonjs.com/#R1F8YU#117

Returns
the new Vector3
Type Parameters
- T extends Vector3<T>
Parameters
- source: DeepImmutable<T>
  
  defines the screen space Vector3 to use
- viewportWidth: number
  
  defines the current width of the viewport
- viewportHeight: number
  
  defines the current height of the viewport
- world: DeepImmutableObject<Matrix>
  
  defines the world matrix to use (can be set to Identity to go to world space)
- view: DeepImmutableObject<Matrix>
  
  defines the view matrix to use
- projection: DeepImmutableObject<Matrix>
  
  defines the projection matrix to use
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1486

`Static` UnprojectFloatsToRef

UnprojectFloatsToRef<T>(sourceX: number, sourceY: number, sourceZ: number, viewportWidth: number, viewportHeight: number, world: DeepImmutableObject<Matrix>, view: DeepImmutableObject<Matrix>, projection: DeepImmutableObject<Matrix>, result: T): T
Unproject from screen space to object space Example Playground https://playground.babylonjs.com/#R1F8YU#120

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- sourceX: number
  
  defines the screen space x coordinate to use
- sourceY: number
  
  defines the screen space y coordinate to use
- sourceZ: number
  
  defines the screen space z coordinate to use
- viewportWidth: number
  
  defines the current width of the viewport
- viewportHeight: number
  
  defines the current height of the viewport
- world: DeepImmutableObject<Matrix>
  
  defines the world matrix to use (can be set to Identity to go to world space)
- view: DeepImmutableObject<Matrix>
  
  defines the view matrix to use
- projection: DeepImmutableObject<Matrix>
  
  defines the projection matrix to use
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1514

`Static` UnprojectFromTransform

UnprojectFromTransform<T>(source: DeepImmutable<T>, viewportWidth: number, viewportHeight: number, world: DeepImmutableObject<Matrix>, transform: DeepImmutableObject<Matrix>): T
Unproject from screen space to object space Example Playground https://playground.babylonjs.com/#R1F8YU#121

Returns
the new Vector3
Type Parameters
- T extends Vector3<T>
Parameters
- source: DeepImmutable<T>
  
  defines the screen space Vector3 to use
- viewportWidth: number
  
  defines the current width of the viewport
- viewportHeight: number
  
  defines the current height of the viewport
- world: DeepImmutableObject<Matrix>
  
  defines the world matrix to use (can be set to Identity to go to world space)
- transform: DeepImmutableObject<Matrix>
  
  defines the transform (view x projection) matrix to use
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1474

`Static` UnprojectToRef

UnprojectToRef<T>(source: DeepImmutableObject<Vector3>, viewportWidth: number, viewportHeight: number, world: DeepImmutableObject<Matrix>, view: DeepImmutableObject<Matrix>, projection: DeepImmutableObject<Matrix>, result: T): T
Unproject from screen space to object space Example Playground https://playground.babylonjs.com/#R1F8YU#119

Returns
result input
Type Parameters
- T extends Vector3<T>
Parameters
- source: DeepImmutableObject<Vector3>
  
  defines the screen space Vector3 to use
- viewportWidth: number
  
  defines the current width of the viewport
- viewportHeight: number
  
  defines the current height of the viewport
- world: DeepImmutableObject<Matrix>
  
  defines the world matrix to use (can be set to Identity to go to world space)
- view: DeepImmutableObject<Matrix>
  
  defines the view matrix to use
- projection: DeepImmutableObject<Matrix>
  
  defines the projection matrix to use
- result: T
  
  defines the Vector3 where to store the result
Returns T
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1499

`Static` Up

Up(): Vector3
Returns a new Vector3 set to (0.0, 1.0, 0.0) Example Playground https://playground.babylonjs.com/#R1F8YU#71

Returns
a new up Vector3

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1145

`Static` Zero

Zero(): Vector3
Returns a new Vector3 set to (0.0, 0.0, 0.0)

Returns
a new empty Vector3

Returns Vector3
- Defined in node_modules/@babylonjs/core/Maths/math.vector.d.ts:1134

Class Vector3

Hierarchy

Index

Constructors

Accessors

Methods

Constructors

constructor

Parameters

Optional x: number

Optional y: number

Optional z: number

Returns Vector3

Accessors

hasAZeroComponent

Returns boolean

isNonUniform

Returns boolean

x

Returns number

Parameters

value: number

Returns void

y

Returns number

Parameters

value: number

Returns void

z

Returns number

Parameters

value: number

Returns void

Static DownReadOnly

Returns DeepImmutableObject<Vector3>

Static LeftHandedBackwardReadOnly

Returns DeepImmutableObject<Vector3>

Static LeftHandedForwardReadOnly

Returns DeepImmutableObject<Vector3>

Static LeftReadOnly

Returns DeepImmutableObject<Vector3>

Static OneReadOnly

Returns DeepImmutableObject<Vector3>

Static RightHandedBackwardReadOnly

Returns DeepImmutableObject<Vector3>

Static RightHandedForwardReadOnly

Returns DeepImmutableObject<Vector3>

Static RightReadOnly

Returns DeepImmutableObject<Vector3>

Static UpReadOnly

Returns DeepImmutableObject<Vector3>

Static ZeroReadOnly

Returns DeepImmutableObject<Vector3>

Methods

add

Returns

Parameters

otherVector: DeepImmutableObject<Vector3>

Returns Vector3

addInPlace

Returns

Parameters

otherVector: DeepImmutableObject<Vector3>

Returns Vector3

addInPlaceFromFloats

Returns

Parameters

x: number

y: number

z: number

Returns Vector3

addToRef

Returns

Type Parameters

T extends Vector3<T>

Parameters

otherVector: DeepImmutableObject<Vector3>

result: T

Returns T

applyRotationQuaternion

`Optional` x: number

`Optional` y: number

`Optional` z: number

`Static` DownReadOnly

`Static` LeftHandedBackwardReadOnly

`Static` LeftHandedForwardReadOnly

`Static` LeftReadOnly

`Static` OneReadOnly

`Static` RightHandedBackwardReadOnly

`Static` RightHandedForwardReadOnly

`Static` RightReadOnly

`Static` UpReadOnly

`Static` ZeroReadOnly