kotlin-math/dev.romainguy.kotlin.math

Package-level declarations

Types

Bool2

data class Bool2(var x: Boolean = false, var y: Boolean = false)

Bool3

data class Bool3(var x: Boolean = false, var y: Boolean = false, var z: Boolean = false)

Bool4

data class Bool4(var x: Boolean = false, var y: Boolean = false, var z: Boolean = false, var w: Boolean = false)

Float2

data class Float2(var x: Float = 0.0f, var y: Float = 0.0f)

Float3

data class Float3(var x: Float = 0.0f, var y: Float = 0.0f, var z: Float = 0.0f)

Float4

data class Float4(var x: Float = 0.0f, var y: Float = 0.0f, var z: Float = 0.0f, var w: Float = 0.0f)

Half

@JvmInline

value class Half(v: UShort) : Comparable<Half>

The Half class is a wrapper and a utility class to manipulate half-precision 16-bit IEEE 754 floating point data types (also called fp16 or binary16). A half-precision float can be created from or converted to single-precision floats, and is stored in a short data type.

Half2

data class Half2(var x: Half = Half.POSITIVE_ZERO, var y: Half = Half.POSITIVE_ZERO)

Half3

data class Half3(var x: Half = Half.POSITIVE_ZERO, var y: Half = Half.POSITIVE_ZERO, var z: Half = Half.POSITIVE_ZERO)

Half4

data class Half4(var x: Half = Half.POSITIVE_ZERO, var y: Half = Half.POSITIVE_ZERO, var z: Half = Half.POSITIVE_ZERO, var w: Half = Half.POSITIVE_ZERO)

Mat2

data class Mat2(var x: Float2 = Float2(x = 1.0f), var y: Float2 = Float2(y = 1.0f))

Mat3

data class Mat3(var x: Float3 = Float3(x = 1.0f), var y: Float3 = Float3(y = 1.0f), var z: Float3 = Float3(z = 1.0f))

Mat4

data class Mat4(var x: Float4 = Float4(x = 1.0f), var y: Float4 = Float4(y = 1.0f), var z: Float4 = Float4(z = 1.0f), var w: Float4 = Float4(w = 1.0f))

MatrixColumn

enum MatrixColumn : Enum<MatrixColumn>

Quaternion

data class Quaternion(var x: Float = 0.0f, var y: Float = 0.0f, var z: Float = 0.0f, var w: Float = 1.0f)

Construct Quaternion and set each value. The Quaternion will be normalized during construction Default: Identity

QuaternionComponent

enum QuaternionComponent : Enum<QuaternionComponent>

Rational

@JvmInline

value class Rational(r: Long) : Comparable<Rational>

Ray

data class Ray(var origin: Float3 = Float3(), var direction: Float3)

RotationsOrder

enum RotationsOrder : Enum<RotationsOrder>

VectorComponent

enum VectorComponent : Enum<VectorComponent>

Functions

abs

inline fun abs(v: Float2): Float2

inline fun abs(v: Float3): Float3

inline fun abs(v: Float4): Float4

inline fun abs(v: Half3): Half3

inline fun abs(v: Half4): Half4

inline fun abs(q: Quaternion): Quaternion

fun abs(x: Half): Half

Returns the absolute value of the specified half-precision float. Special values are handled in the following ways:

all

inline fun all(v: Bool2): Boolean

inline fun all(v: Bool3): Boolean

inline fun all(v: Bool4): Boolean

angle

inline fun angle(a: Float2, b: Float2): Float

inline fun angle(a: Float3, b: Float3): Float

fun angle(a: Quaternion, b: Quaternion): Float

any

inline fun any(v: Bool2): Boolean

inline fun any(v: Bool3): Boolean

inline fun any(v: Bool4): Boolean

ceil

fun ceil(x: Half): Half

Returns the smallest half-precision float value toward negative infinity greater than or equal to the specified half-precision float value. Special values are handled in the following ways:

clamp

