Class Vector4

Immutable 4D(x,y,z,w) Vector class with 32-bit float components.

This class provides comprehensive vector operations for 4-dimensional mathematics, commonly used in graphics programming for representing positions, directions, colors (RGBA), and homogeneous coordinates.

All operations return new vector instances, preserving immutability. For performance-critical applications where mutation is acceptable, consider using the corresponding mutable vector types or the *To methods.

Example: Basic usage:

const vec1 = Vector4.fromCopy4(1, 2, 3, 1);
const vec2 = Vector4.fromCopyArray4([2, 3, 3, 1]);
const dotProduct = vec1.dot(vec2);
const sum = Vector4.add(vec1, vec2);

Example: Creating vectors from different sources:

const fromArray = Vector4.fromCopyArray([1, 2, 3, 4, 5]); // Takes first 4 elements
const fromVec3 = Vector4.fromCopyVector3(someVector3); // W component set to 1
const zero = Vector4.zero();
const normalized = Vector4.normalize(someVector);

Hierarchy (view full)

Constructors

constructor

Properties

_v

Accessors

bytesPerComponent className glslStrAsFloat glslStrAsInt w wgslStrAsFloat wgslStrAsInt x y z compositionType

Methods

at clone dot flattenAsArray isDummy isEqual isStrictEqual isTheSourceSame length lengthSquared lengthTo toString toStringApproximately v _add _divide _divideVector _dummy _fromCopy4 _fromCopyArray _fromCopyArray4 _fromCopyVector3 _fromCopyVector4 _fromVector2 _multiply _multiplyVector _normalize _one _subtract _zero add addTo divide divideTo divideVector divideVectorTo dot dummy fromArrayBuffer fromCopy4 fromCopyArray fromCopyArray4 fromCopyFloat32Array fromCopyVector3 fromCopyVector4 fromFloat32Array lengthBtw lengthSquared multiply multiplyTo multiplyVector multiplyVectorTo normalize one subtract subtractTo zero

Constructors

constructor

Properties

_v

_v: TypedArray = ...

Internal typed array storage for vector components

Accessors

bytesPerComponent

  • get bytesPerComponent(): number

  • Gets the number of bytes per component in the underlying typed array.

    Returns number

    The number of bytes per element (4 for Float32Array, 8 for Float64Array)

className

  • get className(): string

  • Gets the class name of this vector type.

    Returns string

    The string "Vector4"

glslStrAsFloat

  • get glslStrAsFloat(): string

  • Converts the vector to a GLSL vec4 string representation with float precision.

    Returns string

    A GLSL-compatible vec4 string (e.g., "vec4(1.0, 2.0, 3.0, 4.0)")

glslStrAsInt

  • get glslStrAsInt(): string

  • Converts the vector to a GLSL ivec4 string representation with integer values.

    Returns string

    A GLSL-compatible ivec4 string (e.g., "ivec4(1, 2, 3, 4)")

w

  • get w(): number

  • Gets the W component of the vector.

    Returns number

    The W component value

wgslStrAsFloat

  • get wgslStrAsFloat(): string

  • Converts the vector to a WGSL vec4f string representation with float precision.

    Returns string

    A WGSL-compatible vec4f string (e.g., "vec4f(1.0, 2.0, 3.0, 4.0)")

wgslStrAsInt

  • get wgslStrAsInt(): string

  • Converts the vector to a WGSL vec4i string representation with integer values.

    Returns string

    A WGSL-compatible vec4i string (e.g., "vec4i(1, 2, 3, 4)")

x

  • get x(): number

  • Gets the X component of the vector.

    Returns number

    The X component value

y

  • get y(): number

  • Gets the Y component of the vector.

    Returns number

    The Y component value

z

  • get z(): number

  • Gets the Z component of the vector.

    Returns number

    The Z component value

StaticcompositionType

  • get compositionType(): CompositionTypeClass<"VEC4">

  • Gets the composition type identifier for this vector type.

    Returns CompositionTypeClass<"VEC4">

    The CompositionType.Vec4 identifier

    Static

Methods

at

  • at(i): number

  • Gets the component value at the specified index.

    Parameters

    • i: number

      The index (0=x, 1=y, 2=z, 3=w)

    Returns number

    The component value at the specified index

clone

dot

  • dot(vec): number

  • Calculates the dot product between this vector and another vector. The dot product is the sum of the products of corresponding components.

    Parameters

    • vec: IVector4

      The vector to calculate dot product with

    Returns number

    The dot product of the two vectors

flattenAsArray

isDummy

isEqual

  • isEqual(vec, delta?): boolean

  • Checks if this vector is approximately equal to another vector within a specified tolerance.

    Parameters

    • vec: IVector4

      The vector to compare with

    • delta: number = Number.EPSILON

      The tolerance value for comparison (default: Number.EPSILON)

    Returns boolean

    True if the vectors are approximately equal, false otherwise

