Package dev.romainguy.kotlin.math

Types

Bool2

data class Bool2(x: Boolean, y: Boolean)

Bool3

data class Bool3(x: Boolean, y: Boolean, z: Boolean)

Bool4

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

Float2

data class Float2(x: Float, y: Float)

Float3

data class Float3(x: Float, y: Float, z: Float)

Float4

data class Float4(x: Float, y: Float, z: Float, w: Float)

Mat2

data class Mat2(x: Float2, y: Float2)

Mat3

data class Mat3(x: Float3, y: Float3, z: Float3)

Mat4

data class Mat4(x: Float4, y: Float4, z: Float4, w: Float4)

MatrixColumn

enum MatrixColumn : Enum<MatrixColumn>

Quaternion

data class Quaternion(x: Float, y: Float, z: Float, w: Float)

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

QuaternionComponent

enum QuaternionComponent : Enum<QuaternionComponent>

Rational

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

Ray

data class Ray(origin: Float3, 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(q: Quaternion): Quaternion

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

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: Float, min: Float, max: Float): Float

conjugate

fun conjugate(q: Quaternion): Quaternion

cross

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

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

degrees

inline fun degrees(v: Float): Float

distance

inline fun distance(a: Float2, b: Float2): <ERROR CLASS>

inline fun distance(a: Float3, b: Float3): <ERROR CLASS>

inline fun distance(a: Float4, b: Float4): <ERROR CLASS>

div

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

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

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

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

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

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

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

inverse

fun inverse(m: Mat3): Mat3

fun inverse(m: Mat4): Mat4

fun inverse(q: Quaternion): Quaternion

length

inline fun length(v: Float2): <ERROR CLASS>

inline fun length(v: Float3): <ERROR CLASS>

inline fun length(v: Float4): <ERROR CLASS>

inline fun length(q: Quaternion): <ERROR CLASS>

length2

inline fun length2(v: Float2): Float

inline fun length2(v: Float3): Float

inline fun length2(v: Float4): Float

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

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

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

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

max

inline fun max(v: Float2): <ERROR CLASS>

inline fun max(v: Float3): <ERROR CLASS>

inline fun max(v: Float4): <ERROR CLASS>

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

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

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

min

inline fun min(v: Float2): <ERROR CLASS>

inline fun min(v: Float3): <ERROR CLASS>

inline fun min(v: Float4): <ERROR CLASS>

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

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

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

minus

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

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(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

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 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): <ERROR CLASS>

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

refract

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

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

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.

saturate

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

times

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

transform

inline fun transform(v: Float2, block: (Float) -> Float): Float2

inline fun transform(v: Float3, block: (Float) -> Float): Float3

inline fun transform(v: Float4, block: (Float) -> Float): Float4

translation

fun translation(t: Float3): Mat4

fun translation(m: Mat4): Mat4

transpose

fun transpose(m: Mat2): Mat2

fun transpose(m: Mat3): Mat3

fun transpose(m: Mat4): Mat4

infix inline fun Float3.x(v: Float3): Float3

Properties

FOUR_PI

const val FOUR_PI: Float

HALF_PI

const val HALF_PI: Float

INV_FOUR_PI

const val INV_FOUR_PI: Float

INV_PI

const val INV_PI: Float

INV_TWO_PI

const val INV_TWO_PI: Float

const val PI: Float = 3.1415927f

TWO_PI

const val TWO_PI: Float