inline fun clamp(v: Float2, min: Float2, max: Float2): Float2

inline fun clamp(v: Float2, min: Float, max: Float): Float2

inline fun clamp(v: Float3, min: Float3, max: Float3): Float3

inline fun clamp(v: Float3, min: Float, max: Float): Float3

inline fun clamp(v: Float4, min: Float4, max: Float4): Float4

inline fun clamp(v: Float4, min: Float, max: Float): Float4

inline fun clamp(x: Half, min: Half, max: Half): Half

inline fun clamp(v: Half3, min: Half, max: Half): Half3

inline fun clamp(v: Half3, min: Half3, max: Half3): Half3

inline fun clamp(v: Half4, min: Half, max: Half): Half4

inline fun clamp(v: Half4, min: Half4, max: Half4): Half4

inline fun clamp(x: Float, min: Float, max: Float): Float

conjugate

fun conjugate(q: Quaternion): Quaternion

cross

inline fun cross(a: Float3, b: Float3): Float3

inline fun cross(a: Half3, b: Half3): Half3

fun cross(a: Quaternion, b: Quaternion): Quaternion

degrees

inline fun degrees(v: Float): Float

distance

inline fun distance(a: Float2, b: Float2): Float

inline fun distance(a: Float3, b: Float3): Float

inline fun distance(a: Float4, b: Float4): Float

inline fun distance(a: Half3, b: Half3): Half

inline fun distance(a: Half4, b: Half4): Half

div

inline operator fun Half.div(v: Half3): Half3

inline operator fun Half.div(v: Half4): Half4

inline operator fun Float.div(v: Float2): Float2

inline operator fun Float.div(v: Float3): Float3

inline operator fun Float.div(v: Float4): Float4

inline operator fun Float.div(q: Quaternion): Quaternion

dot

inline fun dot(a: Float2, b: Float2): Float

inline fun dot(a: Float3, b: Float3): Float

inline fun dot(a: Float4, b: Float4): Float

inline fun dot(a: Half3, b: Half3): Half

inline fun dot(a: Half4, b: Half4): Half

inline fun dot(a: Quaternion, b: Quaternion): Float

infix inline fun Float2.eq(b: Float2): Bool2

infix inline fun Float2.eq(b: Float): Bool2

infix inline fun Float3.eq(b: Float3): Bool3

infix inline fun Float3.eq(b: Float): Bool3

infix inline fun Float4.eq(b: Float4): Bool4

infix inline fun Float4.eq(b: Float): Bool4

infix inline fun Half2.eq(b: Half): Bool2

infix inline fun Half2.eq(b: Half2): Bool2

infix inline fun Half3.eq(b: Half): Bool3

infix inline fun Half3.eq(b: Half3): Bool3

infix inline fun Half4.eq(b: Half): Bool4

infix inline fun Half4.eq(b: Half4): Bool4

equal

inline fun equal(a: Float2, b: Float2): Bool2

inline fun equal(a: Float2, b: Float): Bool2

inline fun equal(a: Float3, b: Float3): Bool3

inline fun equal(a: Float3, b: Float): Bool3

inline fun equal(a: Float4, b: Float4): Bool4

inline fun equal(a: Float4, b: Float): Bool4

inline fun equal(a: Half2, b: Half): Bool2

inline fun equal(a: Half2, b: Half2): Bool2

inline fun equal(a: Half3, b: Half): Bool3

inline fun equal(a: Half3, b: Half3): Bool3

inline fun equal(a: Half4, b: Half): Bool4

inline fun equal(a: Half4, b: Half4): Bool4

eulerAngles

fun eulerAngles(m: Mat4, order: RotationsOrder = RotationsOrder.ZYX): Float3

Get the Euler angles in degrees from a rotation Matrix

fun eulerAngles(q: Quaternion, order: RotationsOrder = RotationsOrder.ZYX): Float3

Convert a Quaternion to Euler angles

floor

fun floor(x: Half): Half

