core/com.lehaine.littlekt.graphics/MutableColor

MutableColor

open class MutableColor(r: Float, g: Float, b: Float, a: Float) : Color

Constructors

fun MutableColor()

fun MutableColor(color: Color)

fun MutableColor(r: Float, g: Float, b: Float, a: Float)

Functions

fun add(other: Vec4f): MutableColor

fun add(other: Vec4f, weight: Float): MutableColor

fun add(other: Vec2f, result: MutableVec2f): MutableVec2f

fun add(other: Vec3f, result: MutableVec3f): MutableVec3f

fun add(other: Vec4f, result: MutableVec4f): MutableVec4f

fun angleTo(other: Vec2f): Angle

fun clear(): MutableColor

fun cross(other: Vec3f, result: MutableVec3f): MutableVec3f

fun distance(other: Vec2f): Float

fun distance(other: Vec3f): Float

fun distance(other: Vec4f): Float

fun dot(other: Vec2f): Float

fun dot(other: Vec3f): Float

fun dot(other: Vec4f): Float

open operator override fun equals(other: Any?): Boolean

Checks vector components for equality (using '==' operator). For better numeric stability consider using isFuzzyEqual.

fun gamma(gamma: Float, result: MutableColor = MutableColor()): MutableColor

open operator fun get(i: Int): Float

fun getXyz(result: MutableVec3f): MutableVec3f

open override fun hashCode(): Int

fun isFuzzyEqual(other: Vec2f, eps: Float = FUZZY_EQ_F): Boolean

Checks vector components for equality using com.lehaine.littlekt.math.isFuzzyEqual, that is all components must have a difference less or equal eps.

fun isFuzzyEqual(other: Vec3f, eps: Float = FUZZY_EQ_F): Boolean

Checks vector components for equality using com.lehaine.littlekt.math.isFuzzyEqual, that is all components must have a difference less or equal eps.

fun isFuzzyEqual(other: Vec4f, eps: Float = FUZZY_EQ_F): Boolean

Checks vector components for equality using com.lehaine.littlekt.math.isFuzzyEqual, that is all components must have a difference less or equal eps.

fun length(): Float

fun lighten(amount: Float = 0.1f): MutableColor

fun lookAt(forward: Vec3f, up: Vec3f, result: MutableVec4f): MutableVec4f

fun mix(other: Color, weight: Float, result: MutableColor = MutableColor()): MutableColor

fun mix(other: Vec2f, weight: Float, result: MutableVec2f): MutableVec2f

fun mix(other: Vec3f, weight: Float, result: MutableVec3f): MutableVec3f

fun mix(other: Vec4f, weight: Float, result: MutableVec4f): MutableVec4f

fun mul(other: Vec4f): MutableColor

fun mul(other: Vec2f, result: MutableVec2f): MutableVec2f

fun mul(other: Vec3f, result: MutableVec3f): MutableVec3f

fun mul(other: Vec4f, result: MutableVec4f): MutableVec4f

fun norm(result: MutableVec2f): MutableVec2f

fun norm(result: MutableVec3f): MutableVec3f

fun norm(result: MutableVec4f): MutableVec4f

fun planeSpace(p: MutableVec3f, q: MutableVec3f)

fun quatMul(otherQuat: Vec4f, result: MutableVec4f): MutableVec4f

Multiplies this vector as a quaternion with another in the form of this * other.

fun quatMulLeft(otherQuat: Vec4f, result: MutableVec4f): MutableVec4f

Multiplies this vector as a quaternion with another in the form of other * this.

fun rotate(angle: Angle, result: MutableVec2f): MutableVec2f

fun rotate(angle: Angle, axis: Vec3f, result: MutableVec3f): MutableVec3f

fun rotate(angle: Angle, axisX: Float, axisY: Float, axisZ: Float, result: MutableVec3f): MutableVec3f

fun scale(factor: Float): MutableColor

