core/com.lehaine.littlekt.math

Package-level declarations

Types

open class Mat3

A 3x3 column major matrix.

open class Mat4

A 4x4 column major matrix.

class Mat4Stack(val stackSize: Int = DEFAULT_STACK_SIZE) : Mat4

open class MutableVec2f(x: Float, y: Float) : Vec2f

open class MutableVec2i(x: Int, y: Int) : Vec2i

open class MutableVec3f(x: Float, y: Float, z: Float) : Vec3f

open class MutableVec3i(x: Int, y: Int, z: Int) : Vec3i

open class MutableVec4f(x: Float, y: Float, z: Float, w: Float) : Vec4f

open class MutableVec4i(x: Int, y: Int, z: Int, w: Int) : Vec4i

class Ray

open class Rect(var x: Float = 0.0f, var y: Float = 0.0f, var width: Float = 0.0f, var height: Float = 0.0f)

class RectBuilder

open class Vec2f

open class Vec2i(x: Int, y: Int)

open class Vec3f : Vec2f

open class Vec3i(x: Int, y: Int, z: Int)

open class Vec4f : Vec3f

open class Vec4i(x: Int, y: Int, z: Int, w: Int)

Functions

fun add(a: Vec2f, b: Vec2f): MutableVec2f

Vector extensions

fun add(a: Vec3f, b: Vec3f): MutableVec3f

barycentricWeights

fun barycentricWeights(pt: Vec3f, va: Vec3f, vb: Vec3f, vc: Vec3f, result: MutableVec3f): MutableVec3f

inline fun castRay(fromX: Int, fromY: Int, toX: Int, toY: Int, rayCanPass: (Int, Int) -> Boolean): Boolean

Cast a ray from a point to another point and checks if each point along the way can be passed via the rayCanPass parameter.

inline fun castThickRay(fromX: Int, fromY: Int, toX: Int, toY: Int, rayCanPass: (Int, Int) -> Boolean): Boolean

inline fun Double.clamp(min: Double = 0.0, max: Double = 1.0): Double

inline fun Float.clamp(min: Float = 0.0f, max: Float = 1.0f): Float

inline fun Int.clamp(min: Int, max: Int): Int

fun cross(a: Vec3f, b: Vec3f): MutableVec3f

fun dist(ax: Double, ay: Double, bx: Double, by: Double): Double

fun dist(ax: Float, ay: Float, bx: Float, by: Float): Float

fun dist(ax: Int, ay: Int, bx: Int, by: Int): Double

fun Vec2f.distanceToEdge(edgeA: Vec2f, edgeB: Vec2f): Float

fun Vec3f.distanceToEdge(edgeA: Vec3f, edgeB: Vec3f): Float

fun Vec3f.distanceToLine(lineA: Vec3f, lineB: Vec3f): Float

fun Vec3f.distanceToRay(ray: Ray): Float

fun Vec3f.distanceToRay(origin: Vec3f, direction: Vec3f): Float

fun distRadians(a: Double, b: Double): Double

fun distRadians(a: Int, b: Int): Double

fun distSqr(ax: Double, ay: Double, bx: Double, by: Double): Double

fun distSqr(ax: Float, ay: Float, bx: Float, by: Float): Float

fun distSqr(ax: Int, ay: Int, bx: Int, by: Int): Double

inline fun Float.floor(): Float

inline fun Float.floorToInt(): Int

getNumMipLevels

fun getNumMipLevels(texWidth: Int, texHeight: Int): Int

infix fun Double.ife(b: Double): Boolean

infix fun Float.ife(b: Float): Boolean

fun Double.interpolate(l: Double, r: Double): Double

fun Double.interpolate(l: Float, r: Float): Float

fun Double.interpolate(l: Int, r: Int): Int

fun Double.interpolate(l: Long, r: Long): Long

fun Float.interpolate(l: Double, r: Double): Double

fun Float.interpolate(l: Float, r: Float): Float

fun Float.interpolate(l: Int, r: Int): Int

fun Float.interpolate(l: Long, r: Long): Long

@JvmName(name = "isFuzzyEqual_D")

inline fun Double.isFuzzyEqual(b: Double, eps: Double = FUZZY_EQ_D): Boolean

@JvmName(name = "isFuzzyEqual_F")

inline fun Float.isFuzzyEqual(b: Float, eps: Float = FUZZY_EQ_F): Boolean

inline fun isFuzzyEqual(a: Double, b: Double, eps: Double = FUZZY_EQ_D): Boolean

inline fun isFuzzyEqual(a: Float, b: Float, eps: Float = FUZZY_EQ_F): Boolean

inline fun Double.isFuzzyZero(eps: Double = FUZZY_EQ_D): Boolean

inline fun Float.isFuzzyZero(eps: Float = FUZZY_EQ_F): Boolean