Returns the largest half-precision float value toward positive infinity less than or equal to the specified half-precision float value. Special values are handled in the following ways:

fract

inline fun fract(v: Float): Float

greaterThan

inline fun greaterThan(a: Float2, b: Float2): Bool2

inline fun greaterThan(a: Float2, b: Float): Bool2

inline fun greaterThan(a: Float3, b: Float3): Bool3

inline fun greaterThan(a: Float3, b: Float): Bool3

inline fun greaterThan(a: Float4, b: Float4): Bool4

inline fun greaterThan(a: Float4, b: Float): Bool4

inline fun greaterThan(a: Half2, b: Half): Bool2

inline fun greaterThan(a: Half2, b: Half2): Bool2

inline fun greaterThan(a: Half3, b: Half): Bool3

inline fun greaterThan(a: Half3, b: Half3): Bool3

inline fun greaterThan(a: Half4, b: Half): Bool4

inline fun greaterThan(a: Half4, b: Half4): Bool4

greaterThanEqual

inline fun greaterThanEqual(a: Float2, b: Float2): Bool2

inline fun greaterThanEqual(a: Float2, b: Float): Bool2

inline fun greaterThanEqual(a: Float3, b: Float3): Bool3

inline fun greaterThanEqual(a: Float3, b: Float): Bool3

inline fun greaterThanEqual(a: Float4, b: Float4): Bool4

inline fun greaterThanEqual(a: Float4, b: Float): Bool4

inline fun greaterThanEqual(a: Half2, b: Half): Bool2

inline fun greaterThanEqual(a: Half2, b: Half2): Bool2

inline fun greaterThanEqual(a: Half3, b: Half): Bool3

inline fun greaterThanEqual(a: Half3, b: Half3): Bool3

inline fun greaterThanEqual(a: Half4, b: Half): Bool4

inline fun greaterThanEqual(a: Half4, b: Half4): Bool4

infix inline fun Float2.gt(b: Float2): Bool2

infix inline fun Float2.gt(b: Float): Bool2

infix inline fun Float3.gt(b: Float3): Bool3

infix inline fun Float3.gt(b: Float): Bool3

infix inline fun Float4.gt(b: Float4): Bool4

infix inline fun Float4.gt(b: Float): Bool4

infix inline fun Half2.gt(b: Half): Bool2

infix inline fun Half2.gt(b: Half2): Bool2

infix inline fun Half3.gt(b: Half): Bool3

infix inline fun Half3.gt(b: Half3): Bool3

infix inline fun Half4.gt(b: Half): Bool4

infix inline fun Half4.gt(b: Half4): Bool4

gte

infix inline fun Float2.gte(b: Float2): Bool2

infix inline fun Float2.gte(b: Float): Bool2

infix inline fun Float3.gte(b: Float3): Bool3

infix inline fun Float3.gte(b: Float): Bool3

infix inline fun Float4.gte(b: Float4): Bool4

infix inline fun Float4.gte(b: Float): Bool4

infix inline fun Half2.gte(b: Half): Bool2

infix inline fun Half2.gte(b: Half2): Bool2

infix inline fun Half3.gte(b: Half): Bool3

infix inline fun Half3.gte(b: Half3): Bool3

infix inline fun Half4.gte(b: Half): Bool4

infix inline fun Half4.gte(b: Half4): Bool4

Half

fun Half(value: Double): Half

Converts the specified double-precision float value into a half-precision float value. The following special cases are handled:

fun Half(value: Float): Half

Converts the specified single-precision float value into a half-precision float value. The following special cases are handled:

fun Half(value: String): Half

Returns the half-precision float value represented by the specified string. The string is converted to a half-precision float value as if by the String.toFloat() method.

inverse

fun inverse(m: Mat3): Mat3

fun inverse(m: Mat4): Mat4

fun inverse(q: Quaternion): Quaternion

length

inline fun length(v: Float2): Float

inline fun length(v: Float3): Float

inline fun length(v: Float4): Float

inline fun length(v: Half3): Half

