kite3d/io.github.yuroyami.kite3d.math/Vector4

Vector4

class Vector4(var x: Double = 0.0, var y: Double = 0.0, var z: Double = 0.0, var w: Double = 1.0) : Iterable<Double>

A 4D vector: an ordered quadruplet of numbers (x, y, z, w).

A 4D vector can hold a point, a direction with a length, or any four numbers. Its length is the distance from (0, 0, 0, 0) to (x, y, z, w).

Vectors are mutable and not thread-safe. Use each instance from one thread only. Most methods change this and return it for chaining.

Iterating a vector yields its components (x, y, z, w) in order.

Note: the w component defaults to 1.0 (matching three.js), unlike the other three components which default to 0.0.

Constructors

constructor(x: Double = 0.0, y: Double = 0.0, z: Double = 0.0, w: Double = 1.0)

Properties

var height: Double

Alias for w.

The w value of this vector.

var width: Double

Alias for z.

The x value of this vector.

The y value of this vector.

The z value of this vector.

Functions

fun add(v: Vector4): Vector4

Adds v to this instance.

fun addScalar(s: Double): Vector4

Adds the scalar s to all components.

addScaledVector

fun addScaledVector(v: Vector4, s: Double): Vector4

Adds v scaled by s to this instance.

fun addVectors(a: Vector4, b: Vector4): Vector4

Sets this vector to a + b.

fun applyMatrix4(m: Matrix4): Vector4

Multiplies this vector by the 4x4 matrix m.

fun ceil(): Vector4

Rounds each component up to the nearest integer.

fun clamp(min: Vector4, max: Vector4): Vector4

Clamps each component into the range [min, max] (assumed component-wise min <= max).

fun clampLength(min: Double, max: Double): Vector4

Clamps this vector's length into [min, max].

fun clampScalar(minVal: Double, maxVal: Double): Vector4

Clamps each component into the scalar range [minVal, maxVal].

fun clone(): Vector4

Returns a new vector with the same components.

fun copy(v: Vector4): Vector4

Copies the components of v into this instance.

fun divide(v: Vector4): Vector4

Divides this instance component-wise by v.

fun divideScalar(scalar: Double): Vector4

Divides all components by scalar.

fun dot(v: Vector4): Double

Returns the dot product of this vector and v.

open operator override fun equals(other: Any?): Boolean

Structural equality: true when other is a Vector4 with equal components (component-wise ==, so NaN != NaN).

fun floor(): Vector4

Rounds each component down to the nearest integer.

fun fromArray(array: DoubleArray, offset: Int = 0): Vector4

Sets x = array[offset], y = array[offset + 1], z = array[offset + 2], w = array[offset + 3].

fromBufferAttribute

fun fromBufferAttribute(attribute: AttributeLike, index: Int): Vector4

Sets this vector's components from attribute at index.

fun getComponent(index: Int): Double

Returns the component at index (0 = x, 1 = y, 2 = z, 3 = w).

open override fun hashCode(): Int

open operator override fun iterator(): Iterator<Double>

fun length(): Double

Returns the Euclidean length of this vector.

fun lengthSq(): Double

Returns the squared Euclidean length of this vector.

fun lerp(v: Vector4, alpha: Double): Vector4

Linearly interpolates from this vector toward v by alpha.

fun lerpVectors(v1: Vector4, v2: Vector4, alpha: Double): Vector4

Sets this vector to the linear interpolation of v1 and v2 by alpha.

manhattanLength

fun manhattanLength(): Double

Returns the Manhattan length of this vector.

fun max(v: Vector4): Vector4

Sets each component to the maximum of itself and v's corresponding component.

fun min(v: Vector4): Vector4

Sets each component to the minimum of itself and v's corresponding component.

fun multiply(v: Vector4): Vector4

Multiplies this instance component-wise by v.

fun multiplyScalar(scalar: Double): Vector4

Multiplies all components by scalar.

fun negate(): Vector4

Negates each component.

fun normalize(): Vector4

Normalizes this vector to unit length (leaves a zero vector unchanged).

fun random(): Vector4

Sets each component to a pseudo-random value in [0, 1).

fun round(): Vector4

Rounds each component to the nearest integer (halves toward +infinity, as JS Math.round).

fun roundToZero(): Vector4

Rounds each component toward zero.

fun set(x: Double, y: Double, z: Double, w: Double): Vector4

Sets the vector components.

setAxisAngleFromQuaternion

fun setAxisAngleFromQuaternion(q: Quaternion): Vector4

Sets the x, y and z components of this vector to the quaternion q's axis and w to the angle.

setAxisAngleFromRotationMatrix

fun setAxisAngleFromRotationMatrix(m: Matrix4): Vector4

Sets the x, y and z components of this vector to the axis of rotation and w to the angle, from the 4x4 matrix m (whose upper-left 3x3 is assumed to be a pure rotation matrix).

fun setComponent(index: Int, value: Double): Vector4

Sets the component at index (0 = x, 1 = y, 2 = z, 3 = w) to value.

setFromMatrixPosition

fun setFromMatrixPosition(m: Matrix4): Vector4

Sets the vector components to the position elements of the transformation matrix m.

fun setLength(length: Double): Vector4

Sets this vector's length to length, preserving direction.

fun setScalar(scalar: Double): Vector4

Sets all vector components to scalar.

fun setW(w: Double): Vector4

Sets the vector's w component.

fun setX(x: Double): Vector4

Sets the vector's x component.

fun setY(y: Double): Vector4

Sets the vector's y component.

fun setZ(z: Double): Vector4

Sets the vector's z component.

fun sub(v: Vector4): Vector4

Subtracts v from this instance.

fun subScalar(s: Double): Vector4

Subtracts the scalar s from all components.

fun subVectors(a: Vector4, b: Vector4): Vector4

Sets this vector to a - b.

fun toArray(array: MutableList<Double> = mutableListOf(), offset: Int = 0): MutableList<Double>

Writes this vector's components into array at offset, growing the list as needed, and returns it.

open override fun toString(): String