Matrix

Imath.M33f

class Imath.M33f
M33f()M33f
M33f(M33f m)M33f
M33f(float a)M33f
M33f(float a, float b, float c, float d, float e, float f, float g, float h, float i)M33f
M33f(table[9] t)M33f
operator==(M33f m) const -> boolean
operator!=(M33f m) const -> boolean
operator+(M33f m) const -> M33f
operator-(M33f m) const -> M33f
operator-() const -> M33f
operator*(M33f m) const -> M33f
operator*(float s) const -> M33f
operator/(float s) const -> M33f
operator[](int idx) const -> float
operator[](int idx, float value)
makeIdentity()
equalWithAbsError(M33f m, float e) const -> boolean
equalWithRelError(M33f m, float e) const -> boolean
negate()M33f&
multVecMatrix(V2f v) const -> V2f
multDirMatrix(V2f v) const -> V2f
transpose()M33f&
transposed() const -> M33f
invert()M33f&
invert(boolean singExc)M33f&
inverse() const -> M33f
inverse(boolean singExc) const -> M33f
gjInvert()M33f&
gjInvert(boolean singExc)M33f&
gjInverse() const -> M33f
gjInverse(boolean singExc) const -> M33f
minorOf(int r, int c) const -> float
fastMinor(int r0, int r1, int c0, int c1) const -> float
determinant() const -> float
setRotation(float r)M33f&
rotate(float r)M33f&
setScale(float s)M33f&
setScale(V2f s)M33f&
scale(V2f s)M33f&
setTranslation(V2f t)M33f&
translation() const -> V2f
translate(V2f t)M33f&
setShear(float h)M33f&
setShear(V2f h)M33f&
shear(float xy)M33f&
shear(V2f h)M33f&
extractScaling([boolean exc=true]) const -> V2f, boolean
sansScaling([boolean exc=true]) const -> M33f
removeScaling([boolean exc=true])boolean
extractScalingAndShear([boolean exc=true]) const -> V2f, float, boolean
sansScalingAndShear([boolean exc=true]) const -> M33f
removeScalingAndShear([boolean exc=true])boolean
extractAndRemoveScalingAndShear([boolean exc=true]) const -> V2f, float, boolean
extractEuler() const -> float
extractSHRT([boolean exc=true]) const -> V2f, float, float, V2f, boolean
toTable() const -> table[9]
static dimensions()int
static baseTypeMin()float
static baseTypeMax()float
static baseTypeSmallest()float
static baseTypeEpsilon()float
static checkForZeroScaleInRow(float scl, V2f row[, boolean exc=true])boolean
static outerProduct(V3f a, V3f b)M33f

Imath.M33d

class Imath.M33d
M33d()M33d
M33d(M33d m)M33d
M33d(double a)M33d
M33d(double a, double b, double c, double d, double e, double f, double g, double h, double i)M33d
M33d(table[9] t)M33d
operator==(M33d m) const -> boolean
operator!=(M33d m) const -> boolean
operator+(M33d m) const -> M33d
operator-(M33d m) const -> M33d
operator-() const -> M33d
operator*(M33d m) const -> M33d
operator*(double s) const -> M33d
operator/(double s) const -> M33d
operator[](int idx) const -> double
operator[](int idx, double value)
makeIdentity()
equalWithAbsError(M33d m, double e) const -> boolean
equalWithRelError(M33d m, double e) const -> boolean
negate()M33d&
multVecMatrix(V2d v) const -> V2d
multDirMatrix(V2d v) const -> V2d
transpose()M33d&
transposed() const -> M33d
invert()M33d&
invert(boolean singExc)M33d&
inverse() const -> M33d
inverse(boolean singExc) const -> M33d
gjInvert()M33d&
gjInvert(boolean singExc)M33d&
gjInverse() const -> M33d
gjInverse(boolean singExc) const -> M33d
minorOf(int r, int c) const -> double
fastMinor(int r0, int r1, int c0, int c1) const -> double
determinant() const -> double
setRotation(double r)M33d&
rotate(double r)M33d&
setScale(double s)M33d&
setScale(V2d s)M33d&
scale(V2d s)M33d&
setTranslation(V2d t)M33d&
translation() const -> V2d
translate(V2d t)M33d&
setShear(double h)M33d&
setShear(V2d h)M33d&
shear(double xy)M33d&
shear(V2d h)M33d&
extractScaling([boolean exc=true]) const -> V2d, boolean
sansScaling([boolean exc=true]) const -> M33d
removeScaling([boolean exc=true])boolean
extractScalingAndShear([boolean exc=true]) const -> V2d, double, boolean
sansScalingAndShear([boolean exc=true]) const -> M33d
removeScalingAndShear([boolean exc=true])boolean
extractAndRemoveScalingAndShear([boolean exc=true]) const -> V2d, double, boolean
extractEuler() const -> double
extractSHRT([boolean exc=true]) const -> V2d, double, double, V2d, boolean
toTable() const -> table[9]
static dimensions()int
static baseTypeMin()double
static baseTypeMax()double
static baseTypeSmallest()double
static baseTypeEpsilon()double
static checkForZeroScaleInRow(double scl, V2f row[, boolean exc=true])boolean
static outerProduct(V3d a, V3d b)M33d