inline fun length(v: Half4): Half

inline fun length(q: Quaternion): Float

length2

inline fun length2(v: Float2): Float

inline fun length2(v: Float3): Float

inline fun length2(v: Float4): Float

inline fun length2(v: Half3): Half

inline fun length2(v: Half4): Half

inline fun length2(q: Quaternion): Float

lerp

fun lerp(a: Quaternion, b: Quaternion, t: Float): Quaternion

lessThan

inline fun lessThan(a: Float2, b: Float2): Bool2

inline fun lessThan(a: Float2, b: Float): Bool2

inline fun lessThan(a: Float3, b: Float3): Bool3

inline fun lessThan(a: Float3, b: Float): Bool3

inline fun lessThan(a: Float4, b: Float4): Bool4

inline fun lessThan(a: Float4, b: Float): Bool4

inline fun lessThan(a: Half2, b: Half): Bool2

inline fun lessThan(a: Half2, b: Half2): Bool2

inline fun lessThan(a: Half3, b: Half): Bool3

inline fun lessThan(a: Half3, b: Half3): Bool3

inline fun lessThan(a: Half4, b: Half): Bool4

inline fun lessThan(a: Half4, b: Half4): Bool4

lessThanEqual

inline fun lessThanEqual(a: Float2, b: Float2): Bool2

inline fun lessThanEqual(a: Float2, b: Float): Bool2

inline fun lessThanEqual(a: Float3, b: Float3): Bool3

inline fun lessThanEqual(a: Float3, b: Float): Bool3

inline fun lessThanEqual(a: Float4, b: Float4): Bool4

inline fun lessThanEqual(a: Float4, b: Float): Bool4

inline fun lessThanEqual(a: Half2, b: Half): Bool2

inline fun lessThanEqual(a: Half2, b: Half2): Bool2

inline fun lessThanEqual(a: Half3, b: Half): Bool3

inline fun lessThanEqual(a: Half3, b: Half3): Bool3

inline fun lessThanEqual(a: Half4, b: Half): Bool4

inline fun lessThanEqual(a: Half4, b: Half4): Bool4

lookAt

fun lookAt(eye: Float3, target: Float3, up: Float3 = Float3(z = 1.0f)): Mat4

lookTowards

fun lookTowards(eye: Float3, forward: Float3, up: Float3 = Float3(z = 1.0f)): Mat4

infix inline fun Float2.lt(b: Float2): Bool2

infix inline fun Float2.lt(b: Float): Bool2

infix inline fun Float3.lt(b: Float3): Bool3

infix inline fun Float3.lt(b: Float): Bool3

infix inline fun Float4.lt(b: Float4): Bool4

infix inline fun Float4.lt(b: Float): Bool4

infix inline fun Half2.lt(b: Half): Bool2

infix inline fun Half2.lt(b: Half2): Bool2

infix inline fun Half3.lt(b: Half): Bool3

infix inline fun Half3.lt(b: Half3): Bool3

infix inline fun Half4.lt(b: Half): Bool4

infix inline fun Half4.lt(b: Half4): Bool4

lte

infix inline fun Float2.lte(b: Float2): Bool2

infix inline fun Float2.lte(b: Float): Bool2

infix inline fun Float3.lte(b: Float3): Bool3

infix inline fun Float3.lte(b: Float): Bool3

infix inline fun Float4.lte(b: Float4): Bool4

infix inline fun Float4.lte(b: Float): Bool4

infix inline fun Half2.lte(b: Half): Bool2

infix inline fun Half2.lte(b: Half2): Bool2

infix inline fun Half3.lte(b: Half): Bool3

infix inline fun Half3.lte(b: Half3): Bool3

infix inline fun Half4.lte(b: Half): Bool4

infix inline fun Half4.lte(b: Half4): Bool4

max

inline fun max(v: Float2): Float

inline fun max(v: Float3): Float

inline fun max(v: Float4): Float

inline fun max(v: Half2): Half

inline fun max(v: Half3): Half

