Class Vector4

Vector4 class created for EulerAngle class conversion to Quaternion

Implements

Vector<Tuple<number, 4>, IVector4Like>

Index

Constructors

constructor

new Vector4(x?: number, y?: number, z?: number, w?: number): Vector4
Creates a Vector4 object from the given floats.
Parameters
- x: number = 0
  x value of the vector
- y: number = 0
  y value of the vector
- z: number = 0
  z value of the vector
- w: number = 0
  w value of the vector
Returns Vector4
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3476

Properties

`Readonly`dimension

dimension: readonly [4]

See

Tensor.dimension

`Readonly`rank

rank: 1

See

Tensor.rank

`Static`_V8PerformanceHack

_V8PerformanceHack: DeepImmutableObject<Vector4> = ...

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

Accessors

w

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

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

x

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

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

y

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

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

z

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

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

`Static`ZeroReadOnly

get ZeroReadOnly(): DeepImmutable<Vector4>
Gets a zero Vector4 that must not be updated

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

Methods

add

add(otherVector: DeepImmutable<IVector4Like>): Vector4
Returns a new Vector4 as the result of the addition of the current Vector4 and the given one.
Parameters
- otherVector: DeepImmutable<IVector4Like>
  the vector to add
Returns Vector4
the resulting vector
Implementation of Vector.add
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3587

addInPlace

addInPlace(otherVector: DeepImmutable<Vector4>): this
Adds the given vector to the current Vector4.
Parameters
- otherVector: DeepImmutable<Vector4>
  the vector to add
Returns this
the updated Vector4.
Implementation of Vector.addInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3558

addInPlaceFromFloats

addInPlaceFromFloats(x: number, y: number, z: number, w: number): this
Adds the given coordinates to the current Vector4
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
- w: number
  defines the w coordinate of the operand
Returns this
the current updated Vector4
Implementation of Vector.addInPlaceFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3574

addToRef

addToRef<T extends IVector4Like>(
otherVector: DeepImmutable<IVector4Like>,
result: T,
): T
Updates the given vector "result" with the result of the addition of the current Vector4 and the given one.
Type Parameters
- T extends IVector4Like
Parameters
- otherVector: DeepImmutable<IVector4Like>
  the vector to add
- result: T
  the vector to store the result
Returns T
result input
Implementation of Vector.addToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3597

asArray

asArray(): [number, number, number, number]
Returns a new array populated with 4 elements : the Vector4 coordinates.

Returns [number, number, number, number]
the resulting array
Implementation of Vector.asArray
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3521

clone

clone(): Vector4
Returns a new Vector4 copied from the current one.

Returns Vector4
the new cloned vector
Implementation of Vector.clone
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4058

copyFrom

copyFrom(source: DeepImmutable<IVector4Like>): this
Updates the current Vector4 with the given one coordinates.
Parameters
- source: DeepImmutable<IVector4Like>
  the source vector to copy from
Returns this
the updated Vector4.
Implementation of Vector.copyFrom
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4066

copyFromFloats

copyFromFloats(x: number, y: number, z: number, w: number): this
Updates the current Vector4 coordinates with the given floats.
Parameters
- x: number
  float to copy from
- y: number
  float to copy from
- z: number
  float to copy from
- w: number
  float to copy from
Returns this
the updated Vector4.
Implementation of Vector.copyFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4081

divide

divide(otherVector: DeepImmutable<IVector4Like>): Vector4
Returns a new Vector4 set with the division result of the current Vector4 by the given one.
Parameters
- otherVector: DeepImmutable<IVector4Like>
  vector to devide with
Returns Vector4
resulting new vector
Implementation of Vector.divide
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3840

divideInPlace

divideInPlace(otherVector: DeepImmutable<IVector4Like>): this
Divides the current Vector3 coordinates by the given ones.
Parameters
- otherVector: DeepImmutable<IVector4Like>
  vector to devide with
Returns this
the updated Vector3.
Implementation of Vector.divideInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3862

divideToRef

