Class Vector3

constructor

• new Vector3(x?: number, y?: number, z?: number): Vector3

  Creates a new Vector3 object from the given x, y, z (floats) coordinates.

  Parameters

  • x: number = 0

    defines the first coordinates (on X axis)

  • y: number = 0

    defines the second coordinates (on Y axis)

  • z: number = 0

    defines the third coordinates (on Z axis)

  Returns Vector3

Readonlydimension

Readonlyrank

Static_V8PerformanceHack

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

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

x

• get x(): number

  Gets or sets the x coordinate

  Returns number

• set x(value: number): void

  Parameters

  • value: number

  Returns void

y

• get y(): number

  Gets or sets the y coordinate

  Returns number

• set y(value: number): void

  Parameters

  • value: number

  Returns void

z

• get z(): number

  Gets or sets the z coordinate

  Returns number

• set z(value: number): void

  Parameters

  • value: number

  Returns void

StaticDownReadOnly

• get DownReadOnly(): DeepImmutable<Vector3>

  Gets a down Vector3 that must not be updated

  Returns DeepImmutable<Vector3>

StaticLeftHandedBackwardReadOnly

• get LeftHandedBackwardReadOnly(): DeepImmutable<Vector3>

  Gets a backward Vector3 that must not be updated

  Returns DeepImmutable<Vector3>

StaticLeftHandedForwardReadOnly

• get LeftHandedForwardReadOnly(): DeepImmutable<Vector3>

  Gets a forward Vector3 that must not be updated

  Returns DeepImmutable<Vector3>

StaticLeftReadOnly

• get LeftReadOnly(): DeepImmutable<Vector3>

  Gets a left Vector3 that must not be updated

  Returns DeepImmutable<Vector3>

StaticOneReadOnly

• get OneReadOnly(): DeepImmutable<Vector3>

  Gets a one Vector3 that must not be updated

  Returns DeepImmutable<Vector3>

StaticRightHandedBackwardReadOnly

• get RightHandedBackwardReadOnly(): DeepImmutable<Vector3>

  Gets a backward Vector3 that must not be updated

  Returns DeepImmutable<Vector3>

StaticRightHandedForwardReadOnly

• get RightHandedForwardReadOnly(): DeepImmutable<Vector3>

  Gets a forward Vector3 that must not be updated

  Returns DeepImmutable<Vector3>

StaticRightReadOnly

• get RightReadOnly(): DeepImmutable<Vector3>

  Gets a right Vector3 that must not be updated

  Returns DeepImmutable<Vector3>

StaticUpReadOnly

• get UpReadOnly(): DeepImmutable<Vector3>

  Gets an up Vector3 that must not be updated

  Returns DeepImmutable<Vector3>

StaticZeroReadOnly

• get ZeroReadOnly(): DeepImmutable<Vector3>

  Gets a zero Vector3 that must not be updated

  Returns DeepImmutable<Vector3>

add

• add(otherVector: DeepImmutable<IVector3LikeInternal>): Vector3

  Gets a new Vector3, result of the addition the current Vector3 and the given vector Example Playground https://playground.babylonjs.com/#R1F8YU#3

  Parameters

  • otherVector: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  Returns Vector3

  the resulting Vector3

addInPlace

• addInPlace(otherVector: DeepImmutable<Vector3>): this

  Adds the given vector to the current Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#4

  Parameters

  • otherVector: DeepImmutable<Vector3>

    defines the second operand

  Returns this

  the current updated Vector3

addInPlaceFromFloats

• addInPlaceFromFloats(x: number, y: number, z: number): this

  Adds the given coordinates to the current Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#5

  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 this

  the current updated Vector3

addToRef

