korge-foundation/korlibs.math.geom/MMatrix

MMatrix

data class ~~MMatrix~~(var a: Double = 1.0, var b: Double = 0.0, var c: Double = 0.0, var d: Double = 1.0, var tx: Double = 0.0, var ty: Double = 0.0) : MutableInterpolable<MMatrix> , Interpolable<MMatrix>

Deprecated

Use Matrix

Constructors

MMatrix

constructor(a: Double = 1.0, b: Double = 0.0, c: Double = 0.0, d: Double = 1.0, tx: Double = 0.0, ty: Double = 0.0)

Types

Companion

object Companion

Computed

class Computed(val matrix: MMatrix, val transform: MMatrix.Transform)

Transform

data class ~~Transform~~(var x: Double = 0.0, var y: Double = 0.0, var scaleX: Double = 1.0, var scaleY: Double = 1.0, var skewX: Angle = 0.radians, var skewY: Angle = 0.radians, var rotation: Angle = 0.radians) : MutableInterpolable<MMatrix.Transform> , Interpolable<MMatrix.Transform>

Properties

var a: Double

var af: Float

var b: Double

var bf: Float

var c: Double

var cf: Float

var d: Double

var df: Float

immutable

val immutable: Matrix

immutable

val MMatrix?.immutable: Matrix

var tx: Double

txf

var txf: Float

var ty: Double

tyf

var tyf: Float

Functions

clone

fun clone(): MMatrix

concat

fun concat(value: MMatrix): MMatrix

copyFrom

fun copyFrom(that: MMatrix?): MMatrix

fun copyFrom(that: Matrix): MMatrix

copyFromArray

fun copyFromArray(value: DoubleArray, offset: Int = 0): MMatrix

fun copyFromArray(value: FloatArray, offset: Int = 0): MMatrix

copyFromInverted

fun copyFromInverted(that: MMatrix): MMatrix

copyTo

fun copyTo(that: MMatrix = MMatrix()): MMatrix

decompose

fun decompose(out: MMatrix.Transform = Transform()): MMatrix.Transform

deltaTransformPoint

fun deltaTransformPoint(point: MPoint, out: MPoint = MPoint()): MPoint

Transform point without translation

fun deltaTransformPoint(x: Double, y: Double, out: MPoint = MPoint()): MPoint

fun deltaTransformPoint(x: Float, y: Float, out: MPoint = MPoint()): MPoint

deltaTransformX

fun deltaTransformX(x: Double, y: Double): Double

deltaTransformY

fun deltaTransformY(x: Double, y: Double): Double

getType

fun getType(): MatrixType

identity

fun identity(): MMatrix

interpolateWith

open override fun interpolateWith(ratio: Ratio, other: MMatrix): MMatrix

invert

fun invert(matrixToInvert: MMatrix = this): MMatrix

inverted

fun inverted(out: MMatrix = MMatrix()): MMatrix

isAlmostEquals

fun isAlmostEquals(other: MMatrix, epsilon: Double = 1.0E-6): Boolean

isIdentity

fun isIdentity(): Boolean

keepMatrix

inline fun <T> keepMatrix(callback: (MMatrix) -> T): T

multiply

fun multiply(l: MMatrix, r: MMatrix): MMatrix

postconcat

fun postconcat(value: MMatrix): MMatrix

postmultiply

fun postmultiply(m: MMatrix): MMatrix

preconcat

fun preconcat(value: MMatrix): MMatrix

premultiply

fun premultiply(m: MMatrix): MMatrix

fun premultiply(m: Matrix): MMatrix

fun premultiply(la: Double, lb: Double, lc: Double, ld: Double, ltx: Double, lty: Double): MMatrix

fun premultiply(la: Float, lb: Float, lc: Float, ld: Float, ltx: Float, lty: Float): MMatrix

fun premultiply(la: Int, lb: Int, lc: Int, ld: Int, ltx: Int, lty: Int): MMatrix

prerotate

fun prerotate(angle: Angle): MMatrix

prescale

fun prescale(sx: Double, sy: Double = sx): MMatrix

fun prescale(sx: Float, sy: Float = sx): MMatrix

fun prescale(sx: Int, sy: Int = sx): MMatrix

preskew

fun preskew(skewX: Angle, skewY: Angle): MMatrix

pretranslate

fun pretranslate(dx: Double, dy: Double): MMatrix

fun pretranslate(dx: Float, dy: Float): MMatrix

fun pretranslate(dx: Int, dy: Int): MMatrix

rotate

fun rotate(angle: Angle): MMatrix

scale

fun scale(sx: Double, sy: Double = sx): MMatrix

fun scale(sx: Float, sy: Float = sx): MMatrix

fun scale(sx: Int, sy: Int = sx): MMatrix

setTo

fun setTo(a: Double, b: Double, c: Double, d: Double, tx: Double, ty: Double): MMatrix

fun setTo(a: Float, b: Float, c: Float, d: Float, tx: Float, ty: Float): MMatrix

fun setTo(a: Int, b: Int, c: Int, d: Int, tx: Int, ty: Int): MMatrix

setToInterpolated

open override fun setToInterpolated(ratio: Ratio, l: MMatrix, r: MMatrix): MMatrix

setToMultiply

fun setToMultiply(l: MMatrix?, r: MMatrix?): MMatrix

setToNan

fun setToNan(): MMatrix

setTransform

fun setTransform(transform: MMatrix.Transform, pivotX: Double = 0.0, pivotY: Double = 0.0): MMatrix

fun setTransform(x: Float = 0.0f, y: Float = 0.0f, scaleX: Float = 1.0f, scaleY: Float = 1.0f, rotation: Angle = Angle.ZERO, skewX: Angle = Angle.ZERO, skewY: Angle = Angle.ZERO): MMatrix

fun setTransform(x: Double = 0.0, y: Double = 0.0, scaleX: Double = 1.0, scaleY: Double = 1.0, rotation: Angle = Angle.ZERO, skewX: Angle = Angle.ZERO, skewY: Angle = Angle.ZERO, pivotX: Double = 0.0, pivotY: Double = 0.0): MMatrix

skew