divideToRef<T extends IVector4Like>(
otherVector: DeepImmutable<IVector4Like>,
result: T,
): T
Updates the given vector "result" with the division result of the current Vector4 by the given one.
Type Parameters
- T extends IVector4Like
Parameters
- otherVector: DeepImmutable<IVector4Like>
  vector to devide with
- result: T
  vector to store the result
Returns T
result input
Implementation of Vector.divideToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3849

dot

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

equals

equals(otherVector: DeepImmutable<IVector4Like>): boolean
Boolean : True if the current Vector4 coordinates are stricly equal to the given ones.
Parameters
- otherVector: DeepImmutable<IVector4Like>
  the vector to compare against
Returns boolean
true if they are equal
Implementation of Vector.equals
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3758

equalsToFloats

equalsToFloats(x: number, y: number, z: number, w: number): boolean
Boolean : True if the given floats are strictly equal to the current Vector4 coordinates.
Parameters
- x: number
  x value to compare against
- y: number
  y value to compare against
- z: number
  z value to compare against
- w: number
  w value to compare against
Returns boolean
true if equal
Implementation of Vector.equalsToFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3786

equalsWithEpsilon

equalsWithEpsilon(
otherVector: DeepImmutable<IVector4Like>,
epsilon?: number,
): boolean
Boolean : True if the current Vector4 coordinates are each beneath the distance "epsilon" from the given vector ones.
Parameters
- otherVector: DeepImmutable<IVector4Like>
  vector to compare against
- epsilon: number = Epsilon
  (Default: very small number)
Returns boolean
true if they are equal
Implementation of Vector.equalsWithEpsilon
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3768

floor

floor(): Vector4
Gets a new Vector4 from current Vector4 floored values

Returns Vector4
a new Vector4
Implementation of Vector.floor
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3956

floorToRef

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

fract

fract(): Vector4
Gets a new Vector4 from current Vector4 fractional values

Returns Vector4
a new Vector4
Implementation of Vector.fract
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3977

fractToRef

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

fromArray

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

getClassName

getClassName(): string
Returns the string "Vector4".

Returns string
"Vector4"
Implementation of Vector.getClassName
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3495

getHashCode

getHashCode(): number
Returns the Vector4 hash code.

Returns number
a unique hash code
Implementation of Vector.getHashCode
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3503

length

length(): number
Returns the Vector4 length (float).

Returns number
the length
Implementation of Vector.length
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3986

lengthSquared

lengthSquared(): number
Returns the Vector4 squared length (float).

Returns number
the length squared
Implementation of Vector.lengthSquared
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3993

maximizeInPlace

maximizeInPlace(other: DeepImmutable<IVector4Like>): this
Updates the Vector4 coordinates with the maximum values between its own and the given vector ones
Parameters
- other: DeepImmutable<IVector4Like>
  defines the second operand
Returns this
the current updated Vector4
Implementation of Vector.maximizeInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3891

maximizeInPlaceFromFloats

maximizeInPlaceFromFloats(x: number, y: number, z: number, w: number): this
Updates the current Vector4 with the maximal coordinate values between its and the given coordinates.
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
- w: number
  defines the w coordinate of the operand
Returns this
the current updated Vector4
Implementation of Vector.maximizeInPlaceFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3931

minimizeInPlace

minimizeInPlace(other: DeepImmutable<IVector4Like>): this
Updates the Vector4 coordinates with the minimum values between its own and the given vector ones
Parameters
- other: DeepImmutable<IVector4Like>
  defines the second operand
Returns this
the current updated Vector4
Implementation of Vector.minimizeInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3871

minimizeInPlaceFromFloats

minimizeInPlaceFromFloats(x: number, y: number, z: number, w: number): this
Updates the current Vector4 with the minimal coordinate values between its and the given coordinates
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
- w: number
  defines the w coordinate of the operand
Returns this
the current updated Vector4
Implementation of Vector.minimizeInPlaceFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3915

multiply

multiply(otherVector: DeepImmutable<IVector4Like>): Vector4
Returns a new Vector4 set with the multiplication result of the current Vector4 and the given one.
Parameters
- otherVector: DeepImmutable<IVector4Like>
  vector to multiple with