fun map(inRangeStart: Float, inRangeEnd: Float, outRangeStart: Float, outRangeEnd: Float, value: Float): Float

nearestPointOnEdge

fun Vec2f.nearestPointOnEdge(edgeA: Vec2f, edgeB: Vec2f, result: MutableVec2f): MutableVec2f

fun Vec3f.nearestPointOnEdge(edgeA: Vec3f, edgeB: Vec3f, result: MutableVec3f): MutableVec3f

nearestPointOnLine

fun Vec3f.nearestPointOnLine(lineA: Vec3f, lineB: Vec3f, result: MutableVec3f): MutableVec3f

nearestPointOnRay

fun Vec3f.nearestPointOnRay(origin: Vec3f, direction: Vec3f, result: MutableVec3f): MutableVec3f

fun norm(a: Vec2f): MutableVec2f

fun norm(a: Vec3f): MutableVec3f

normalizeRadian

fun normalizeRadian(a: Double): Double

fun <T> Array<T>.partition(k: Int, cmp: (T, T) -> Int)

fun <T> MutableList<T>.partition(k: Int, cmp: (T, T) -> Int)

fun <T> Array<T>.partition(rng: IntRange, k: Int, cmp: (T, T) -> Int)

fun <T> MutableList<T>.partition(rng: IntRange, k: Int, cmp: (T, T) -> Int)

fun <L, T> partition(elems: L, lt: Int, rt: Int, k: Int, get: L.(Int) -> T, cmp: (T, T) -> Int, swap: L.(Int, Int) -> Unit)

Partitions items with the given comparator. After partitioning, all elements left of k are smaller than all elements right of k with respect to the given comparator function.

fun ClosedFloatingPointRange<Double>.random(): Double

fun ClosedFloatingPointRange<Float>.random(): Float

fun IntRange.random(): Float

fun scale(a: Vec2f, fac: Float): MutableVec2f

fun scale(a: Vec3f, fac: Float): MutableVec3f

fun smoothStep(low: Float, high: Float, x: Float): Float

fun sparseListOf(vararg ranges: IntRange): List<Int>

sqrDistancePointToEdge

fun sqrDistancePointToEdge(x: Float, y: Float, edgeA: Vec2f, edgeB: Vec2f): Float

fun sqrDistancePointToEdge(x: Float, y: Float, z: Float, edgeA: Vec3f, edgeB: Vec3f): Float

sqrDistancePointToLine

fun sqrDistancePointToLine(x: Float, y: Float, z: Float, lineA: Vec3f, lineB: Vec3f): Float

sqrDistancePointToRay

fun sqrDistancePointToRay(x: Float, y: Float, z: Float, origin: Vec3f, direction: Vec3f): Float

sqrDistanceToEdge

fun Vec2f.sqrDistanceToEdge(edgeA: Vec2f, edgeB: Vec2f): Float

fun Vec3f.sqrDistanceToEdge(edgeA: Vec3f, edgeB: Vec3f): Float

sqrDistanceToLine

fun Vec3f.sqrDistanceToLine(lineA: Vec3f, lineB: Vec3f): Float

sqrDistanceToRay

fun Vec3f.sqrDistanceToRay(ray: Ray): Float

fun Vec3f.sqrDistanceToRay(origin: Vec3f, direction: Vec3f): Float

fun subtract(a: Vec2f, b: Vec2f): MutableVec2f

fun subtract(a: Vec3f, b: Vec3f): MutableVec3f

subtractRadians

fun subtractRadians(a: Double, b: Double): Double

inline fun Double.toDeg(): Double

inline fun Float.toDeg(): Float

inline fun Double.toRad(): Double

inline fun Float.toRad(): Float

fun triArea(va: Vec3f, vb: Vec3f, vc: Vec3f): Float

fun triAspectRatio(va: Vec3f, vb: Vec3f, vc: Vec3f): Float

fun Double.wrap(low: Double, high: Double): Double

fun Float.wrap(low: Float, high: Float): Float

fun Int.wrap(low: Int, high: Int): Int

fun MutableVec3f.xy(): MutableVec2f

fun Vec3f.xy(): Vec2f

Properties

const val DEG_2_RAD: Double

const val FLT_EPSILON: Float = 1.1920929E-7f

The difference between 1 and the smallest floating point number of type float that is greater than 1.

const val FUZZY_EQ_D: Double = 1.0E-10

const val FUZZY_EQ_F: Float = 1.0E-5f

val Int.isPowerOfTwo: Boolean

Checks if this value is power of two

val Int.nextPowerOfTwo: Int

const val PI2: Double

const val PI2_F: Float

const val PI_F: Float

val Int.prevPowerOfTwo: Int

Returns the previous power of two of this

const val RAD_2_DEG: Double

const val SQRT_1_2: Float = 0.70710677f

Square-root of 0.5f