Imath.M44f

class Imath.M44f
M44f()M44f
M44f(M44f m)M44f
M44f(M33f r, V3f t)M44f
M44f(float a)M44f
M44f(float a, float b, float c, float d, float e, float f, float g, float h, float i, float j, float k, float l, float m, float n, float o, float p)M44f
M44f(table[16] t)M44f
operator==(M44f m) const -> boolean
operator!=(M44f m) const -> boolean
operator+(M44f m) const -> M44f
operator-(M44f m) const -> M44f
operator-() const -> M44f
operator*(M44f m) const -> M44f
operator*(float s) const -> M44f
operator/(float s) const -> M44f
operator[](int idx) const -> float
operator[](int idx, float value)
makeIdentity()
equalWithAbsError(M44f m, float e) const -> boolean
equalWithRelError(M44f m, float e) const -> boolean
negate()M44f&
multVecMatrix(V3f v) const -> V3f
multDirMatrix(V3f v) const -> V3f
transpose()M44f&
transposed() const -> M44f
invert()M44f&
invert(boolean singExc)M44f&
inverse() const -> M44f
inverse(boolean singExc) const -> M44f
gjInvert()M44f&
gjInvert(boolean singExc)M44f&
gjInverse() const -> M44f
gjInverse(boolean singExc) const -> M44f
minorOf(int r, int c) const -> float
fastMinor(int r0, int r1, int r2 int c0, int c1, int c2) const -> float
determinant() const -> float
setEulerAngles(V3f r)M44f&
setAxisAngle(V3f ax, float angle)M44f&
rotate(V3f r)M44f&
setScale(float s)M44f&
setScale(V3f s)M44f&
scale(V3f s)M44f&
setTranslation(V3f t)M44f&
translation() const -> V3f
translate(V3f t)M44f&
setShear(V3f h)M44f&
shear(V3f h)M44f&
extractScaling([boolean exc=true]) const -> V3f, boolean
sansScaling([boolean exc=true]) const -> M44f
removeScaling([boolean exc=true])boolean
extractScalingAndShear([boolean exc=true]) const -> V3f, V3f, boolean
sansScalingAndShear([boolean exc=true]) const -> M44f
removeScalingAndShear([boolean exc=true])boolean
extractAndRemoveScalingAndShear([boolean exc=true]) const -> V3f, V3f, boolean
extractEulerXYZ() const -> V3f
extractEulerZYX() const -> V3f
extractQuat() const -> Quatf
extractSHRT(boolean exc, Eulerf.Order rOrder) const -> V3f, V3f, V3f, V3f, boolean
extractSHRT([boolean exc=true]) const -> V3f, V3f, V3f, V3f, boolean
extractSHRT(Eulerf e[, boolean exc=true]) const -> V3f, V3f, Eulerf, V3f, boolean
toTable() const -> table[16]
static multiply(M44f a, M44f b)M44f
static dimensions()int
static baseTypeMin()float
static baseTypeMax()float
static baseTypeSmallest()float
static baseTypeEpsilon()float
static checkForZeroScaleInRow(float scl, V3f row[, boolean exc=true])boolean
static outerProduct(V4f a, V4f b)M44f
static rotationMatrix(V3f fromDirection, V3f toDirection)M44f
static rotationMatrixWithUpDir(V3f fromDir, V3f toDir, V3f upDir)M44f
static alignZAxisWithTargetDir(M44f& result, V3f targetDir, V3f upDir)
static alignZAxisWithTargetDir(V3f targetDir, V3f upDir)M44f
static computeLocalFrame(V3f p, V3f xDir, V3f normal)M44f
static addOffset(M44f inMat, V3f tOffset, V3f rOffset, V3f sOffset, M44f ref)M44f
static computeRSMatrix(boolean keepRotateA, boolean keepScaleA, M44f A, M44f B)M44f