Returns Vector4
resulting new vector
Implementation of Vector.multiply
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3808

multiplyByFloats

multiplyByFloats(x: number, y: number, z: number, w: number): Vector4
Returns a new Vector4 set with the multiplication result of the given floats and the current Vector4 coordinates.
Parameters
- x: number
  x value multiply with
- y: number
  y value multiply with
- z: number
  z value multiply with
- w: number
  w value multiply with
Returns Vector4
resulting new vector
Implementation of Vector.multiplyByFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3832

multiplyInPlace

multiplyInPlace(otherVector: DeepImmutable<IVector4Like>): this
Multiplies in place the current Vector4 by the given one.
Parameters
- otherVector: DeepImmutable<IVector4Like>
  vector to multiple with
Returns this
the updated Vector4.
Implementation of Vector.multiplyInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3795

multiplyToRef

multiplyToRef<T extends IVector4Like>(
otherVector: DeepImmutable<IVector4Like>,
result: T,
): T
Updates the given vector "result" with the multiplication result of the current Vector4 and the given one.
Type Parameters
- T extends IVector4Like
Parameters
- otherVector: DeepImmutable<IVector4Like>
  vector to multiple with
- result: T
  vector to store the result
Returns T
result input
Implementation of Vector.multiplyToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3817

negate

negate(): Vector4
Returns a new Vector4 set with the current Vector4 negated coordinates.

Returns Vector4
a new vector with the negated values
Implementation of Vector.negate
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3674

negateInPlace

negateInPlace(): this
Negate this vector in place

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

negateToRef

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

normalize

normalize(): this
Normalizes in place the Vector4.

Returns this
the updated Vector4.
Implementation of Vector.normalize
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4002

normalizeFromLength

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

normalizeToNew

normalizeToNew(): Vector4
Normalize the current Vector4 to a new vector

Returns Vector4
the new Vector4
Implementation of Vector.normalizeToNew
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4024

normalizeToRef

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

scale

scale(scale: number): Vector4
Returns a new Vector4 set with the current Vector4 coordinates multiplied by scale (float).
Parameters
- scale: number
  the number to scale with
Returns Vector4
a new vector with the result
Implementation of Vector.scale
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3721

scaleAndAddToRef

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

scaleInPlace

scaleInPlace(scale: number): this
Multiplies the current Vector4 coordinates by scale (float).
Parameters
- scale: number
  the number to scale with
Returns this
the updated Vector4.
Implementation of Vector.scaleInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3708

scaleToRef

scaleToRef<T extends IVector4Like>(scale: number, result: T): T
Sets the given vector "result" with the current Vector4 coordinates multiplied by scale (float).
Type Parameters
- T extends IVector4Like
Parameters
- scale: number
  the number to scale with
- result: T
  a vector to store the result in
Returns T
result input
Implementation of Vector.scaleToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3731

set

set(x: number, y: number, z: number, w: number): this
Updates the current Vector4 coordinates with the given floats.
Parameters
- x: number
  float to set from
- y: number
  float to set from
- z: number
  float to set from
- w: number
  float to set from
Returns this
the updated Vector4.
Implementation of Vector.set
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4096

setAll

setAll(v: number): this
Copies the given float to the current Vector4 coordinates
Parameters
- v: number
  defines the x, y, z and w coordinates of the operand
Returns this
the current updated Vector4
Implementation of Vector.setAll
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4105

subtract

subtract(otherVector: DeepImmutable<IVector4Like>): Vector4
Returns a new Vector4 with the result of the subtraction of the given vector from the current Vector4.
Parameters
- otherVector: DeepImmutable<IVector4Like>
  the vector to add
Returns Vector4
the new vector with the result
Implementation of Vector.subtract
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3623

subtractFromFloats

subtractFromFloats(x: number, y: number, z: number, w: number): Vector4
Returns a new Vector4 set with the result of the subtraction of the given floats from the current Vector4 coordinates.
Parameters
- x: number
  value to subtract
- y: number
  value to subtract
- z: number
  value to subtract
- w: number
  value to subtract
Returns Vector4
new vector containing the result
Implementation of Vector.subtractFromFloats
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3649