inline fun max(v: Half4): Half

inline fun max(a: Float2, b: Float2): Float2

inline fun max(a: Float3, b: Float3): Float3

inline fun max(a: Float4, b: Float4): Float4

inline fun max(a: Half2, b: Half2): Half2

inline fun max(a: Half3, b: Half3): Half3

inline fun max(a: Half4, b: Half4): Half4

fun max(x: Half, y: Half): Half

Returns the larger of two half-precision float values (the value closest to positive infinity). Special values are handled in the following ways:

min

inline fun min(v: Float2): Float

inline fun min(v: Float3): Float

inline fun min(v: Float4): Float

inline fun min(v: Half2): Half

inline fun min(v: Half3): Half

inline fun min(v: Half4): Half

inline fun min(a: Float2, b: Float2): Float2

inline fun min(a: Float3, b: Float3): Float3

inline fun min(a: Float4, b: Float4): Float4

inline fun min(a: Half2, b: Half2): Half2

inline fun min(a: Half3, b: Half3): Half3

inline fun min(a: Half4, b: Half4): Half4

fun min(x: Half, y: Half): Half

Returns the smaller of two half-precision float values (the value closest to negative infinity). Special values are handled in the following ways:

minus

inline operator fun Half.minus(v: Half3): Half3

inline operator fun Half.minus(v: Half4): Half4

inline operator fun Float.minus(v: Float2): Float2

inline operator fun Float.minus(v: Float3): Float3

inline operator fun Float.minus(v: Float4): Float4

inline operator fun Float.minus(q: Quaternion): Quaternion

mix

inline fun mix(a: Float2, b: Float2, x: Float2): Float2

inline fun mix(a: Float2, b: Float2, x: Float): Float2

inline fun mix(a: Float3, b: Float3, x: Float3): Float3

inline fun mix(a: Float3, b: Float3, x: Float): Float3

inline fun mix(a: Float4, b: Float4, x: Float4): Float4

inline fun mix(a: Float4, b: Float4, x: Float): Float4

inline fun mix(a: Half, b: Half, x: Half): Half

inline fun mix(a: Half3, b: Half3, x: Half): Half3

inline fun mix(a: Half3, b: Half3, x: Half3): Half3

inline fun mix(a: Half4, b: Half4, x: Half): Half4

inline fun mix(a: Half4, b: Half4, x: Half4): Half4

inline fun mix(a: Float, b: Float, x: Float): Float

neq

infix inline fun Float2.neq(b: Float2): Bool2

infix inline fun Float2.neq(b: Float): Bool2

infix inline fun Float3.neq(b: Float3): Bool3

infix inline fun Float3.neq(b: Float): Bool3

infix inline fun Float4.neq(b: Float4): Bool4

infix inline fun Float4.neq(b: Float): Bool4

infix inline fun Half2.neq(b: Half): Bool2

infix inline fun Half2.neq(b: Half2): Bool2

infix inline fun Half3.neq(b: Half): Bool3

infix inline fun Half3.neq(b: Half3): Bool3

infix inline fun Half4.neq(b: Half): Bool4

infix inline fun Half4.neq(b: Half4): Bool4

nlerp

fun nlerp(a: Quaternion, b: Quaternion, t: Float): Quaternion

normal

fun normal(m: Mat4): Mat4

normalize

fun normalize(v: Float2): Float2

fun normalize(v: Float3): Float3

fun normalize(v: Float4): Float4

fun normalize(v: Half3): Half3

fun normalize(v: Half4): Half4

fun normalize(q: Quaternion): Quaternion

Rescale the Quaternion to the unit length

notEqual

inline fun notEqual(a: Float2, b: Float2): Bool2

inline fun notEqual(a: Float2, b: Float): Bool2

inline fun notEqual(a: Float3, b: Float3): Bool3

inline fun notEqual(a: Float3, b: Float): Bool3

inline fun notEqual(a: Float4, b: Float4): Bool4

