java.lang.Object | ||
android.opengl.Matrix |
Matrix math utilities. These methods operate on OpenGL ES format matrices and vectors stored in float arrays. Matrices are 4 x 4 column-vector matrices stored in column-major order:
m[offset + 0] m[offset + 4] m[offset + 8] m[offset + 12] m[offset + 1] m[offset + 5] m[offset + 9] m[offset + 13] m[offset + 2] m[offset + 6] m[offset + 10] m[offset + 14] m[offset + 3] m[offset + 7] m[offset + 11] m[offset + 15]Vectors are 4 row x 1 column column-vectors stored in order:
v[offset + 0] v[offset + 1] v[offset + 2] v[offset + 3]
Matrix() |
static | void | frustumM(float[] m, int offset, float left, float right, float bottom, float top, float near, float far) | ||||
Define a projection matrix in terms of six clip planes | ||||||
static | boolean | invertM(float[] mInv, int mInvOffset, float[] m, int mOffset) | ||||
Inverts a 4 x 4 matrix. | ||||||
static | float | length(float x, float y, float z) | ||||
Computes the length of a vector | ||||||
static | void | multiplyMM(float[] result, int resultOffset, float[] lhs, int lhsOffset, float[] rhs, int rhsOffset) | ||||
Multiply two 4x4 matrices together and store the result in a third 4x4 matrix. | ||||||
static | void | multiplyMV(float[] resultVec, int resultVecOffset, float[] lhsMat, int lhsMatOffset, float[] rhsVec, int rhsVecOffset) | ||||
Multiply a 4 element vector by a 4x4 matrix and store the result in a 4 element column vector. | ||||||
static | void | orthoM(float[] m, int mOffset, float left, float right, float bottom, float top, float near, float far) | ||||
Computes an orthographic projection matrix. | ||||||
static | void | rotateM(float[] rm, int rmOffset, float[] m, int mOffset, float a, float x, float y, float z) | ||||
Rotates matrix m by angle a (in degrees) around the axis (x, y, z) | ||||||
static | void | rotateM(float[] m, int mOffset, float a, float x, float y, float z) | ||||
Rotates matrix m in place by angle a (in degrees) around the axis (x, y, z) | ||||||
static | void | scaleM(float[] m, int mOffset, float x, float y, float z) | ||||
Scales matrix m in place by sx, sy, and sz | ||||||
static | void | scaleM(float[] sm, int smOffset, float[] m, int mOffset, float x, float y, float z) | ||||
Scales matrix m by sx, sy, and sz, putting the result in sm | ||||||
static | void | setIdentityM(float[] sm, int smOffset) | ||||
Sets matrix m to the identity matrix. | ||||||
static | void | setRotateEulerM(float[] rm, int rmOffset, float x, float y, float z) | ||||
Converts Euler angles to a rotation matrix | ||||||
static | void | setRotateM(float[] rm, int rmOffset, float a, float x, float y, float z) | ||||
Rotates matrix m by angle a (in degrees) around the axis (x, y, z) | ||||||
static | void | translateM(float[] tm, int tmOffset, float[] m, int mOffset, float x, float y, float z) | ||||
Translates matrix m by sx, sy, and sz, putting the result in tm | ||||||
static | void | translateM(float[] m, int mOffset, float x, float y, float z) | ||||
Translates matrix m by sx, sy, and sz in place. | ||||||
static | void | transposeM(float[] mTrans, int mTransOffset, float[] m, int mOffset) | ||||
Transposes a 4 x 4 matrix. |
m | the float array that holds the perspective matrix |
---|---|
offset | the offset into float array m where the perspective matrix data is written |
mInv | the array that holds the output inverted matrix |
---|---|
mInvOffset | an offset into mInv where the inverted matrix is stored. |
m | the input array |
mOffset | an offset into m where the matrix is stored. |
x | x coordinate of a vector |
---|---|
y | y coordinate of a vector |
z | z coordinate of a vector |
result | The float array that holds the result. |
---|---|
resultOffset | The offset into the result array where the result is stored. |
lhs | The float array that holds the left-hand-side matrix. |
lhsOffset | The offset into the lhs array where the lhs is stored |
rhs | The float array that holds the right-hand-side matrix. |
rhsOffset | The offset into the rhs array where the rhs is stored. |
IllegalArgumentException | if result, lhs, or rhs are null, or if resultOffset + 16 > result.length or lhsOffset + 16 > lhs.length or rhsOffset + 16 > rhs.length. |
---|
resultVec | The float array that holds the result vector. |
---|---|
resultVecOffset | The offset into the result array where the result vector is stored. |
lhsMat | The float array that holds the left-hand-side matrix. |
lhsMatOffset | The offset into the lhs array where the lhs is stored |
rhsVec | The float array that holds the right-hand-side vector. |
rhsVecOffset | The offset into the rhs vector where the rhs vector is stored. |
IllegalArgumentException | if resultVec, lhsMat, or rhsVec are null, or if resultVecOffset + 4 > resultVec.length or lhsMatOffset + 16 > lhsMat.length or rhsVecOffset + 4 > rhsVec.length. |
---|
m | returns the result |
---|
rm | returns the result |
---|---|
rmOffset | index into rm where the result matrix starts |
m | source matrix |
mOffset | index into m where the source matrix starts |
a | angle to rotate in degrees |
x | scale factor x |
y | scale factor y |
z | scale factor z |
m | source matrix |
---|---|
mOffset | index into m where the matrix starts |
a | angle to rotate in degrees |
x | scale factor x |
y | scale factor y |
z | scale factor z |
m | matrix to scale |
---|---|
mOffset | index into m where the matrix starts |
x | scale factor x |
y | scale factor y |
z | scale factor z |
sm | returns the result |
---|---|
smOffset | index into sm where the result matrix starts |
m | source matrix |
mOffset | index into m where the source matrix starts |
x | scale factor x |
y | scale factor y |
z | scale factor z |
sm | returns the result |
---|---|
smOffset | index into sm where the result matrix starts |
rm | returns the result |
---|---|
rmOffset | index into rm where the result matrix starts |
x | angle of rotation, in degrees |
y | angle of rotation, in degrees |
z | angle of rotation, in degrees |
rm | returns the result |
---|---|
rmOffset | index into rm where the result matrix starts |
a | angle to rotate in degrees |
x | scale factor x |
y | scale factor y |
z | scale factor z |
tm | returns the result |
---|---|
tmOffset | index into sm where the result matrix starts |
m | source matrix |
mOffset | index into m where the source matrix starts |
x | translation factor x |
y | translation factor y |
z | translation factor z |
m | matrix |
---|---|
mOffset | index into m where the matrix starts |
x | translation factor x |
y | translation factor y |
z | translation factor z |
mTrans | the array that holds the output inverted matrix |
---|---|
mTransOffset | an offset into mInv where the inverted matrix is stored. |
m | the input array |
mOffset | an offset into m where the matrix is stored. |
Copyright 2007 Google Inc. | Build 0.9_r1-98467 - 14 Aug 2008 18:48 |