subtractFromFloatsToRef

subtractFromFloatsToRef<T extends IVector4Like>(
    x: number,
    y: number,
    z: number,
    w: number,
    result: T,
): T
Sets the given vector "result" set with the result of the subtraction of the given floats from the current Vector4 coordinates.
Type Parameters
- T extends IVector4Like
Parameters
- x: number
  value to subtract
- y: number
  value to subtract
- z: number
  value to subtract
- w: number
  value to subtract
- result: T
  the vector to store the result in
Returns T
result input
Implementation of Vector.subtractFromFloatsToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3662

subtractInPlace

subtractInPlace(otherVector: DeepImmutable<IVector4Like>): this
Subtract in place the given vector from the current Vector4.
Parameters
- otherVector: DeepImmutable<IVector4Like>
  the vector to subtract
Returns this
the updated Vector4.
Implementation of Vector.subtractInPlace
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3610

subtractToRef

subtractToRef<T extends IVector4Like>(
otherVector: DeepImmutable<IVector4Like>,
result: T,
): T
Sets the given vector "result" with the result of the subtraction of the given vector from the current Vector4.
Type Parameters
- T extends IVector4Like
Parameters
- otherVector: DeepImmutable<IVector4Like>
  the vector to subtract
- result: T
  the vector to store the result
Returns T
result input
Implementation of Vector.subtractToRef
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3633

toArray

toArray(array: FloatArray, index?: number): this
Populates the given array from the given index with the Vector4 coordinates.
Parameters
- array: FloatArray
  array to populate
- Optionalindex: number
  index of the array to start at (default: 0)
Returns this
the Vector4.
Implementation of Vector.toArray
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3531

toString

toString(): string
Returns the string with the Vector4 coordinates.

Returns string
a string containing all the vector values
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:3487

toVector3

toVector3(): Vector3
Returns a new Vector3 from the Vector4 (x, y, z) coordinates.

Returns Vector3
this converted to a new vector3
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4050

`Static`Center

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

`Static`CenterToRef

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

`Static`CheckExtends

CheckExtends(v: IVector4Like, min: Vector4, max: Vector4): void
Checks if a given vector is inside a specific range Example Playground https://playground.babylonjs.com/#R1F8YU#75
Parameters
- v: IVector4Like
  defines the vector to test
- min: Vector4
  defines the minimum range
- max: Vector4
  defines the maximum range
Returns void
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4251

`Static`Clamp

Clamp(
    value: DeepImmutable<IVector4Like>,
    min: DeepImmutable<IVector4Like>,
    max: DeepImmutable<IVector4Like>,
): Vector4
Returns a new Vector4 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
Parameters
- value: DeepImmutable<IVector4Like>
  defines the current value
- min: DeepImmutable<IVector4Like>
  defines the lower range value
- max: DeepImmutable<IVector4Like>
  defines the upper range value
Returns Vector4
the new Vector4
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4222

`Static`ClampToRef