inline fun notEqual(a: Float4, b: Float): Bool4

inline fun notEqual(a: Half2, b: Half): Bool2

inline fun notEqual(a: Half2, b: Half2): Bool2

inline fun notEqual(a: Half3, b: Half): Bool3

inline fun notEqual(a: Half3, b: Half3): Bool3

inline fun notEqual(a: Half4, b: Half): Bool4

inline fun notEqual(a: Half4, b: Half4): Bool4

ortho

fun ortho(l: Float, r: Float, b: Float, t: Float, n: Float, f: Float): Mat4

perspective

fun perspective(fov: Float, ratio: Float, near: Float, far: Float): Mat4

plus

inline operator fun Half.plus(v: Half3): Half3

inline operator fun Half.plus(v: Half4): Half4

inline operator fun Float.plus(v: Float2): Float2

inline operator fun Float.plus(v: Float3): Float3

inline operator fun Float.plus(v: Float4): Float4

inline operator fun Float.plus(q: Quaternion): Quaternion

pointAt

fun pointAt(r: Ray, t: Float): Float3

pow

inline fun pow(x: Float, y: Float): Float

quaternion

fun quaternion(m: Mat4): Quaternion

Get the Quaternion from a rotation Matrix

radians

inline fun radians(v: Float): Float

Rational

fun Rational(value: Double): Rational

fun Rational(value: Float): Rational

fun Rational(value: Int): Rational

fun Rational(numerator: Int, denominator: Int): Rational

reflect

inline fun reflect(i: Float2, n: Float2): Float2

inline fun reflect(i: Float3, n: Float3): Float3

inline fun reflect(i: Half3, n: Half3): Half3

refract

fun refract(i: Float2, n: Float2, eta: Float): Float2

fun refract(i: Float3, n: Float3, eta: Float): Float3

fun refract(i: Half3, n: Half3, eta: Half): Half3

rotation

fun rotation(m: Mat4): Mat4

fun rotation(axis: Float3, angle: Float): Mat4

fun rotation(quaternion: Quaternion): Mat4

Construct a Quaternion Rotation Matrix following the Hamilton convention

fun rotation(d: Float3, order: RotationsOrder = RotationsOrder.ZYX): Mat4

Construct a rotation matrix from Euler angles using YPR around a specified order

fun rotation(yaw: Float = 0.0f, pitch: Float = 0.0f, roll: Float = 0.0f, order: RotationsOrder = RotationsOrder.ZYX): Mat4

Construct a rotation matrix from Euler yaw, pitch, roll around a specified order.

round

fun round(x: Half): Half

Returns the closest integral half-precision float value to the specified half-precision float value. Special values are handled in the following ways:

saturate

inline fun saturate(x: Half): Half

inline fun saturate(x: Float): Float

scale

fun scale(s: Float3): Mat4

fun scale(m: Mat4): Mat4

slerp

fun slerp(a: Quaternion, b: Quaternion, t: Float, dotThreshold: Float = 0.9995f): Quaternion

Spherical linear interpolation between two given orientations

sqr

inline fun sqr(v: Half): Half

inline fun sqr(v: Float): Float

sqrt

fun sqrt(x: Half): Half

times

inline operator fun Half.times(v: Half3): Half3

inline operator fun Half.times(v: Half4): Half4

inline operator fun Float.times(v: Float2): Float2

inline operator fun Float.times(v: Float3): Float3

inline operator fun Float.times(v: Float4): Float4

inline operator fun Float.times(q: Quaternion): Quaternion

toHalf

fun Rational.toHalf(): Half

Returns the half-precision float value represented by the specified Rational.

fun Double.toHalf(): Half

Converts this double-precision float value into a half-precision float value. The following special cases are handled:

fun Float.toHalf(): Half

Converts this single-precision float value into a half-precision float value. The following special cases are handled:

fun String.toHalf(): Half

Returns the half-precision float value represented by the specified string. The string is converted to a half-precision float value as if by the String.toFloat() method.

transform