fun scale(factor: Float, result: MutableVec2f): MutableVec2f

fun scale(factor: Float, result: MutableVec3f): MutableVec3f

fun scale(factor: Float, result: MutableVec4f): MutableVec4f

fun scaleRgb(factor: Float): MutableColor

fun scaleRgb(factor: Float, result: MutableColor = MutableColor()): MutableColor

fun set(other: Vec4f): MutableColor

open operator fun set(i: Int, v: Float)

fun set(r: Float, g: Float, b: Float, a: Float): MutableColor

fun setAbgr8888(abgr888: Int): MutableColor

fun setHsv(h: Float, s: Float, v: Float, a: Float): MutableColor

fun setLength(length: Float, result: MutableVec2f): MutableVec2f

fun setRgba8888(rgba8888: Int): MutableColor

fun setSqrLength(sqrLength: Float, result: MutableVec2f): MutableVec2f

fun sqrDistance(other: Vec2f): Float

fun sqrDistance(other: Vec3f): Float

fun sqrDistance(other: Vec4f): Float

open override fun sqrLength(): Float

fun subtract(other: Vec4f): MutableColor

fun subtract(other: Vec2f, result: MutableVec2f): MutableVec2f

fun subtract(other: Vec3f, result: MutableVec3f): MutableVec3f

fun subtract(other: Vec4f, result: MutableVec4f): MutableVec4f

operator fun times(other: Vec2f): Float

operator fun times(other: Vec3f): Float

operator fun times(other: Vec4f): Float

fun toHexString(): String

fun toLinear(): MutableColor

fun toLinear(result: MutableColor): MutableColor

fun toMutableColor(): MutableColor

fun toMutableColor(result: MutableColor): MutableColor

fun toMutableVec2(): MutableVec2f

fun toMutableVec2(result: MutableVec2f): MutableVec2f

fun toMutableVec3(): MutableVec3f

fun toMutableVec3(result: MutableVec3f): MutableVec3f

fun toMutableVec4(): MutableVec4f

fun toMutableVec4(result: MutableVec4f): MutableVec4f

fun toSrgb(): MutableColor

fun toSrgb(result: MutableColor): MutableColor

open override fun toString(): String

fun toVec2(): Vec2f

fun toVec3(): Vec3f

fun toVec4(): Vec4f

fun transform(vec: Vec3f, result: MutableVec3f): MutableVec3f

Transforms the given vector using this quaternion and outputs the result.

fun withAlpha(alpha: Float): MutableColor

Properties

open override var a: Float

val array: FloatArray

open override var b: Float

val brightness: Float

open override var g: Float

val gimbalPole: Int

The pole of the gimbal lock, if any. Postiive (+1) for north pole, negative (-1) for south pole, zero (0) who no gimbal lock.

val pitch: Angle

The rotation around the x-axis. Requires that this vector / quaternion to be normalized.

open override var r: Float

val roll: Angle

The rotation around the z-axis. Requires this vector / quaternion to be normalized.

open val w: Float

open val x: Float

open val y: Float

The rotation around the y-axis. Requires that this vector / quaternion tobe normalized.

open val z: Float

Extensions

fun Color.abgr(): Int

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

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

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

fun Vec3f.distanceToRay(ray: Ray): Float

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

nearestPointOnEdge

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

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

nearestPointOnLine

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

nearestPointOnRay

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

fun Color.rgba(): Int

sqrDistanceToEdge

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

fun Vec2f.sqrDistanceToEdge(edgeA: Vec2f, edgeB: Vec2f): 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 Color.toAgbr8888(): Int

fun Color.toFloatBits(): Float

Packs the color components into a 32-bit integer with the format ABGR and then converts it to a float. Alpha is compressed from 0-255 to use only even numbers between 0-254 to avoid using float bits in the NaN range. Converting a color to a float and back can be lossy for alpha.

fun Color.toRgba8888(): Int

fun Vec3f.xy(): Vec2f