Matrix

Matrix

Matrix()

Deprecated: All methods are static, do not instantiate this class.

frustumM

open static fun frustumM(
    m: FloatArray!, 
    offset: Int, 
    left: Float, 
    right: Float, 
    bottom: Float, 
    top: Float, 
    near: Float, 
    far: Float
): Unit

Defines a projection matrix in terms of six clip planes.

invertM

open static fun invertM(
    mInv: FloatArray!, 
    mInvOffset: Int, 
    m: FloatArray!, 
    mOffset: Int
): Boolean

Inverts a 4 x 4 matrix.

mInv and m must not overlap.

length

open static fun length(
    x: Float, 
    y: Float, 
    z: Float
): Float

Computes the length of a vector.

multiplyMM

open static fun multiplyMM(
    result: FloatArray!, 
    resultOffset: Int, 
    lhs: FloatArray!, 
    lhsOffset: Int, 
    rhs: FloatArray!, 
    rhsOffset: Int
): Unit

Multiplies two 4x4 matrices together and stores the result in a third 4x4 matrix. In matrix notation: result = lhs x rhs. Due to the way matrix multiplication works, the result matrix will have the same effect as first multiplying by the rhs matrix, then multiplying by the lhs matrix. This is the opposite of what you might expect.

The same float array may be passed for result, lhs, and/or rhs. This operation is expected to do the correct thing if the result elements overlap with either of the lhs or rhs elements.

multiplyMV

open static fun multiplyMV(
    resultVec: FloatArray!, 
    resultVecOffset: Int, 
    lhsMat: FloatArray!, 
    lhsMatOffset: Int, 
    rhsVec: FloatArray!, 
    rhsVecOffset: Int
): Unit

Multiplies a 4 element vector by a 4x4 matrix and stores the result in a 4-element column vector. In matrix notation: result = lhs x rhs

The same float array may be passed for resultVec, lhsMat, and/or rhsVec. This operation is expected to do the correct thing if the result elements overlap with either of the lhs or rhs elements.

orthoM

open static fun orthoM(
    m: FloatArray!, 
    mOffset: Int, 
    left: Float, 
    right: Float, 
    bottom: Float, 
    top: Float, 
    near: Float, 
    far: Float
): Unit

Computes an orthographic projection matrix.

perspectiveM

open static fun perspectiveM(
    m: FloatArray!, 
    offset: Int, 
    fovy: Float, 
    aspect: Float, 
    zNear: Float, 
    zFar: Float
): Unit

Defines a projection matrix in terms of a field of view angle, an aspect ratio, and z clip planes.

rotateM

open static fun rotateM(
    rm: FloatArray!, 
    rmOffset: Int, 
    m: FloatArray!, 
    mOffset: Int, 
    a: Float, 
    x: Float, 
    y: Float, 
    z: Float
): Unit

Rotates matrix m by angle a (in degrees) around the axis (x, y, z).

m and rm must not overlap.

rotateM

open static fun rotateM(
    m: FloatArray!, 
    mOffset: Int, 
    a: Float, 
    x: Float, 
    y: Float, 
    z: Float
): Unit

Rotates matrix m in place by angle a (in degrees) around the axis (x, y, z).

scaleM

open static fun scaleM(
    sm: FloatArray!, 
    smOffset: Int, 
    m: FloatArray!, 
    mOffset: Int, 
    x: Float, 
    y: Float, 
    z: Float
): Unit

Scales matrix m by x, y, and z, putting the result in sm.

m and sm must not overlap.

scaleM

open static fun scaleM(
    m: FloatArray!, 
    mOffset: Int, 
    x: Float, 
    y: Float, 
    z: Float
): Unit

Scales matrix m in place by sx, sy, and sz.

setIdentityM

open static fun setIdentityM(
    sm: FloatArray!, 
    smOffset: Int
): Unit

Sets matrix m to the identity matrix.

setLookAtM

open static fun setLookAtM(
    rm: FloatArray!, 
    rmOffset: Int, 
    eyeX: Float, 
    eyeY: Float, 
    eyeZ: Float, 
    centerX: Float, 
    centerY: Float, 
    centerZ: Float, 
    upX: Float, 
    upY: Float, 
    upZ: Float
): Unit

Defines a viewing transformation in terms of an eye point, a center of view, and an up vector.

setRotateEulerM

open static fun setRotateEulerM(
    rm: FloatArray!, 
    rmOffset: Int, 
    x: Float, 
    y: Float, 
    z: Float
): Unit

Deprecated: This method is incorrect around the y axis. This method is deprecated and replaced (below) by setRotateEulerM2 which behaves correctly

Converts Euler angles to a rotation matrix.

setRotateEulerM2

open static fun setRotateEulerM2(
    rm: FloatArray, 
    rmOffset: Int, 
    x: Float, 
    y: Float, 
    z: Float
): Unit

Converts Euler angles to a rotation matrix.

setRotateM

open static fun setRotateM(
    rm: FloatArray!, 
    rmOffset: Int, 
    a: Float, 
    x: Float, 
    y: Float, 
    z: Float
): Unit

Creates a matrix for rotation by angle a (in degrees) around the axis (x, y, z).

An optimized path will be used for rotation about a major axis (e.g. x=1.0f y=0.0f z=0.0f).

translateM

open static fun translateM(
    tm: FloatArray!, 
    tmOffset: Int, 
    m: FloatArray!, 
    mOffset: Int, 
    x: Float, 
    y: Float, 
    z: Float
): Unit

Translates matrix m by x, y, and z, putting the result in tm.

m and tm must not overlap.

translateM

open static fun translateM(
    m: FloatArray!, 
    mOffset: Int, 
    x: Float, 
    y: Float, 
    z: Float
): Unit

Translates matrix m by x, y, and z in place.

transposeM

open static fun transposeM(
    mTrans: FloatArray!, 
    mTransOffset: Int, 
    m: FloatArray!, 
    mOffset: Int
): Unit

Transposes a 4 x 4 matrix.

mTrans and m must not overlap.