ClampToRef<T extends IVector4Like>(
    value: DeepImmutable<IVector4Like>,
    min: DeepImmutable<IVector4Like>,
    max: DeepImmutable<IVector4Like>,
    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
Type Parameters
- T extends IVector4Like
Parameters
- value: DeepImmutable<IVector4Like>
  defines the current value
- min: DeepImmutable<IVector4Like>
  defines the lower range value
- max: DeepImmutable<IVector4Like>
  defines the upper range value
- result: T
  defines the Vector4 where to store the result
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4236

`Static`Distance

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

`Static`DistanceSquared

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

`Static`Dot

Dot(
left: DeepImmutable<IVector4Like>,
right: DeepImmutable<IVector4Like>,
): number
Returns the dot product (float) between the vectors "left" and "right"
Parameters
- left: DeepImmutable<IVector4Like>
  defines the left operand
- right: DeepImmutable<IVector4Like>
  defines the right operand
Returns number
the dot product
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4472

`Static`FromArray

FromArray(array: DeepImmutable<ArrayLike<number>>, offset?: number): Vector4
Returns a new Vector4 set from the starting index of the given array.
Parameters
- array: DeepImmutable<ArrayLike<number>>
  the array to pull values from
- Optionaloffset: number
  the offset into the array to start at
Returns Vector4
the new vector
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4126

`Static`FromArrayToRef

FromArrayToRef<T extends IVector4Like>(
    array: DeepImmutable<ArrayLike<number>>,
    offset: number,
    result: T,
): T
Updates the given vector "result" from the starting index of the given array.
Type Parameters
- T extends IVector4Like
Parameters
- array: DeepImmutable<ArrayLike<number>>
  the array to pull values from
- offset: number
  the offset into the array to start at
- result: T
  the vector to store the result in
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4139

`Static`FromFloatArrayToRef

FromFloatArrayToRef<T extends IVector4Like>(
    array: DeepImmutable<Float32Array>,
    offset: number,
    result: T,
): T
Updates the given vector "result" from the starting index of the given Float32Array.
Type Parameters
- T extends IVector4Like
Parameters
- array: DeepImmutable<Float32Array>
  the array to pull values from
- offset: number
  the offset into the array to start at
- result: T
  the vector to store the result in
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4153

`Static`FromFloatsToRef

FromFloatsToRef<T extends IVector4Like>(
    x: number,
    y: number,
    z: number,
    w: number,
    result: T,
): T
Updates the given vector "result" coordinates from the given floats.
Type Parameters
- T extends IVector4Like
Parameters
- x: number
  float to set from
- y: number
  float to set from
- z: number
  float to set from
- w: number
  float to set from
- result: T
  the vector to the floats in
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4166

`Static`FromVector3

FromVector3(source: Vector3, w?: number): Vector4
Creates a new Vector4 from a Vector3
Parameters
- source: Vector3
  defines the source data
- w: number = 0
  defines the 4th component (default is 0)
Returns Vector4
a new Vector4
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4462

`Static`Maximize

Maximize(
left: DeepImmutable<IVector4Like>,
right: DeepImmutable<IVector4Like>,
): Vector4
Returns a vector with the maximum values from the left and right vectors
Parameters
- left: DeepImmutable<IVector4Like>
  left vector to maximize
- right: DeepImmutable<IVector4Like>
  right vector to maximize
Returns Vector4
a new vector with the maximum of the left and right vector values
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4300

`Static`Minimize

Minimize<T extends Vector4>(
left: DeepImmutable<T>,
right: DeepImmutable<Vector4>,
): Vector4
Returns a vector with the minimum values from the left and right vectors
Type Parameters
- T extends Vector4
Parameters
- left: DeepImmutable<T>
  left vector to minimize
- right: DeepImmutable<Vector4>
  right vector to minimize
Returns Vector4
a new vector with the minimum of the left and right vector values
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4287

`Static`Normalize

Normalize(vector: DeepImmutable<Vector4>): Vector4
Returns a new normalized Vector4 from the given one.
Parameters
- vector: DeepImmutable<Vector4>
  the vector to normalize
Returns Vector4
the vector
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4267

`Static`NormalizeToRef

NormalizeToRef<T extends IVector4Like>(
vector: DeepImmutable<Vector4>,
result: T,
): T
Updates the given vector "result" from the normalization of the given one.
Type Parameters
- T extends IVector4Like
Parameters
- vector: DeepImmutable<Vector4>
  the vector to normalize
- result: T
  the vector to store the result in
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4276

`Static`One

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

Returns Vector4
the new vector
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4184

`Static`Random

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

`Static`RandomToRef

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

`Static`TransformCoordinates

TransformCoordinates(
vector: DeepImmutable<Vector3>,
transformation: DeepImmutable<Matrix>,
): Vector4
Returns a new Vector4 set with the result of the transformation by the given matrix of the given vector. This method computes tranformed coordinates only, not transformed direction vectors (ie. it takes translation in account) The difference with Vector3.TransformCoordinates is that the w component is not used to divide the other coordinates but is returned in the w coordinate instead
Parameters
- vector: DeepImmutable<Vector3>
  defines the Vector3 to transform
- transformation: DeepImmutable<Matrix>
  defines the transformation matrix
Returns Vector4
the transformed Vector4
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4362

`Static`TransformCoordinatesFromFloatsToRef

TransformCoordinatesFromFloatsToRef<T extends IVector4Like>(
    x: number,
    y: number,
    z: number,
    transformation: DeepImmutable<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 tranformed coordinates only, not transformed direction vectors The difference with Vector3.TransformCoordinatesFromFloatsToRef is that the w component is not used to divide the other coordinates but is returned in the w coordinate instead
Type Parameters
- T extends IVector4Like
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: DeepImmutable<Matrix>
  defines the transformation matrix
- result: T
  defines the Vector4 where to store the result
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4391

`Static`TransformCoordinatesToRef

TransformCoordinatesToRef<T extends IVector4Like>(
    vector: DeepImmutable<Vector3>,
    transformation: DeepImmutable<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 tranformed coordinates only, not transformed direction vectors (ie. it takes translation in account) The difference with Vector3.TransformCoordinatesToRef is that the w component is not used to divide the other coordinates but is returned in the w coordinate instead
Type Parameters
- T extends IVector4Like
Parameters
- vector: DeepImmutable<Vector3>
  defines the Vector3 to transform
- transformation: DeepImmutable<Matrix>
  defines the transformation matrix
- result: T
  defines the Vector4 where to store the result
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4375

`Static`TransformNormal

TransformNormal(
vector: DeepImmutable<IVector4Like>,
transformation: DeepImmutable<Matrix>,
): Vector4
Returns a new Vector4 set with the result of the normal transformation by the given matrix of the given vector. This methods computes transformed normalized direction vectors only.
Parameters
- vector: DeepImmutable<IVector4Like>
  the vector to transform
- transformation: DeepImmutable<Matrix>
  the transformation matrix to apply
Returns Vector4
the new vector
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4412

`Static`TransformNormalFromFloatsToRef

TransformNormalFromFloatsToRef<T extends IVector4Like>(
    x: number,
    y: number,
    z: number,
    w: number,
    transformation: DeepImmutable<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, w). This methods computes transformed normalized direction vectors only.
Type Parameters
- T extends IVector4Like
Parameters
- x: number
  value to transform
- y: number
  value to transform
- z: number
  value to transform
- w: number
  value to transform
- transformation: DeepImmutable<Matrix>
  the transformation matrix to apply
- result: T
  the vector to store the results in
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4447

`Static`TransformNormalToRef

TransformNormalToRef<T extends IVector4Like>(
    vector: DeepImmutable<IVector4Like>,
    transformation: DeepImmutable<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.
Type Parameters
- T extends IVector4Like
Parameters
- vector: DeepImmutable<IVector4Like>
  the vector to transform
- transformation: DeepImmutable<Matrix>
  the transformation matrix to apply
- result: T
  the vector to store the result in
Returns T
result input
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4424

`Static`Zero

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

Returns Vector4
the new vector
- Defined in packages/dev/core/src/Maths/math.vector.pure.ts:4177

Class Vector4

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

Returns Vector4

Properties

Readonlydimension

See

Readonlyrank

See

Static_V8PerformanceHack

Accessors

w

Returns number

Parameters

Returns void

x

Returns number

Parameters

Returns void

y

Returns number

Parameters

Returns void

z

Returns number

Parameters

Returns void

StaticZeroReadOnly

Returns DeepImmutable<Vector4>

Methods

add

Parameters

Returns Vector4

addInPlace

Parameters

Returns this

addInPlaceFromFloats

Parameters

Returns this

addToRef

Type Parameters

Parameters

Returns T

asArray

Returns [number, number, number, number]

clone

Returns Vector4

copyFrom

Parameters

Returns this

copyFromFloats

Parameters

Returns this

divide

Parameters

Returns Vector4

divideInPlace

Parameters

Returns this

divideToRef

Type Parameters

Parameters

Returns T

dot

Parameters

Returns number

equals

Parameters

Returns boolean

equalsToFloats

Parameters

Returns boolean

equalsWithEpsilon

`Readonly`dimension

`Readonly`rank

`Static`_V8PerformanceHack

`Static`ZeroReadOnly