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 represent a point in 4D space, a direction and length in 4D space (the length being the Euclidean distance from (0, 0, 0, 0) to (x, y, z, w)), or any arbitrary ordered quadruplet of numbers.

Vectors are mutable and not thread-safe; confine an instance (and any object graph holding it) to a single thread, exactly as in three.js. Most methods mutate 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

Vector4

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

Properties

height

var height: Double

Alias for w.

var w: Double

The w value of this vector.

width

var width: Double

Alias for z.

var x: Double

The x value of this vector.

var y: Double

The y value of this vector.

var z: Double

The z value of this vector.

Functions

add

fun add(v: Vector4): Vector4

Adds v to this instance.

addScalar

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.

addVectors

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

Sets this vector to a + b.

applyMatrix4

fun applyMatrix4(m: Matrix4): Vector4

Multiplies this vector by the 4x4 matrix m.

ceil

fun ceil(): Vector4

Rounds each component up to the nearest integer.

clamp

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

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

clampLength

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

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

clampScalar

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

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

clone

fun clone(): Vector4

Returns a new vector with the same components.

copy

fun copy(v: Vector4): Vector4

Copies the components of v into this instance.

divide

fun divide(v: Vector4): Vector4

Divides this instance component-wise by v.

divideScalar

fun divideScalar(scalar: Double): Vector4

Divides all components by scalar.

dot

fun dot(v: Vector4): Double

Returns the dot product of this vector and v.

equals

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

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

floor

fun floor(): Vector4

Rounds each component down to the nearest integer.

fromArray

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.

getComponent

fun getComponent(index: Int): Double

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

hashCode

open override fun hashCode(): Int

iterator

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

length

fun length(): Double

Returns the Euclidean length of this vector.

lengthSq

fun lengthSq(): Double

Returns the squared Euclidean length of this vector.

lerp

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

Linearly interpolates from this vector toward v by alpha.

lerpVectors

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.

max

fun max(v: Vector4): Vector4

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

min

fun min(v: Vector4): Vector4

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

multiply

fun multiply(v: Vector4): Vector4

Multiplies this instance component-wise by v.

multiplyScalar

fun multiplyScalar(scalar: Double): Vector4

Multiplies all components by scalar.

negate

fun negate(): Vector4

Negates each component.

normalize

fun normalize(): Vector4

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

random

fun random(): Vector4

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

round

fun round(): Vector4

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

roundToZero

fun roundToZero(): Vector4

Rounds each component toward zero.

set

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).