filament-utils/io.github.erkko68.filament.utils

Package-level declarations

Types

Link copied to clipboard
data class Bool2(var x: Boolean = false, var y: Boolean = false)

A two-component boolean vector, typically the result of per-component comparisons on Float2.

Link copied to clipboard
data class Bool3(var x: Boolean = false, var y: Boolean = false, var z: Boolean = false)

A three-component boolean vector, typically the result of per-component comparisons on Float3.

Link copied to clipboard
data class Bool4(var x: Boolean = false, var y: Boolean = false, var z: Boolean = false, var w: Boolean = false)

A four-component boolean vector, typically the result of per-component comparisons on Float4.

Link copied to clipboard
actual class EquirectangularToCubemap(context: IBLPrefilterContext)

Converts an equirectangular image to a cubemap.

expect class EquirectangularToCubemap(context: IBLPrefilterContext)

Converts an equirectangular image to a cubemap.

actual class EquirectangularToCubemap(context: IBLPrefilterContext)

Converts an equirectangular image to a cubemap.

actual class EquirectangularToCubemap(context: IBLPrefilterContext)

Converts an equirectangular image to a cubemap.

actual class EquirectangularToCubemap(context: IBLPrefilterContext)

Converts an equirectangular image to a cubemap.

Link copied to clipboard
data class Float2(var x: Float = 0.0f, var y: Float = 0.0f)

A two-component vector of Float values with GLSL-style swizzle accessors.

Link copied to clipboard
data class Float3(var x: Float = 0.0f, var y: Float = 0.0f, var z: Float = 0.0f)

A three-component vector of Float values with GLSL-style swizzle accessors.

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

A four-component vector of Float values with GLSL-style swizzle accessors.

Link copied to clipboard
@JvmInline
value class Half(val 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.

Link copied to clipboard
data class Half2(var x: Half = Half.POSITIVE_ZERO, var y: Half = Half.POSITIVE_ZERO)

A two-component vector of Half-precision float values with GLSL-style swizzle accessors.

Link copied to clipboard
data class Half3(var x: Half = Half.POSITIVE_ZERO, var y: Half = Half.POSITIVE_ZERO, var z: Half = Half.POSITIVE_ZERO)

A three-component vector of Half-precision float values with GLSL-style swizzle accessors.

Link copied to clipboard
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)

A four-component vector of Half-precision float values with GLSL-style swizzle accessors.

Link copied to clipboard
actual object HDRLoader

Decodes an HDR image from raw bytes into a Filament Texture.

expect object HDRLoader

Decodes an HDR image from raw bytes into a Filament Texture.

actual object HDRLoader

Decodes an HDR image from raw bytes into a Filament Texture.

actual object HDRLoader

Decodes an HDR image from raw bytes into a Filament Texture.

actual object HDRLoader

Decodes an HDR image from raw bytes into a Filament Texture.

Link copied to clipboard
actual class IBLPrefilterContext(engine: Engine)

Creates and initializes GPU state common to all environment map filters supported.

expect class IBLPrefilterContext(engine: Engine)

Creates and initializes GPU state common to all environment map filters supported.

actual class IBLPrefilterContext(engine: Engine)

Creates and initializes GPU state common to all environment map filters supported.

actual class IBLPrefilterContext(engine: Engine)

Creates and initializes GPU state common to all environment map filters supported.

actual class IBLPrefilterContext(engine: Engine)

Creates and initializes GPU state common to all environment map filters supported.

Link copied to clipboard
data class Int2(var x: Int = 0, var y: Int = 0)
Link copied to clipboard
data class Int3(var x: Int = 0, var y: Int = 0, var z: Int = 0)
Link copied to clipboard
data class Int4(var x: Int = 0, var y: Int = 0, var z: Int = 0, var w: Int = 0)
Link copied to clipboard
actual object KTX1Loader

Decodes KTX1 data into Filament textures, indirect lights, and skyboxes.

expect object KTX1Loader

Decodes KTX1 data into Filament textures, indirect lights, and skyboxes.

actual object KTX1Loader

Decodes KTX1 data into Filament textures, indirect lights, and skyboxes.

actual object KTX1Loader

Decodes KTX1 data into Filament textures, indirect lights, and skyboxes.

actual object KTX1Loader

Decodes KTX1 data into Filament textures, indirect lights, and skyboxes.

Link copied to clipboard
actual class Manipulator

Helper that enables camera interaction similar to sketchfab or Google Maps.

expect class Manipulator

