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

Package-level declarations

Types

class Bookmark(nativeHandle: NativePointer) : AutoCloseable

Opaque memento to a viewing position and orientation (e.g. the "home" camera position), used to track camera animation between waypoints. In map mode this implements Van Wijk interpolation.

Bool2

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.

Bool3

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.

Bool4

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.

ComponentType

enum ComponentType : Enum<ComponentType>

A vertex attribute component type Transcoder reads.

Float2

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.

Float3

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.

Float4

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.

Fov

enum Fov : Enum<Fov>

The axis held constant when the viewport changes in Mode.MAP.

Half

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

Half2

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.

Half3

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.

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)

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

HDRLoader

object HDRLoader

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

IBLPrefilterContext

class IBLPrefilterContext(engine: Engine) : AutoCloseable

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

Int2

data class Int2(var x: Int = 0, var y: Int = 0)

Int3

data class Int3(var x: Int = 0, var y: Int = 0, var z: Int = 0)

Int4

data class Int4(var x: Int = 0, var y: Int = 0, var z: Int = 0, var w: Int = 0)

Ktx1Bundle

class Ktx1Bundle(nativeHandle: NativePointer) : AutoCloseable

An in-memory representation of a KTX1 file: a hierarchy of blobs (miplevels, array elements, cubemap faces) and metadata.

Ktx1Reader

object Ktx1Reader

Creates Filament textures from KTX1 bundles.

Ktx2Reader

class Ktx2Reader(engine: Engine, quiet: Boolean = false) : AutoCloseable

Allows clients to create Filament textures from KTX2 containers.

Manipulator

class Manipulator(nativeHandle: NativePointer) : AutoCloseable

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

Mat2

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.

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

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

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

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

MatrixColumn

enum MatrixColumn : Enum<MatrixColumn>

Selects a column of a matrix by semantic name.

Mode

enum Mode : Enum<Mode>

The interaction style of a Manipulator.

Quaternion

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.

QuaternionComponent

enum QuaternionComponent : Enum<QuaternionComponent>

Enumeration of quaternion components.

Ray

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

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

RotationsOrder

enum RotationsOrder : Enum<RotationsOrder>

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

TangentSpaceMesh

class TangentSpaceMesh(nativeHandle: NativePointer) : AutoCloseable

Builds Filament-style TANGENTS buffers (tangent-space quaternions) from an input mesh, with a choice of algorithms. Supersedes SurfaceOrientation.

TextureLoader

object TextureLoader

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

Transcoder

class Transcoder(config: Transcoder.Config) : AutoCloseable

Converts vertex attribute data into tightly packed floats: useful for 3-component formats not every backend supports (the Vulkan minspec includes float3 but not short3).

VectorComponent

enum VectorComponent : Enum<VectorComponent>

Selects a component of a vector by semantic alias.

Properties

FOUR_PI

const val FOUR_PI: Float

4π as a Float.

FPI

const val FPI: Float = 3.1415927f

π as a Float.

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:

HALF_ONE

val HALF_ONE: Half

1.0 as a Half.

HALF_PI

const val HALF_PI: Float

π / 2 as a Float.

HALF_TWO

val HALF_TWO: Half

2.0 as a Half.

INV_FOUR_PI

const val INV_FOUR_PI: Float

1 / (4π) as a Float.

INV_PI

const val INV_PI: Float

1 / π as a Float.

INV_TWO_PI

const val INV_TWO_PI: Float

1 / (2π) as a Float.

TWO_PI

const val TWO_PI: Float

2π as a Float.

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

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

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.

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

compareTo

inline fun Float.compareTo(v: Float, delta: Float): Float

conjugate

fun conjugate(q: Quaternion): Quaternion

Returns the conjugate of the given quaternion q.

cross

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.

degrees

inline fun degrees(v: Float): Float

Converts radians to degrees.

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

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.

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

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.

equal

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.

equals

inline fun Float.equals(v: Float, delta: Float): Boolean

eulerAngles

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

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

Returns the fractional part of v.

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

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.

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

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.

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.

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

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.

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

Returns the inverse of m.

fun inverse(q: Quaternion): Quaternion

Returns the inverse of the given quaternion q.

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

Returns the length of the given quaternion q.

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

Returns the squared length of the given quaternion q.

lerp

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

Linearly interpolates between two quaternions a and b by t.

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

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.

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

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.

lookAt

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.

lookTowards

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.

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.

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

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.

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

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

minus

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

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.

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

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

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.

nlerp

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

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

normal

fun normal(m: Mat4): Mat4

Returns the normal matrix for m.

normalize

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

notEqual

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.

ortho

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

Returns an orthographic projection matrix.

perspective

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

Returns a perspective projection matrix.

plus

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

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.

pointAt

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

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

pow

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

Raises x to the power y.

quaternion

fun quaternion(m: Mat4): Quaternion

Extracts a unit Quaternion from a rotation Mat4.

radians

inline fun radians(v: Float): Float

Converts degrees to radians.

reflect

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

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

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

rotation

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.

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

Clamps x to 0.0, 1.0 as a Half.

inline fun saturate(x: Float): Float

Clamps x to 0.0, 1.0.

scale

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.

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

Returns v squared as a Half.

inline fun sqr(v: Float): Float

Returns v squared.

sqrt

fun sqrt(x: Half): Half

times

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

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.

toHalf

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