• addToRef<T extends IVector3LikeInternal>(
      otherVector: DeepImmutable<IVector3LikeInternal>,
      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

  Type Parameters

  • T extends IVector3LikeInternal

  Parameters

  • otherVector: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  • result: T

    defines the Vector3 object where to store the result

  Returns T

  the result

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

  Parameters

  • q: Quaternion

    the unit quaternion representing the rotation

  Returns Vector3

  a new Vector3

applyRotationQuaternionInPlace

• applyRotationQuaternionInPlace(q: Quaternion): this

  Rotates the vector in place using the given unit quaternion Example Playground https://playground.babylonjs.com/#R1F8YU#8

  Parameters

  • q: Quaternion

    the unit quaternion representing the rotation

  Returns this

  the current updated Vector3

applyRotationQuaternionToRef

• applyRotationQuaternionToRef<T extends Vector3>(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

  Type Parameters

  • T extends Vector3

  Parameters

  • q: Quaternion

    the unit quaternion representing the rotation

  • result: T

    the output vector

  Returns T

  the result

asArray

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

  Creates an array containing three elements : the coordinates of the Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#10

  Returns [number, number, number]

  a new array of numbers

clone

• clone(): Vector3

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

  Returns Vector3

  the new Vector3

copyFrom

• copyFrom(source: DeepImmutable<Vector3>): this

  Copies the given vector coordinates to the current Vector3 ones Example Playground https://playground.babylonjs.com/#R1F8YU#12

  Parameters

  • source: DeepImmutable<Vector3>

    defines the source Vector3

  Returns this

  the current updated Vector3

copyFromFloats

• copyFromFloats(x: number, y: number, z: number): this

  Copies the given floats to the current Vector3 coordinates Example Playground https://playground.babylonjs.com/#R1F8YU#13

  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 this

  the current updated Vector3

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

  Parameters

  • other: Vector3

    defines the right operand

  Returns Vector3

  the cross product

divide

• divide(otherVector: DeepImmutable<IVector3LikeInternal>): 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

  Parameters

  • otherVector: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  Returns Vector3

  the new Vector3

divideInPlace

• divideInPlace(otherVector: DeepImmutable<IVector3LikeInternal>): this

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

  Parameters

  • otherVector: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  Returns this

  the current updated Vector3

divideToRef

• divideToRef<T extends IVector3LikeInternal>(
      otherVector: DeepImmutable<IVector3LikeInternal>,
      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

  Type Parameters

  • T extends IVector3LikeInternal

  Parameters

  • otherVector: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  • result: T

    defines the Vector3 object where to store the result

  Returns T

  the result

dot

• dot(otherVector: DeepImmutable<Vector3>): number

  Returns the dot product (float) between the current vectors and "otherVector"

  Parameters

  • otherVector: DeepImmutable<Vector3>

    defines the right operand

  Returns number

  the dot product

equals

• equals(otherVector: DeepImmutable<Vector3>): boolean

  Returns true if the current Vector3 and the given vector coordinates are strictly equal Example Playground https://playground.babylonjs.com/#R1F8YU#19

  Parameters

  • otherVector: DeepImmutable<Vector3>

    defines the second operand

  Returns boolean

  true if both vectors are equals

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

  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

  true if both vectors are equal

equalsWithEpsilon

• equalsWithEpsilon(
      otherVector: DeepImmutable<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

  Parameters

  • otherVector: DeepImmutable<Vector3>

    defines the second operand

  • epsilon: number = Epsilon

    defines the minimal distance to define values as equals

  Returns boolean

  true if both vectors are distant less than epsilon

floor

• floor(): Vector3

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

  Returns Vector3

  a new Vector3

floorToRef

• floorToRef<T extends IVector3LikeInternal>(result: T): T

  Gets the current Vector3's floored values and stores them in result

  Type Parameters

  • T extends IVector3LikeInternal

  Parameters

  • result: T

    the vector to store the result in

  Returns T

  the result vector

fract

• fract(): Vector3

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

  Returns Vector3

  a new Vector3

fractToRef

• fractToRef<T extends IVector3LikeInternal>(result: T): T

  Gets the current Vector3's fractional values and stores them in result

  Type Parameters

  • T extends IVector3LikeInternal

  Parameters

  • result: T

    the vector to store the result in

  Returns T

  the result vector

fromArray

• fromArray(array: DeepImmutable<FloatArray>, offset?: number): this

  Update the current vector from an array Example Playground https://playground.babylonjs.com/#R1F8YU#24

  Parameters

  • array: DeepImmutable<FloatArray>

    defines the destination array

  • offset: number = 0

    defines the offset in the destination array

  Returns this

  the current Vector3

getClassName

• getClassName(): string

  Gets the class name

  Returns string

  the string "Vector3"

getHashCode

• getHashCode(): number

  Creates the Vector3 hash code

  Returns number

  a number which tends to be unique between Vector3 instances

getNormalToRef

• getNormalToRef(result: 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: Vector3

    defines the Vector3 object where to store the resultant normal

  Returns Vector3

  the result

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

  Parameters

  • epsilon: number

    the amount the values can differ

  Returns boolean

  if the vector is non uniform to a certain number of decimal places

length

• length(): number

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

  Returns number

  the length of the Vector3

lengthSquared

• lengthSquared(): number

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

  Returns number

  squared length of the Vector3

maximizeInPlace

• maximizeInPlace(other: DeepImmutable<IVector3LikeInternal>): this

  Updates the current Vector3 with the maximal coordinate values between its and the given vector ones. Example Playground https://playground.babylonjs.com/#R1F8YU#27

  Parameters

  • other: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  Returns this

  the current updated Vector3

maximizeInPlaceFromFloats

• maximizeInPlaceFromFloats(x: number, y: number, z: number): this

  Updates the current Vector3 with the maximal coordinate values between its and the given coordinates. Example Playground https://playground.babylonjs.com/#R1F8YU#28

  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 this

  the current updated Vector3

minimizeInPlace

• minimizeInPlace(other: DeepImmutable<IVector3LikeInternal>): this

  Updates the current Vector3 with the minimal coordinate values between its and the given vector ones Example Playground https://playground.babylonjs.com/#R1F8YU#29

  Parameters

  • other: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  Returns this

  the current updated Vector3

minimizeInPlaceFromFloats

• minimizeInPlaceFromFloats(x: number, y: number, z: number): this

  Updates the current Vector3 with the minimal coordinate values between its and the given coordinates Example Playground https://playground.babylonjs.com/#R1F8YU#30

  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 this

  the current updated Vector3

multiply

• multiply(otherVector: DeepImmutable<IVector3LikeInternal>): 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

  Parameters

  • otherVector: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  Returns Vector3

  the new Vector3

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

  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

  the new Vector3

multiplyInPlace

• multiplyInPlace(otherVector: DeepImmutable<IVector3LikeInternal>): this

  Multiplies the current Vector3 coordinates by the given ones Example Playground https://playground.babylonjs.com/#R1F8YU#32

  Parameters

  • otherVector: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  Returns this

  the current updated Vector3

multiplyToRef

• multiplyToRef<T extends IVector3LikeInternal>(
      otherVector: DeepImmutable<IVector3LikeInternal>,
      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

  Type Parameters

  • T extends IVector3LikeInternal

  Parameters

  • otherVector: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  • result: T

    defines the Vector3 object where to store the result

  Returns T

  the result

negate

• negate(): Vector3

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

  Returns Vector3

  a new Vector3

negateInPlace

• negateInPlace(): this

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

  Returns this

  this

negateToRef

• negateToRef<T extends IVector3LikeInternal>(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

  Type Parameters

  • T extends IVector3LikeInternal

  Parameters

  • result: T

    defines the Vector3 object where to store the result

  Returns T

  the result

normalize

• normalize(): this

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

  Returns this

  the current updated Vector3

normalizeFromLength

• normalizeFromLength(len: number): this

  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

  Parameters

  • len: number

    the length of the vector

  Returns this

  the current updated Vector3

normalizeToNew

• normalizeToNew(): Vector3

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

  Returns Vector3

  the new Vector3

normalizeToRef

• normalizeToRef<T extends IVector3LikeInternal>(result: T): T

  Normalize the current Vector3 to the reference Example Playground https://playground.babylonjs.com/#R1F8YU#125

  Type Parameters

  • T extends IVector3LikeInternal

  Parameters

  • result: T

    define the Vector3 to update

  Returns T

  the updated Vector3

projectOnPlane

• projectOnPlane(plane: Plane, origin: Vector3): Vector3

  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

  Parameters

  • plane: Plane

    defines the plane to project to

  • origin: Vector3

    defines the origin of the projection ray

  Returns Vector3

  the projected vector3

projectOnPlaneToRef

• projectOnPlaneToRef<T extends Vector3>(
      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

  Type Parameters

  • T extends Vector3

  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

  result input

reorderInPlace

• reorderInPlace(order: string): Vector3

  Reorders the x y z properties of the vector in place Example Playground https://playground.babylonjs.com/#R1F8YU#44

  Parameters

  • order: string

    new ordering of the properties (eg. for vector 1,2,3 with "ZYX" will produce 3,2,1)

  Returns Vector3

  the current updated vector

rotateByQuaternionAroundPointToRef

• rotateByQuaternionAroundPointToRef<T extends Vector3>(
      quaternion: Quaternion,
      point: Vector3,
      result: T,
  ): T

  Rotates a vector around a given point Example Playground https://playground.babylonjs.com/#R1F8YU#46

  Type Parameters

  • T extends Vector3

  Parameters

  • quaternion: Quaternion

    the rotation quaternion

  • point: Vector3

    the point to rotate around

  • result: T

    vector to store the result

  Returns T

  the resulting vector

rotateByQuaternionToRef

• rotateByQuaternionToRef<T extends Vector3>(quaternion: Quaternion, result: T): T

  Rotates the vector around 0,0,0 by a quaternion Example Playground https://playground.babylonjs.com/#R1F8YU#47

  Type Parameters

  • T extends Vector3

  Parameters

  • quaternion: Quaternion

    the rotation quaternion

  • result: T

    vector to store the result

  Returns T

  the resulting vector

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

  Parameters

  • scale: number

    defines the multiplier factor

  Returns Vector3

  a new Vector3

scaleAndAddToRef

• scaleAndAddToRef<T extends IVector3LikeInternal>(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

  Type Parameters

  • T extends IVector3LikeInternal

  Parameters

  • scale: number

    defines the scale factor

  • result: T

    defines the Vector3 object where to store the result

  Returns T

  result input

scaleInPlace

• scaleInPlace(scale: number): this

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

  Parameters

  • scale: number

    defines the multiplier factor

  Returns this

  the current updated Vector3

scaleToRef

• scaleToRef<T extends IVector3LikeInternal>(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

  Type Parameters

  • T extends IVector3LikeInternal

  Parameters

  • scale: number

    defines the multiplier factor

  • result: T

    defines the Vector3 object where to store the result

  Returns T

  the result

set

• set(x: number, y: number, z: number): this

  Copies the given floats to the current Vector3 coordinates Example Playground https://playground.babylonjs.com/#R1F8YU#58

  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 this

  the current updated Vector3

setAll

• setAll(v: number): this

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

  Parameters

  • v: number

    defines the x, y and z coordinates of the operand

  Returns this

  the current updated Vector3

subtract

• subtract(otherVector: DeepImmutable<IVector3LikeInternal>): 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

  Parameters

  • otherVector: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  Returns Vector3

  the resulting Vector3

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

  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

  the resulting Vector3

subtractFromFloatsToRef

• subtractFromFloatsToRef<T extends IVector3LikeInternal>(
      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

  Type Parameters

  • T extends IVector3LikeInternal

  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

  the result

subtractInPlace

• subtractInPlace(otherVector: DeepImmutable<IVector3LikeInternal>): this

  Subtract the given vector from the current Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#61

  Parameters

  • otherVector: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  Returns this

  the current updated Vector3

subtractToRef

• subtractToRef<T extends IVector3LikeInternal>(
      otherVector: DeepImmutable<IVector3LikeInternal>,
      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

  Type Parameters

  • T extends IVector3LikeInternal

  Parameters

  • otherVector: DeepImmutable<IVector3LikeInternal>

    defines the second operand

  • result: T

    defines the Vector3 object where to store the result

  Returns T

  the result

toArray

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

  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

  Parameters

  • array: FloatArray

    defines the destination array

  • index: number = 0

    defines the offset in the destination array

  Returns this

  the current Vector3

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 Quaternion

  a new Quaternion object, computed from the Vector3 coordinates

toString

• toString(): string

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

  Returns string

  a string with the Vector3 coordinates.

StaticBackward

• Backward(rightHandedSystem?: boolean): Vector3

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

  Parameters

  • rightHandedSystem: boolean = false

    is the scene right-handed (negative-z)

  Returns Vector3

  a new Backward Vector3

StaticCatmullRom

• CatmullRom(
      value1: DeepImmutable<Vector3>,
      value2: DeepImmutable<Vector3>,
      value3: DeepImmutable<Vector3>,
      value4: DeepImmutable<Vector3>,
      amount: number,
  ): Vector3

  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

  Parameters

  • value1: DeepImmutable<Vector3>

    defines the first control point

  • value2: DeepImmutable<Vector3>

    defines the second control point

  • value3: DeepImmutable<Vector3>

    defines the third control point

  • value4: DeepImmutable<Vector3>

    defines the fourth control point

  • amount: number

    defines the amount on the spline to use

  Returns Vector3

  the new Vector3

StaticCenter

• Center(value1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>): Vector3

  Returns a new Vector3 located at the center between "value1" and "value2" Example Playground https://playground.babylonjs.com/#R1F8YU#72

  Parameters

  • value1: DeepImmutable<Vector3>

    defines the first operand

  • value2: DeepImmutable<Vector3>

    defines the second operand

  Returns Vector3

  the new Vector3

StaticCenterToRef

• CenterToRef<T extends Vector3>(
      value1: DeepImmutable<Vector3>,
      value2: DeepImmutable<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

  Type Parameters

  • T extends Vector3

  Parameters

  • value1: DeepImmutable<Vector3>

    defines first vector

  • value2: DeepImmutable<Vector3>

    defines second vector

  • ref: T

    defines third vector

  Returns T

  ref

StaticCheckExtends

• 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

StaticClamp

• Clamp(
      value: DeepImmutable<Vector3>,
      min: DeepImmutable<Vector3>,
      max: DeepImmutable<Vector3>,
  ): Vector3

  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

  Parameters

  • value: DeepImmutable<Vector3>

    defines the current value

  • min: DeepImmutable<Vector3>

    defines the lower range value

  • max: DeepImmutable<Vector3>

    defines the upper range value

  Returns Vector3

  the new Vector3

StaticClampToRef

• ClampToRef<T extends Vector3>(
      value: DeepImmutable<Vector3>,
      min: DeepImmutable<Vector3>,
      max: DeepImmutable<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

  Type Parameters

  • T extends Vector3

  Parameters

  • value: DeepImmutable<Vector3>

    defines the current value

  • min: DeepImmutable<Vector3>

    defines the lower range value

  • max: DeepImmutable<Vector3>

    defines the upper range value

  • result: T

    defines the Vector3 where to store the result

  Returns T

  result input

StaticCross

• Cross(left: DeepImmutable<Vector3>, right: DeepImmutable<Vector3>): Vector3

  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

  Parameters

  • left: DeepImmutable<Vector3>

    defines the left operand

  • right: DeepImmutable<Vector3>

    defines the right operand

  Returns Vector3

  the cross product

StaticCrossToRef

• CrossToRef<T extends Vector3>(
      left: DeepImmutable<Vector3>,
      right: DeepImmutable<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

  Type Parameters

  • T extends Vector3

  Parameters

  • left: DeepImmutable<Vector3>

    defines the left operand

  • right: DeepImmutable<Vector3>

    defines the right operand

  • result: T

    defines the Vector3 where to store the result

  Returns T

  result input

StaticDistance

• Distance(value1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>): number

  Returns the distance between the vectors "value1" and "value2" Example Playground https://playground.babylonjs.com/#R1F8YU#81

  Parameters

  • value1: DeepImmutable<Vector3>

    defines the first operand

  • value2: DeepImmutable<Vector3>

    defines the second operand

  Returns number

  the distance

StaticDistanceSquared

• DistanceSquared(
      value1: DeepImmutable<Vector3>,
      value2: DeepImmutable<Vector3>,
  ): number

  Returns the squared distance between the vectors "value1" and "value2" Example Playground https://playground.babylonjs.com/#R1F8YU#80

  Parameters

  • value1: DeepImmutable<Vector3>

    defines the first operand

  • value2: DeepImmutable<Vector3>

    defines the second operand

  Returns number

  the squared distance

StaticDot

• Dot(left: DeepImmutable<Vector3>, right: DeepImmutable<Vector3>): number

  Returns the dot product (float) between the vectors "left" and "right" Example Playground https://playground.babylonjs.com/#R1F8YU#82

  Parameters

  • left: DeepImmutable<Vector3>

    defines the left operand

  • right: DeepImmutable<Vector3>

    defines the right operand

  Returns number

  the dot product

StaticDown

• Down(): Vector3

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

  Returns Vector3

  a new down Vector3

StaticForward

• Forward(rightHandedSystem?: boolean): Vector3

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

  Parameters

  • rightHandedSystem: boolean = false

    is the scene right-handed (negative z)

  Returns Vector3

  a new forward Vector3

StaticFromArray

• FromArray(array: DeepImmutable<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

  Parameters

  • array: DeepImmutable<ArrayLike<number>>

    defines the source array

  • offset: number = 0

    defines the offset in the source array

  Returns Vector3

  the new Vector3

StaticFromArrayToRef

• FromArrayToRef<T extends Vector3>(
      array: DeepImmutable<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

  Type Parameters

  • T extends Vector3

  Parameters

  • array: DeepImmutable<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

  result input

StaticFromFloatArray

• FromFloatArray(array: DeepImmutable<Float32Array>, offset?: number): Vector3

  Returns a new Vector3 set from the index "offset" of the given Float32Array

  Parameters

  • array: DeepImmutable<Float32Array>

    defines the source array

  • Optionaloffset: number

    defines the offset in the source array

  Returns Vector3

  the new Vector3

  Deprecated

  Please use FromArray instead.

StaticFromFloatArrayToRef

• FromFloatArrayToRef<T extends Vector3>(
      array: DeepImmutable<Float32Array>,
      offset: number,
      result: T,
  ): T

  Sets the given vector "result" with the element values from the index "offset" of the given Float32Array

  Type Parameters

  • T extends Vector3

  Parameters

  • array: DeepImmutable<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

  result input

  Deprecated

  Please use FromArrayToRef instead.

StaticFromFloatsToRef

• FromFloatsToRef<T extends Vector3 = Vector3>(
      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 = 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

  the result vector

StaticGetAngleBetweenVectors

• GetAngleBetweenVectors(
      vector0: DeepImmutable<Vector3>,
      vector1: DeepImmutable<Vector3>,
      normal: DeepImmutable<Vector3>,
  ): number

  Get angle between two vectors Example Playground https://playground.babylonjs.com/#R1F8YU#86

  Parameters

  • vector0: DeepImmutable<Vector3>

    the starting point

  • vector1: DeepImmutable<Vector3>

    the ending point

  • normal: DeepImmutable<Vector3>

    direction of the normal

  Returns number

  the angle between vector0 and vector1

StaticGetAngleBetweenVectorsOnPlane

• GetAngleBetweenVectorsOnPlane(
      vector0: DeepImmutable<Vector3>,
      vector1: DeepImmutable<Vector3>,
      normal: DeepImmutable<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%)

  Parameters

  • vector0: DeepImmutable<Vector3>

    angle between vector0 and vector1

  • vector1: DeepImmutable<Vector3>

    angle between vector0 and vector1

  • normal: DeepImmutable<Vector3>

    Normal of the projection plane

  Returns number

  the angle in radians (float) between vector0 and vector1 projected on the plane with the specified normal

StaticGetClipFactor

• GetClipFactor(
      vector0: DeepImmutable<Vector3>,
      vector1: DeepImmutable<Vector3>,
      axis: DeepImmutable<Vector3>,
      size: number,
  ): number

  Get the clip factor between two vectors Example Playground https://playground.babylonjs.com/#R1F8YU#126

  Parameters

  • vector0: DeepImmutable<Vector3>

    defines the first operand

  • vector1: DeepImmutable<Vector3>

    defines the second operand

  • axis: DeepImmutable<Vector3>

    defines the axis to use

  • size: number

    defines the size along the axis

  Returns number

  the clip factor

StaticHermite

• Hermite(
      value1: DeepImmutable<Vector3>,
      tangent1: DeepImmutable<Vector3>,
      value2: DeepImmutable<Vector3>,
      tangent2: DeepImmutable<Vector3>,
      amount: number,
  ): Vector3

  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

  Parameters

  • value1: DeepImmutable<Vector3>

    defines the first control point

  • tangent1: DeepImmutable<Vector3>

    defines the first tangent vector

  • value2: DeepImmutable<Vector3>

    defines the second control point

  • tangent2: DeepImmutable<Vector3>

    defines the second tangent vector

  • amount: number

    defines the amount on the interpolation spline (between 0 and 1)

  Returns Vector3

  the new Vector3

StaticHermite1stDerivative

• Hermite1stDerivative(
      value1: DeepImmutable<Vector3>,
      tangent1: DeepImmutable<Vector3>,
      value2: DeepImmutable<Vector3>,
      tangent2: DeepImmutable<Vector3>,
      time: number,
  ): Vector3

  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

  Parameters

  • value1: DeepImmutable<Vector3>

    defines the first control point

  • tangent1: DeepImmutable<Vector3>

    defines the first tangent

  • value2: DeepImmutable<Vector3>

    defines the second control point

  • tangent2: DeepImmutable<Vector3>

    defines the second tangent

  • time: number

    define where the derivative must be done

  Returns Vector3

  1st derivative

StaticHermite1stDerivativeToRef

• Hermite1stDerivativeToRef<T extends Vector3>(
      value1: DeepImmutable<Vector3>,
      tangent1: DeepImmutable<Vector3>,
      value2: DeepImmutable<Vector3>,
      tangent2: DeepImmutable<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

  Type Parameters

  • T extends Vector3

  Parameters

  • value1: DeepImmutable<Vector3>

    defines the first control point

  • tangent1: DeepImmutable<Vector3>

    defines the first tangent

  • value2: DeepImmutable<Vector3>

    defines the second control point

  • tangent2: DeepImmutable<Vector3>

    defines the second tangent

  • time: number

    define where the derivative must be done

  • result: T

    define where to store the derivative

  Returns T

  result input

StaticLeft

• Left(): Vector3

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

  Returns Vector3

  a new left Vector3

StaticLerp

• Lerp(
      start: DeepImmutable<Vector3>,
      end: DeepImmutable<Vector3>,
      amount: number,
  ): Vector3

  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

  Parameters

  • start: DeepImmutable<Vector3>

    defines the start value

  • end: DeepImmutable<Vector3>

    defines the end value

  • amount: number

    max defines amount between both (between 0 and 1)

  Returns Vector3

  the new Vector3

StaticLerpToRef

• LerpToRef<T extends Vector3>(
      start: DeepImmutable<Vector3>,
      end: DeepImmutable<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

  Type Parameters

  • T extends Vector3

  Parameters

  • start: DeepImmutable<Vector3>

    defines the start value

  • end: DeepImmutable<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

  result input

StaticMaximize

• Maximize(left: DeepImmutable<Vector3>, right: DeepImmutable<Vector3>): Vector3

  Gets the maximal coordinate values between two Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#96

  Parameters

  • left: DeepImmutable<Vector3>

    defines the first operand

  • right: DeepImmutable<Vector3>

    defines the second operand

  Returns Vector3

  the new Vector3

StaticMinimize

• Minimize(left: DeepImmutable<Vector3>, right: DeepImmutable<Vector3>): Vector3

  Gets the minimal coordinate values between two Vector3 Example Playground https://playground.babylonjs.com/#R1F8YU#97

  Parameters

  • left: DeepImmutable<Vector3>

    defines the first operand

  • right: DeepImmutable<Vector3>

    defines the second operand

  Returns Vector3

  the new Vector3

StaticNormalize

• Normalize(vector: DeepImmutable<Vector3>): Vector3

  Returns a new Vector3 as the normalization of the given vector Example Playground https://playground.babylonjs.com/#R1F8YU#98

  Parameters

  • vector: DeepImmutable<Vector3>

    defines the Vector3 to normalize

  Returns Vector3

  the new Vector3

StaticNormalizeToRef

• NormalizeToRef<T extends Vector3>(vector: DeepImmutable<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

  Type Parameters

  • T extends Vector3

  Parameters

  • vector: DeepImmutable<Vector3>

    defines the Vector3 to normalize

  • result: T

    defines the Vector3 where to store the result

  Returns T

  result input

StaticOne

• One(): Vector3

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

  Returns Vector3

  a new Vector3

StaticPitchYawRollToMoveBetweenPoints

• 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

  Parameters

  • start: Vector3

    the starting point

  • target: Vector3

    the target point

  Returns Vector3

  the rotation in the form (pitch, yaw, 0)

StaticPitchYawRollToMoveBetweenPointsToRef

• PitchYawRollToMoveBetweenPointsToRef<T extends Vector3>(
      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

  Type Parameters

  • T extends Vector3

  Parameters

  • start: Vector3

    the starting point

  • target: Vector3

    the target point

  • ref: T

    the vector3 to store the result

  Returns T

  ref in the form (pitch, yaw, 0)

StaticProject

• Project(
      vector: DeepImmutable<Vector3>,
      world: DeepImmutable<Matrix>,
      transform: DeepImmutable<Matrix>,
      viewport: DeepImmutable<Viewport>,
  ): Vector3

  Project a Vector3 onto screen space Example Playground https://playground.babylonjs.com/#R1F8YU#101

  Parameters

  • vector: DeepImmutable<Vector3>

    defines the Vector3 to project

  • world: DeepImmutable<Matrix>

    defines the world matrix to use

  • transform: DeepImmutable<Matrix>

    defines the transform (view x projection) matrix to use

  • viewport: DeepImmutable<Viewport>

    defines the screen viewport to use

  Returns Vector3

  the new Vector3

StaticProjectOnTriangleToRef

• ProjectOnTriangleToRef(
      vector: DeepImmutable<Vector3>,
      p0: DeepImmutable<Vector3>,
      p1: DeepImmutable<Vector3>,
      p2: DeepImmutable<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

  Parameters

  • vector: DeepImmutable<Vector3>

    the vector to get distance from

  • p0: DeepImmutable<Vector3>

    extremity of the triangle

  • p1: DeepImmutable<Vector3>

    extremity of the triangle

  • p2: DeepImmutable<Vector3>

    extremity of the triangle

  • ref: Vector3

    variable to store the result to

  Returns number

  The distance between "ref" and "vector"

StaticProjectToRef

• ProjectToRef<T extends Vector3>(
      vector: DeepImmutable<Vector3>,
      world: DeepImmutable<Matrix>,
      transform: DeepImmutable<Matrix>,
      viewport: DeepImmutable<Viewport>,
      result: T,
  ): T

  Project a Vector3 onto screen space to reference Example Playground https://playground.babylonjs.com/#R1F8YU#102

  Type Parameters

  • T extends Vector3

  Parameters

  • vector: DeepImmutable<Vector3>

    defines the Vector3 to project

  • world: DeepImmutable<Matrix>

    defines the world matrix to use

  • transform: DeepImmutable<Matrix>

    defines the transform (view x projection) matrix to use

  • viewport: DeepImmutable<Viewport>

    defines the screen viewport to use

  • result: T

    the vector in which the screen space will be stored

  Returns T

  result input

StaticRandom

• Random(min?: number, max?: number): Vector3

  Returns a new Vector3 with random values between min and max

  Parameters

  • min: number = 0

    the minimum random value

  • max: number = 1

    the maximum random value

  Returns Vector3

  a Vector3 with random values between min and max

StaticRandomToRef

• RandomToRef<T extends Vector3>(min?: number, max?: number, ref: T): T

  Sets a Vector3 with random values between min and max

  Type Parameters

  • T extends Vector3

  Parameters

  • min: number = 0

    the minimum random value

  • max: number = 1

    the maximum random value

  • ref: T

    the ref to store the values in

  Returns T

  the ref with random values between min and max

StaticReflect

• Reflect(
      inDirection: DeepImmutable<Vector3>,
      normal: DeepImmutable<Vector3>,
  ): Vector3

  Reflects a vector off the plane defined by a normalized normal

  Parameters

  • inDirection: DeepImmutable<Vector3>

    defines the vector direction

  • normal: DeepImmutable<Vector3>

    defines the normal - Must be normalized

  Returns Vector3

  the resulting vector

StaticReflectToRef

• ReflectToRef<T extends Vector3>(
      inDirection: DeepImmutable<Vector3>,
      normal: DeepImmutable<Vector3>,
      ref: T,
  ): T

  Reflects a vector off the plane defined by a normalized normal to reference

  Type Parameters

  • T extends Vector3

  Parameters

  • inDirection: DeepImmutable<Vector3>

    defines the vector direction

  • normal: DeepImmutable<Vector3>

    defines the normal - Must be normalized

  • ref: T

    defines the Vector3 where to store the result

  Returns T

  the resulting vector

StaticRight

• Right(): Vector3

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

  Returns Vector3

  a new right Vector3

StaticRotationFromAxis

• RotationFromAxis(
      axis1: DeepImmutable<Vector3>,
      axis2: DeepImmutable<Vector3>,
      axis3: DeepImmutable<Vector3>,
  ): Vector3

  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

  Parameters

  • axis1: DeepImmutable<Vector3>

    defines the first axis

  • axis2: DeepImmutable<Vector3>

    defines the second axis

  • axis3: DeepImmutable<Vector3>

    defines the third axis

  Returns Vector3

  a new Vector3

  See

  https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms/center_origin/target_align

StaticRotationFromAxisToRef

• RotationFromAxisToRef<T extends Vector3>(
      axis1: DeepImmutable<Vector3>,
      axis2: DeepImmutable<Vector3>,
      axis3: DeepImmutable<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

  Type Parameters

  • T extends Vector3

  Parameters

  • axis1: DeepImmutable<Vector3>

    defines the first axis

  • axis2: DeepImmutable<Vector3>

    defines the second axis

  • axis3: DeepImmutable<Vector3>

    defines the third axis

  • ref: T

    defines the Vector3 where to store the result

  Returns T

  result input

StaticSlerpToRef

• SlerpToRef<T extends Vector3 = Vector3>(
      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 = 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

  The slerped vector

StaticSmoothToRef

• SmoothToRef<T extends Vector3 = Vector3>(
      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 = 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

  the smoothed vector

StaticTransformCoordinates

• TransformCoordinates(
      vector: DeepImmutable<Vector3>,
      transformation: DeepImmutable<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

  Parameters

  • vector: DeepImmutable<Vector3>

    defines the Vector3 to transform

  • transformation: DeepImmutable<Matrix>

    defines the transformation matrix

  Returns Vector3

  the transformed Vector3