isStrictEqual

  • isStrictEqual(vec): boolean

  • Checks if this vector is strictly equal to another vector (exact component equality).

    Parameters

    • vec: IVector4

      The vector to compare with

    Returns boolean

    True if all components are exactly equal, false otherwise

isTheSourceSame

  • isTheSourceSame(arrayBuffer): boolean

  • Checks if the internal storage shares the same ArrayBuffer as the provided one. Useful for determining if vectors share underlying memory.

    Parameters

    • arrayBuffer: ArrayBuffer

      The ArrayBuffer to compare against

    Returns boolean

    True if the same ArrayBuffer is used, false otherwise

length

lengthSquared

  • lengthSquared(): number

  • Calculates the squared length (magnitude) of the vector. This is more efficient than length() when only comparing magnitudes.

    Returns number

    The squared length of the vector

lengthTo

  • lengthTo(vec): number

  • Calculates the distance from this vector to another vector.

    Parameters

    • vec: IVector4

      The target vector to calculate distance to

    Returns number

    The distance between the two vectors

toString

toStringApproximately

  • toStringApproximately(): string

  • Converts the vector to an approximately formatted string representation with financial precision. Each component is formatted to a fixed number of decimal places.

    Returns string

    A string with space-separated components followed by a newline

v

  • v(i): number

  • Gets the component value at the specified index. Alias for the at() method for convenience.

    Parameters

    • i: number

      The index of the component to retrieve

    Returns number

    The component value at the given index

Static_add

Static_divide

Static_divideVector

Static_dummy

Static_fromCopy4

Static_fromCopyArray

Static_fromCopyArray4

Static_fromCopyVector3

Static_fromCopyVector4

Static_fromVector2

Static_multiply

Static_multiplyVector

Static_normalize

Static_one

Static_subtract

Static_zero

Staticadd

StaticaddTo

Staticdivide

  • divide(vec, value): Vector4

  • Divides a vector by a scalar value and returns a new vector. If the divisor is zero, the result components will be set to Infinity and an error will be logged.

    Parameters

    • vec: IVector4

      The vector to divide

    • value: number

      The scalar value to divide by

    Returns Vector4

    A new Vector4 with each component divided by the scalar

    Static

StaticdivideTo

  • divideTo(vec, value, out): IMutableVector4

  • Divides a vector by a scalar value and stores the result in the output vector. If the divisor is zero, the result components will be set to Infinity and an error will be logged. This method modifies the output vector in-place for better performance.

    Parameters

    • vec: IVector4

      The vector to divide

    • value: number

      The scalar value to divide by

    • out: IMutableVector4

      The output vector to store the result (will be modified)

    Returns IMutableVector4

    The modified output vector with each component divided by the scalar

    Static

StaticdivideVector

  • divideVector(l_vec, r_vec): Vector4

  • Divides the left vector by the right vector component-wise and returns a new vector. If any component of the right vector is zero, the corresponding result component will be set to Infinity.

    Parameters

    • l_vec: IVector4

      The left operand vector (dividend)

    • r_vec: IVector4

      The right operand vector (divisor)

    Returns Vector4

    A new Vector4 with component-wise division result

    Static

StaticdivideVectorTo

  • divideVectorTo(l_vec, r_vec, out): IMutableVector4

  • Divides the left vector by the right vector component-wise and stores the result in the output vector. If any component of the right vector is zero, the corresponding result component will be set to Infinity. This method modifies the output vector in-place for better performance.

    Parameters

    • l_vec: IVector4

      The left operand vector (dividend)

    • r_vec: IVector4

      The right operand vector (divisor)

    • out: IMutableVector4

      The output vector to store the result (will be modified)

    Returns IMutableVector4

    The modified output vector with component-wise division result

    Static

Staticdot

  • dot(l_vec, r_vec): number

  • Calculates the dot product of two vectors. The dot product is the sum of the products of corresponding components.

    Parameters

    Returns number

    The dot product of the two vectors

    Static

Staticdummy

  • dummy(): Vector4

  • Creates a dummy vector with no components (empty array). This is used as a placeholder when a vector is needed but not yet initialized.

    Returns Vector4

    A new dummy Vector4 with empty components

    Static

StaticfromArrayBuffer

  • fromArrayBuffer(arrayBuffer): Vector4

  • Creates a new Vector4 from an ArrayBuffer. The ArrayBuffer should contain at least 16 bytes (4 float32 values).

    Parameters

    • arrayBuffer: ArrayBuffer

      The ArrayBuffer containing vector data

    Returns Vector4

    A new Vector4 instance using the ArrayBuffer data

    Static

StaticfromCopy4

  • fromCopy4(x, y, z, w): Vector4

  • Creates a new Vector4 from individual component values.

    Parameters

    • x: number

      The X component value

    • y: number

      The Y component value

    • z: number

      The Z component value

    • w: number

      The W component value

    Returns Vector4

    A new Vector4 instance with the specified component values

    Static