Imath.M44d

class Imath.M44d
M44d()M44d
M44d(M44d m)M44d
M44d(M33d r, V3d t)M44d
M44d(double a)M44d
M44d(double a, double b, double c, double d, double e,
double f, double g, double h, double i, double j,
double k, double l, double m, double n, double o,
double p) -> M44d
M44d(table[16] t)M44d
operator==(M44d m) const -> boolean
operator!=(M44d m) const -> boolean
operator+(M44d m) const -> M44d
operator-(M44d m) const -> M44d
operator-() const -> M44d
operator*(M44d m) const -> M44d
operator*(double s) const -> M44d
operator/(double s) const -> M44d
operator[](int idx) const -> double
operator[](int idx, double value)
makeIdentity()
equalWithAbsError(M44d m, double e) const -> boolean
equalWithRelError(M44d m, double e) const -> boolean
negate()M44d&
multVecMatrix(V3d v) const -> V3d
multDirMatrix(V3d v) const -> V3d
transpose()M44d&
transposed() const -> M44d
invert()M44d&
invert(boolean singExc)M44d&
inverse() const -> M44d
inverse(boolean singExc) const -> M44d
gjInvert()M44d&
gjInvert(boolean singExc)M44d&
gjInverse() const -> M44d
gjInverse(boolean singExc) const -> M44d
minorOf(int r, int c) const -> double
fastMinor(int r0, int r1, int r2 int c0, int c1, int c2) const -> double
determinant() const -> double
setEulerAngles(V3d r)M44d&
setAxisAngle(V3d ax, double angle)M44d&
rotate(V3d r)M44d&
setScale(double s)M44d&
setScale(V3d s)M44d&
scale(V3d s)M44d&
setTranslation(V3d t)M44d&
translation() const -> V3d
translate(V3d t)M44d&
setShear(V3d h)M44d&
shear(V3d h)M44d&
extractScaling([boolean exc=true]) const -> V3d, boolean
sansScaling([boolean exc=true]) const -> M44d
removeScaling([boolean exc=true])boolean
extractScalingAndShear([boolean exc=true]) const -> V3d, V3d, boolean
sansScalingAndShear([boolean exc=true]) const -> M44d
removeScalingAndShear([boolean exc=true])boolean
extractAndRemoveScalingAndShear([boolean exc=true]) const -> V3d, V3d, boolean
extractEulerXYZ() const -> V3d
extractEulerZYX() const -> V3d
extractQuat() const -> Quatd
extractSHRT(boolean exc, Eulerd.Order rOrder) const -> V3d, V3d, V3d, V3d, boolean
extractSHRT([boolean exc=true]) const -> V3d, V3d, V3d, V3d, boolean
extractSHRT(Eulerd e[, boolean exc=true]) const -> V3d, V3d, Eulerd, V3d, boolean
toTable() const -> table[16]
static multiply(M44d a, M44d b)M44d
static dimensions()int
static baseTypeMin()double
static baseTypeMax()double
static baseTypeSmallest()double
static baseTypeEpsilon()double
static checkForZeroScaleInRow(double scl, V3d row[, boolean exc=true])boolean
static outerProduct(V4d a, V4d b)M44d
static rotationMatrix(V3d fromDirection, V3d toDirection)M44d
static rotationMatrixWithUpDir(V3d fromDir, V3d toDir, V3d upDir)M44d
static alignZAxisWithTargetDir(M44d& result, V3d targetDir, V3d upDir)
static alignZAxisWithTargetDir(V3d targetDir, V3d upDir)M44d
static computeLocalFrame(V3d p, V3d xDir, V3d normal)M44d
static addOffset(M44d inMat, V3d tOffset, V3d rOffset, V3d sOffset, M44d ref)M44d
static computeRSMatrix(boolean keepRotateA, boolean keepScaleA, M44d A, M44d B)M44d