Helper that enables camera interaction similar to sketchfab or Google Maps.

actual class Manipulator

Helper that enables camera interaction similar to sketchfab or Google Maps.

actual class Manipulator

Helper that enables camera interaction similar to sketchfab or Google Maps.

actual class Manipulator

Helper that enables camera interaction similar to sketchfab or Google Maps.

Link copied to clipboard
data class Mat2(var x: Float2 = Float2(x = 1.0f), var y: Float2 = Float2(y = 1.0f))

A 2×2 column-major matrix of Float values.

Link copied to clipboard
data class Mat3(var x: Float3 = Float3(x = 1.0f), var y: Float3 = Float3(y = 1.0f), var z: Float3 = Float3(z = 1.0f))

A 3×3 column-major matrix of Float values.

Link copied to clipboard
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))

A 4×4 column-major matrix of Float values.

Link copied to clipboard
enum MatrixColumn : Enum<MatrixColumn>

Selects a column of a matrix by semantic name.

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

A quaternion of single-precision floats used for 3D rotations and orientations. The quaternion is normalized during construction if no parameters are specified.

Link copied to clipboard
enum QuaternionComponent : Enum<QuaternionComponent>

Enumeration of quaternion components.

Link copied to clipboard
data class Ray(var origin: Float3 = Float3(), var direction: Float3)

A ray defined by an origin point and a direction vector.

Link copied to clipboard
enum RotationsOrder : Enum<RotationsOrder>

Euler-angle rotation order (intrinsic Tait-Bryan angles).

Link copied to clipboard
actual class SpecularFilter(context: IBLPrefilterContext)

GPU-based implementation of the specular probe pre-integration filter.

expect class SpecularFilter(context: IBLPrefilterContext)

GPU-based implementation of the specular probe pre-integration filter.

actual class SpecularFilter(context: IBLPrefilterContext)

GPU-based implementation of the specular probe pre-integration filter.

actual class SpecularFilter(context: IBLPrefilterContext)

GPU-based implementation of the specular probe pre-integration filter.

actual class SpecularFilter(context: IBLPrefilterContext)

GPU-based implementation of the specular probe pre-integration filter.

Link copied to clipboard
actual object TextureLoader

Loads common image formats (PNG, JPG, etc.) into a Filament Texture.

expect object TextureLoader

Loads common image formats (PNG, JPG, etc.) into a Filament Texture.

actual object TextureLoader

Loads common image formats (PNG, JPG, etc.) into a Filament Texture.

actual object TextureLoader

Loads common image formats (PNG, JPG, etc.) into a Filament Texture.

actual object TextureLoader

Loads common image formats (PNG, JPG, etc.) into a Filament Texture.

Link copied to clipboard
enum VectorComponent : Enum<VectorComponent>

Selects a component of a vector by semantic alias.

Properties

Link copied to clipboard
const val FOUR_PI: Float

4π as a Float.

Link copied to clipboard
const val FPI: Float = 3.1415927f

π as a Float.

Link copied to clipboard
val Double.h: Half

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

val Float.h: Half

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

Link copied to clipboard
val HALF_ONE: Half

1.0 as a Half.

Link copied to clipboard
const val HALF_PI: Float

π / 2 as a Float.

Link copied to clipboard
val HALF_TWO: Half

2.0 as a Half.

Link copied to clipboard
const val INV_FOUR_PI: Float

1 / (4π) as a Float.

Link copied to clipboard
const val INV_PI: Float

1 / π as a Float.

Link copied to clipboard
const val INV_TWO_PI: Float

1 / (2π) as a Float.

Link copied to clipboard
const val TWO_PI: Float

2π as a Float.

Functions

Link copied to clipboard
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(v: Int3): Int3
inline fun abs(v: Int4): Int4

fun abs(x: Half): Half

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

inline fun abs(q: Quaternion): Quaternion

Returns the absolute value of the given quaternion q.

Link copied to clipboard
inline fun all(v: Bool2): Boolean
inline fun all(v: Bool3): Boolean
inline fun all(v: Bool4): Boolean
Link copied to clipboard
inline fun angle(a: Float2, b: Float2): Float
inline fun angle(a: Float3, b: Float3): Float

Returns the angle in radians between vectors a and b.

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

Returns the angle in radians between two quaternions.

Link copied to clipboard
inline fun any(v: Bool2): Boolean
inline fun any(v: Bool3): Boolean
inline fun any(v: Bool4): Boolean
Link copied to clipboard
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:

Link copied to clipboard
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(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(v: Int3, min: Int3, max: Int3): Int3
inline fun clamp(v: Int3, min: Int, max: Int): Int3
inline fun clamp(v: Int4, min: Int4, max: Int4): Int4
inline fun clamp(v: Int4, min: Int, max: Int): Int4

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

Clamps x to the range [min, max].

Link copied to clipboard
inline fun Float.compareTo(v: Float, delta: Float): Float
Link copied to clipboard
fun conjugate(q: Quaternion): Quaternion

Returns the conjugate of the given quaternion q.

Link copied to clipboard
inline fun cross(a: Float3, b: Float3): Float3

Returns the cross product of a and b.

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

Returns the cross product of a and b as a Half3.

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

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

Returns the cross product of two quaternions.

Link copied to clipboard
inline fun degrees(v: Float): Float

Converts radians to degrees.

Link copied to clipboard
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
Link copied to clipboard
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 Int.div(v: Int3): Int3
inline operator fun Int.div(v: Int4): Int4

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

Divides a scalar by a quaternion.

Link copied to clipboard
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: Int3, b: Int3): Int
inline fun dot(a: Int4, b: Int4): Int

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

Returns the dot product of two quaternions.

Link copied to clipboard
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
infix inline fun Int2.eq(b: Int2): Bool2
infix inline fun Int2.eq(b: Int): Bool2
infix inline fun Int3.eq(b: Int3): Bool3
infix inline fun Int3.eq(b: Int): Bool3
infix inline fun Int4.eq(b: Int4): Bool4
infix inline fun Int4.eq(b: Int): Bool4

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

Returns a Bool4 indicating if each component of this quaternion is equal to the corresponding component of b.

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

Returns a Bool4 indicating if each component of this quaternion is equal to b.

Link copied to clipboard
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
inline fun equal(a: Int2, b: Int2): Bool2
inline fun equal(a: Int2, b: Int): Bool2
inline fun equal(a: Int3, b: Int3): Bool3
inline fun equal(a: Int3, b: Int): Bool3
inline fun equal(a: Int4, b: Int4): Bool4
inline fun equal(a: Int4, b: Int): Bool4
inline fun equal(a: Float2, b: Float2, delta: Float = 0.0f): Bool2
inline fun equal(a: Float2, b: Float, delta: Float = 0.0f): Bool2
inline fun equal(a: Float3, b: Float3, delta: Float = 0.0f): Bool3
inline fun equal(a: Float3, b: Float, delta: Float = 0.0f): Bool3
inline fun equal(a: Float4, b: Float4, delta: Float = 0.0f): Bool4
inline fun equal(a: Float4, b: Float, delta: Float = 0.0f): Bool4
inline fun equal(a: Mat2, b: Mat2, delta: Float = 0.0f): Bool2
inline fun equal(a: Mat2, b: Float, delta: Float = 0.0f): Bool2
inline fun equal(a: Mat3, b: Mat3, delta: Float = 0.0f): Bool3
inline fun equal(a: Mat3, b: Float, delta: Float = 0.0f): Bool3
inline fun equal(a: Mat4, b: Mat4, delta: Float = 0.0f): Bool4
inline fun equal(a: Mat4, b: Float, delta: Float = 0.0f): Bool4

inline fun equal(a: Quaternion, b: Quaternion, delta: Float = 0.0f): Bool4

Returns a Bool4 indicating if each component of a is equal to the corresponding component of b within delta.

inline fun equal(a: Quaternion, b: Float, delta: Float = 0.0f): Bool4

Returns a Bool4 indicating if each component of a is equal to b within delta.

Link copied to clipboard
inline fun Float.equals(v: Float, delta: Float): Boolean
Link copied to clipboard
fun eulerAngles(m: Mat4, order: RotationsOrder = RotationsOrder.ZYX): Float3

Extracts Euler angles in degrees from a rotation Mat4 in the specified order.

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

Convert a Quaternion to Euler angles

Link copied to clipboard
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:

Link copied to clipboard
inline fun fract(v: Float): Float

Returns the fractional part of v.

Link copied to clipboard
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
inline fun greaterThan(a: Int2, b: Int2): Bool2
inline fun greaterThan(a: Int2, b: Int): Bool2
inline fun greaterThan(a: Int3, b: Int3): Bool3
inline fun greaterThan(a: Int3, b: Int): Bool3
inline fun greaterThan(a: Int4, b: Int4): Bool4
inline fun greaterThan(a: Int4, b: Int): Bool4

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

Returns a Bool4 indicating if each component of a is greater than the corresponding component of b.

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

Returns a Bool4 indicating if each component of a is greater than b.

Link copied to clipboard
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
inline fun greaterThanEqual(a: Int2, b: Int2): Bool2
inline fun greaterThanEqual(a: Int2, b: Int): Bool2
inline fun greaterThanEqual(a: Int3, b: Int3): Bool3
inline fun greaterThanEqual(a: Int3, b: Int): Bool3
inline fun greaterThanEqual(a: Int4, b: Int4): Bool4
inline fun greaterThanEqual(a: Int4, b: Int): Bool4

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

Returns a Bool4 indicating if each component of a is greater than or equal to the corresponding component of b.

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

Returns a Bool4 indicating if each component of a is greater than or equal to b.

Link copied to clipboard
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
infix inline fun Int2.gt(b: Int2): Bool2
infix inline fun Int2.gt(b: Int): Bool2
infix inline fun Int3.gt(b: Int3): Bool3
infix inline fun Int3.gt(b: Int): Bool3
infix inline fun Int4.gt(b: Int4): Bool4
infix inline fun Int4.gt(b: Int): Bool4

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

Returns a Bool4 indicating if each component of this quaternion is greater than the corresponding component of b.

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

Returns a Bool4 indicating if each component of this quaternion is greater than b.

Link copied to clipboard
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
infix inline fun Int2.gte(b: Int2): Bool2
infix inline fun Int2.gte(b: Int): Bool2
infix inline fun Int3.gte(b: Int3): Bool3
infix inline fun Int3.gte(b: Int): Bool3
infix inline fun Int4.gte(b: Int4): Bool4
infix inline fun Int4.gte(b: Int): Bool4

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

Returns a Bool4 indicating if each component of this quaternion is greater than or equal to the corresponding component of b.

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

Returns a Bool4 indicating if each component of this quaternion is greater than or equal to b.

Link copied to clipboard
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.

Link copied to clipboard
fun inverse(m: Mat3): Mat3
fun inverse(m: Mat4): Mat4

Returns the inverse of m.

fun inverse(q: Quaternion): Quaternion

Returns the inverse of the given quaternion q.

Link copied to clipboard
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

Returns the length of the given quaternion q.

Link copied to clipboard
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

Returns the squared length of the given quaternion q.

Link copied to clipboard
fun lerp(a: Quaternion, b: Quaternion, t: Float): Quaternion

Linearly interpolates between two quaternions a and b by t.

Link copied to clipboard
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
inline fun lessThan(a: Int2, b: Int2): Bool2
inline fun lessThan(a: Int2, b: Int): Bool2
inline fun lessThan(a: Int3, b: Int3): Bool3
inline fun lessThan(a: Int3, b: Int): Bool3
inline fun lessThan(a: Int4, b: Int4): Bool4
inline fun lessThan(a: Int4, b: Int): Bool4

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

Returns a Bool4 indicating if each component of a is less than the corresponding component of b.

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

Returns a Bool4 indicating if each component of a is less than b.

Link copied to clipboard
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
inline fun lessThanEqual(a: Int2, b: Int2): Bool2
inline fun lessThanEqual(a: Int2, b: Int): Bool2
inline fun lessThanEqual(a: Int3, b: Int3): Bool3
inline fun lessThanEqual(a: Int3, b: Int): Bool3
inline fun lessThanEqual(a: Int4, b: Int4): Bool4
inline fun lessThanEqual(a: Int4, b: Int): Bool4

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

Returns a Bool4 indicating if each component of a is less than or equal to the corresponding component of b.

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

Returns a Bool4 indicating if each component of a is less than or equal to b.

Link copied to clipboard
fun lookAt(eye: Float3, target: Float3, up: Float3 = Float3(z = 1.0f)): Mat4

Returns a view matrix that positions the camera at eye looking toward target.

Link copied to clipboard
fun lookTowards(eye: Float3, forward: Float3, up: Float3 = Float3(z = 1.0f)): Mat4

Returns a view matrix for a camera at eye pointing in forward direction.

Link copied to clipboard
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
infix inline fun Int2.lt(b: Int2): Bool2
infix inline fun Int2.lt(b: Int): Bool2
infix inline fun Int3.lt(b: Int3): Bool3
infix inline fun Int3.lt(b: Int): Bool3
infix inline fun Int4.lt(b: Int4): Bool4
infix inline fun Int4.lt(b: Int): Bool4

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

Returns a Bool4 indicating if each component of this quaternion is less than the corresponding component of b.

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

Returns a Bool4 indicating if each component of this quaternion is less than b.

Link copied to clipboard
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
infix inline fun Int2.lte(b: Int2): Bool2
infix inline fun Int2.lte(b: Int): Bool2
infix inline fun Int3.lte(b: Int3): Bool3
infix inline fun Int3.lte(b: Int): Bool3
infix inline fun Int4.lte(b: Int4): Bool4
infix inline fun Int4.lte(b: Int): Bool4

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

Returns a Bool4 indicating if each component of this quaternion is less than or equal to the corresponding component of b.

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

Returns a Bool4 indicating if each component of this quaternion is less than or equal to b.

Link copied to clipboard
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(v: Int2): Int
inline fun max(v: Int3): Int
inline fun max(v: Int4): Int
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
inline fun max(a: Int2, b: Int2): Int2
inline fun max(a: Int3, b: Int3): Int3
inline fun max(a: Int4, b: Int4): Int4

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:

Link copied to clipboard
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(v: Int2): Int
inline fun min(v: Int3): Int
inline fun min(v: Int4): Int
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
inline fun min(a: Int2, b: Int2): Int2
inline fun min(a: Int3, b: Int3): Int3
inline fun min(a: Int4, b: Int4): Int4

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:

Link copied to clipboard
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 Int.minus(v: Int3): Int3
inline operator fun Int.minus(v: Int4): Int4

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

Subtracts a quaternion from a scalar.

Link copied to clipboard
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: 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: Half, b: Half, x: Half): Half

Linearly interpolates between a and b by factor x using Half arithmetic.

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

Linearly interpolates between a and b by factor x: a * (1 - x) + b * x.

Link copied to clipboard
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
infix inline fun Int2.neq(b: Int2): Bool2
infix inline fun Int2.neq(b: Int): Bool2
infix inline fun Int3.neq(b: Int3): Bool3
infix inline fun Int3.neq(b: Int): Bool3
infix inline fun Int4.neq(b: Int4): Bool4
infix inline fun Int4.neq(b: Int): Bool4

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

Returns a Bool4 indicating if each component of this quaternion is not equal to the corresponding component of b.

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

Returns a Bool4 indicating if each component of this quaternion is not equal to b.

Link copied to clipboard
fun nlerp(a: Quaternion, b: Quaternion, t: Float): Quaternion

Normalized linear interpolation between two quaternions a and b by t.

Link copied to clipboard
fun normal(m: Mat4): Mat4

Returns the normal matrix for m.

Link copied to clipboard
fun normalize(v: Float2): Float2
fun normalize(v: Float3): Float3
fun normalize(v: Float4): Float4

Returns a unit-length copy of v.

fun normalize(v: Half3): Half3

Returns a unit-length copy of v as a Half3.

fun normalize(v: Half4): Half4

Returns a unit-length copy of v as a Half4.

fun normalize(q: Quaternion): Quaternion

Rescale the Quaternion to the unit length

Link copied to clipboard
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
inline fun notEqual(a: Int2, b: Int2): Bool2
inline fun notEqual(a: Int2, b: Int): Bool2
inline fun notEqual(a: Int3, b: Int3): Bool3
inline fun notEqual(a: Int3, b: Int): Bool3
inline fun notEqual(a: Int4, b: Int4): Bool4
inline fun notEqual(a: Int4, b: Int): Bool4
inline fun notEqual(a: Float2, b: Float2, delta: Float = 0.0f): Bool2
inline fun notEqual(a: Float2, b: Float, delta: Float = 0.0f): Bool2
inline fun notEqual(a: Float3, b: Float3, delta: Float = 0.0f): Bool3
inline fun notEqual(a: Float3, b: Float, delta: Float = 0.0f): Bool3
inline fun notEqual(a: Float4, b: Float4, delta: Float = 0.0f): Bool4
inline fun notEqual(a: Float4, b: Float, delta: Float = 0.0f): Bool4
inline fun notEqual(a: Mat2, b: Mat2, delta: Float = 0.0f): Bool2
inline fun notEqual(a: Mat2, b: Float, delta: Float = 0.0f): Bool2
inline fun notEqual(a: Mat3, b: Mat3, delta: Float = 0.0f): Bool3
inline fun notEqual(a: Mat3, b: Float, delta: Float = 0.0f): Bool3
inline fun notEqual(a: Mat4, b: Mat4, delta: Float = 0.0f): Bool4
inline fun notEqual(a: Mat4, b: Float, delta: Float = 0.0f): Bool4