StaticfromCopyArray

  • fromCopyArray(array): Vector4

  • Creates a new Vector4 by copying values from an array. Takes the first 4 elements from the array. If the array has fewer than 4 elements, the remaining components will be undefined.

    Parameters

    • array: number[]

      Array containing numeric values (at least 4 elements recommended)

    Returns Vector4

    A new Vector4 instance with copied values

    Static

StaticfromCopyArray4

  • fromCopyArray4(array): Vector4

  • Creates a new Vector4 from a 4-element array by copying the values.

    Parameters

    • array: Array4<number>

      Array containing exactly 4 numeric values [x, y, z, w]

    Returns Vector4

    A new Vector4 instance with the copied values

    Static

StaticfromCopyFloat32Array

  • fromCopyFloat32Array(float32Array): Vector4

  • Creates a new Vector4 by copying from a Float32Array. This creates a new Float32Array copy of the input data.

    Parameters

    • float32Array: Float32Array

      The Float32Array to copy from

    Returns Vector4

    A new Vector4 instance with copied Float32Array data

    Static

StaticfromCopyVector3

  • fromCopyVector3(vec3): Vector4

  • Creates a new Vector4 from a Vector3, setting the W component to 1. This is commonly used for converting 3D positions to homogeneous coordinates.

    Parameters

    • vec3: IVector3

      The source Vector3 to copy from

    Returns Vector4

    A new Vector4 with (vec3.x, vec3.y, vec3.z, 1.0)

    Static

StaticfromCopyVector4

  • fromCopyVector4(vec4): Vector4

  • Creates a new Vector4 by copying values from another Vector4.

    Parameters

    • vec4: IVector4

      The source Vector4 to copy from

    Returns Vector4

    A new Vector4 instance with copied values from the source vector

    Static

StaticfromFloat32Array

  • fromFloat32Array(float32Array): Vector4

  • Creates a new Vector4 from a Float32Array. The Float32Array is used directly without copying.

    Parameters

    • float32Array: Float32Array

      The Float32Array containing vector components

    Returns Vector4

    A new Vector4 instance using the provided Float32Array

    Static

StaticlengthBtw

StaticlengthSquared

  • lengthSquared(vec): number

  • Calculates the squared length (magnitude) of a vector. This is more efficient than length() when only comparing magnitudes.

    Parameters

    • vec: IVector4

      The vector to calculate squared length for

    Returns number

    The squared length of the vector

    Static

Staticmultiply

  • multiply(vec, value): Vector4

  • Multiplies a vector by a scalar value and returns a new vector. This operation scales the vector while preserving its direction.

    Parameters

    • vec: IVector4

      The vector to multiply

    • value: number

      The scalar value to multiply by

    Returns Vector4

    A new Vector4 with each component multiplied by the scalar

    Static

StaticmultiplyTo

  • multiplyTo(vec, value, out): IMutableVector4

  • Multiplies a vector by a scalar value and stores the result in the output vector. This method modifies the output vector in-place for better performance.

    Parameters

    • vec: IVector4

      The vector to multiply

    • value: number

      The scalar value to multiply by

    • out: IMutableVector4

      The output vector to store the result (will be modified)

    Returns IMutableVector4

    The modified output vector with each component multiplied by the scalar

    Static

StaticmultiplyVector

  • multiplyVector(l_vec, r_vec): Vector4

  • Multiplies two vectors component-wise and returns a new vector. This is also known as the Hadamard product or element-wise multiplication.

    Parameters

    Returns Vector4

    A new Vector4 with each component being the product of corresponding components

    Static

StaticmultiplyVectorTo

Staticnormalize

  • normalize(vec): Vector4

  • Creates a normalized version of the given vector. A normalized vector has a length of 1 while maintaining its direction.

    Parameters

    Returns Vector4

    A new normalized Vector4

    Static

Staticone

Staticsubtract

  • subtract(l_vec, r_vec): Vector4

  • Subtracts the right vector from the left vector component-wise and returns a new vector.

    Parameters

    • l_vec: IVector4

      The left operand vector (minuend)

    • r_vec: IVector4

      The right operand vector (subtrahend)

    Returns Vector4

    A new Vector4 containing the difference (l_vec - r_vec)

    Static

StaticsubtractTo

  • subtractTo(l_vec, r_vec, out): IMutableVector4

  • Subtracts the right vector from the left vector component-wise and stores the result in the output vector. This method modifies the output vector in-place for better performance.

    Parameters

    • l_vec: IVector4

      The left operand vector (minuend)

    • r_vec: IVector4

      The right operand vector (subtrahend)

    • out: IMutableVector4

      The output vector to store the result (will be modified)

    Returns IMutableVector4

    The modified output vector containing the difference

    Static

Staticzero

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods