kite3d/io.github.yuroyami.kite3d.math/Vector3

Vector3

class Vector3(var x: Double = 0.0, var y: Double = 0.0, var z: Double = 0.0) : Iterable<Double>

A 3D vector: an ordered triplet of numbers (x, y, z).

A 3D vector can represent a point in 3D space, a direction and length in 3D space (the length being the Euclidean distance from (0, 0, 0) to (x, y, z)), or any arbitrary ordered triplet 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) in order.

Constructors

Vector3

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

Properties

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: Vector3): Vector3

Adds v to this instance.

addScalar

fun addScalar(s: Double): Vector3

Adds the scalar s to all components.

addScaledVector

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

Adds v scaled by s to this instance.

addVectors

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

Sets this vector to a + b.

angleTo

fun angleTo(v: Vector3): Double

Returns the angle between this vector and v, in radians.

applyAxisAngle

fun applyAxisAngle(axis: Vector3, angle: Double): Vector3

Applies a rotation specified by axis (a normalized vector) and angle (in radians) to this vector.

applyEuler

fun applyEuler(euler: Euler): Vector3

Applies the Euler rotation euler to this vector.

applyMatrix3

fun applyMatrix3(m: Matrix3): Vector3

Multiplies this vector by the 3x3 matrix m.

applyMatrix4

fun applyMatrix4(m: Matrix4): Vector3

Multiplies this vector (with an implicit 1 in the 4th dimension) by m, and divides by perspective.

applyNormalMatrix

fun applyNormalMatrix(m: Matrix3): Vector3

Multiplies this vector by the normal matrix m and normalizes the result.

applyQuaternion

fun applyQuaternion(q: Quaternion): Vector3

Applies the Quaternion q (assumed to have unit length) to this vector.

ceil

fun ceil(): Vector3

Rounds each component up to the nearest integer.

clamp

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

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

clampLength

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

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

clampScalar

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

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

clone

fun clone(): Vector3

Returns a new vector with the same components.

copy

fun copy(v: Vector3): Vector3

Copies the components of v into this instance.

cross

fun cross(v: Vector3): Vector3

Sets this vector to the cross product of this vector and v.

crossVectors

fun crossVectors(a: Vector3, b: Vector3): Vector3

Sets this vector to the cross product of a and b.

distanceTo

fun distanceTo(v: Vector3): Double

Returns the distance from this vector to v.

distanceToSquared

fun distanceToSquared(v: Vector3): Double

Returns the squared distance from this vector to v.

divide

fun divide(v: Vector3): Vector3

Divides this instance component-wise by v.

divideScalar

fun divideScalar(scalar: Double): Vector3

Divides all components by scalar.

dot

fun dot(v: Vector3): 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 Vector3 with equal components (component-wise ==, so NaN != NaN).

floor

fun floor(): Vector3

Rounds each component down to the nearest integer.

fromArray

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

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

fromBufferAttribute

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

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

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: Vector3, alpha: Double): Vector3

Linearly interpolates from this vector toward v by alpha.

lerpVectors

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

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

manhattanDistanceTo

fun manhattanDistanceTo(v: Vector3): Double

Returns the Manhattan distance from this vector to v.

manhattanLength

fun manhattanLength(): Double

Returns the Manhattan length of this vector.

max

fun max(v: Vector3): Vector3

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

min

fun min(v: Vector3): Vector3

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

multiply

fun multiply(v: Vector3): Vector3

Multiplies this instance component-wise by v.

multiplyScalar

fun multiplyScalar(scalar: Double): Vector3

Multiplies all components by scalar.

multiplyVectors

fun multiplyVectors(a: Vector3, b: Vector3): Vector3

Sets this vector to a * b (component-wise).

negate

fun negate(): Vector3

Negates each component.

normalize

fun normalize(): Vector3

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

projectOnPlane

fun projectOnPlane(planeNormal: Vector3): Vector3

Projects this vector onto the plane with normal planeNormal (by subtracting this vector's projection onto the normal). Leaves the vector unchanged when planeNormal is a zero vector.

projectOnVector