inline fun notEqual(a: Quaternion, b: Quaternion, delta: Float = 0.0f): Bool4

Returns a Bool4 indicating if each component of a is not equal to the corresponding component of b within delta.

inline fun notEqual(a: Quaternion, b: Float, delta: Float = 0.0f): Bool4

Returns a Bool4 indicating if each component of a is not equal to b within delta.

Link copied to clipboard
fun ortho(l: Float, r: Float, b: Float, t: Float, n: Float, f: Float): Mat4

Returns an orthographic projection matrix.

Link copied to clipboard
fun perspective(fov: Float, ratio: Float, near: Float, far: Float): Mat4

Returns a perspective projection matrix.

Link copied to clipboard
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 Int.plus(v: Int3): Int3
inline operator fun Int.plus(v: Int4): Int4

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

Adds a quaternion to a scalar.

Link copied to clipboard
fun pointAt(r: Ray, t: Float): Float3

Returns the point along ray r at parameter t: origin + direction * t.

Link copied to clipboard
inline fun pow(x: Float, y: Float): Float

Raises x to the power y.

Link copied to clipboard
fun quaternion(m: Mat4): Quaternion

Extracts a unit Quaternion from a rotation Mat4.

Link copied to clipboard
inline fun radians(v: Float): Float

Converts degrees to radians.

Link copied to clipboard
inline fun reflect(i: Float2, n: Float2): Float2
inline fun reflect(i: Float3, n: Float3): Float3

Returns the reflection of incident vector i off a surface with normal n.

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

Returns the reflection of incident vector i off a surface with normal n (assumed normalized).

Link copied to clipboard
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

Returns the refraction of incident vector i through a surface with normal n and ratio eta.

Link copied to clipboard
fun rotation(m: Mat4): Mat4

Extracts and returns the rotation-only Mat4 from m by normalizing its basis vectors.

fun rotation(quaternion: Quaternion): Mat4

Returns a rotation Mat4 from the given quaternion (normalized internally).

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

Returns a rotation Mat4 from Euler angles (in degrees) in the specified order.

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

Returns a rotation Mat4 around axis by angle degrees.

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

Returns a rotation Mat4 from individual Euler angles in radians in the specified order.

Link copied to clipboard
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:

Link copied to clipboard
inline fun saturate(x: Half): Half

Clamps x to 0.0, 1.0 as a Half.

inline fun saturate(x: Float): Float

Clamps x to 0.0, 1.0.

Link copied to clipboard
fun scale(s: Float3): Mat4

Returns a scale Mat4 from the given per-axis scale factors s.

fun scale(m: Mat4): Mat4

Extracts and returns a scale Mat4 from m.

Link copied to clipboard
fun slerp(a: Quaternion, b: Quaternion, t: Float, dotThreshold: Float = 0.9995f): Quaternion

Spherical linear interpolation between two given orientations

Link copied to clipboard
inline fun sqr(v: Half): Half

Returns v squared as a Half.

inline fun sqr(v: Float): Float

Returns v squared.

Link copied to clipboard
fun sqrt(x: Half): Half
Link copied to clipboard
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 Int.times(v: Int3): Int3
inline operator fun Int.times(v: Int4): Int4

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

Multiplies a scalar by a quaternion.

Link copied to clipboard
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.

Link copied to clipboard
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
inline fun transform(v: Half2, block: (Half) -> Half): Half2
inline fun transform(v: Half3, block: (Half) -> Half): Half3
inline fun transform(v: Half4, block: (Half) -> Half): Half4
inline fun transform(v: Int2, block: (Int) -> Int): Int2
inline fun transform(v: Int3, block: (Int) -> Int): Int3
inline fun transform(v: Int4, block: (Int) -> Int): Int4
Link copied to clipboard
fun translation(t: Float3): Mat4

Returns a translation Mat4 for the vector t.

fun translation(m: Mat4): Mat4

Extracts and returns a translation Mat4 from m.

Link copied to clipboard
fun transpose(m: Mat2): Mat2
fun transpose(m: Mat3): Mat3
fun transpose(m: Mat4): Mat4

Returns the transpose of m.

Link copied to clipboard
fun truncate(x: Half): Half

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

Link copied to clipboard
infix inline fun Float3.x(v: Float3): Float3

Infix alias for cross: a x b.

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

Infix alias for cross on Half3: a x b.

infix inline fun Int3.x(v: Int3): Int3
Generated by Dokka
© 2026 Copyright