Matrix4fpublic class Matrix4f extends Object | Class for exposing the native RenderScript rs_matrix4x4 type back to the Android system. |
| Fields Summary |
|---|
| final float[] | mMat |
| Constructors Summary |
|---|
public Matrix4f()Creates a new identity 4x4 matrix
mMat = new float[16];
loadIdentity();
| public Matrix4f(float[] dataArray)Creates a new matrix and sets its values from the given
parameter
mMat = new float[16];
System.arraycopy(dataArray, 0, mMat, 0, mMat.length);
|
| Methods Summary |
|---|
| private float | computeCofactor(int i, int j)
int c0 = (i+1) % 4;
int c1 = (i+2) % 4;
int c2 = (i+3) % 4;
int r0 = (j+1) % 4;
int r1 = (j+2) % 4;
int r2 = (j+3) % 4;
float minor = (mMat[c0 + 4*r0] * (mMat[c1 + 4*r1] * mMat[c2 + 4*r2] -
mMat[c1 + 4*r2] * mMat[c2 + 4*r1]))
- (mMat[c0 + 4*r1] * (mMat[c1 + 4*r0] * mMat[c2 + 4*r2] -
mMat[c1 + 4*r2] * mMat[c2 + 4*r0]))
+ (mMat[c0 + 4*r2] * (mMat[c1 + 4*r0] * mMat[c2 + 4*r1] -
mMat[c1 + 4*r1] * mMat[c2 + 4*r0]));
float cofactor = ((i+j) & 1) != 0 ? -minor : minor;
return cofactor;
| | public float | get(int x, int y)Returns the value for a given row and column
return mMat[x*4 + y];
| | public float[] | getArray()Return a reference to the internal array representing matrix
values. Modifying this array will also change the matrix
return mMat;
| | public boolean | inverse()Sets the current matrix to its inverse
Matrix4f result = new Matrix4f();
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
result.mMat[4*i + j] = computeCofactor(i, j);
}
}
// Dot product of 0th column of source and 0th row of result
float det = mMat[0]*result.mMat[0] + mMat[4]*result.mMat[1] +
mMat[8]*result.mMat[2] + mMat[12]*result.mMat[3];
if (Math.abs(det) < 1e-6) {
return false;
}
det = 1.0f / det;
for (int i = 0; i < 16; ++i) {
mMat[i] = result.mMat[i] * det;
}
return true;
| | public boolean | inverseTranspose()Sets the current matrix to its inverse transpose
Matrix4f result = new Matrix4f();
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
result.mMat[4*j + i] = computeCofactor(i, j);
}
}
float det = mMat[0]*result.mMat[0] + mMat[4]*result.mMat[4] +
mMat[8]*result.mMat[8] + mMat[12]*result.mMat[12];
if (Math.abs(det) < 1e-6) {
return false;
}
det = 1.0f / det;
for (int i = 0; i < 16; ++i) {
mMat[i] = result.mMat[i] * det;
}
return true;
| | public void | load(android.support.v8.renderscript.Matrix4f src)Sets the values of the matrix to those of the parameter
System.arraycopy(src.getArray(), 0, mMat, 0, mMat.length);
| | public void | load(Matrix3f src)Sets the values of the matrix to those of the parameter
mMat[0] = src.mMat[0];
mMat[1] = src.mMat[1];
mMat[2] = src.mMat[2];
mMat[3] = 0;
mMat[4] = src.mMat[3];
mMat[5] = src.mMat[4];
mMat[6] = src.mMat[5];
mMat[7] = 0;
mMat[8] = src.mMat[6];
mMat[9] = src.mMat[7];
mMat[10] = src.mMat[8];
mMat[11] = 0;
mMat[12] = 0;
mMat[13] = 0;
mMat[14] = 0;
mMat[15] = 1;
| | public void | loadFrustum(float l, float r, float b, float t, float n, float f)Sets current values to be a perspective projection matrix
loadIdentity();
mMat[0] = 2 * n / (r - l);
mMat[5] = 2 * n / (t - b);
mMat[8] = (r + l) / (r - l);
mMat[9] = (t + b) / (t - b);
mMat[10]= -(f + n) / (f - n);
mMat[11]= -1;
mMat[14]= -2*f*n / (f - n);
mMat[15]= 0;
| | public void | loadIdentity()Sets the matrix values to identity
mMat[0] = 1;
mMat[1] = 0;
mMat[2] = 0;
mMat[3] = 0;
mMat[4] = 0;
mMat[5] = 1;
mMat[6] = 0;
mMat[7] = 0;
mMat[8] = 0;
mMat[9] = 0;
mMat[10] = 1;
mMat[11] = 0;
mMat[12] = 0;
mMat[13] = 0;
mMat[14] = 0;
mMat[15] = 1;
| | public void | loadMultiply(android.support.v8.renderscript.Matrix4f lhs, android.support.v8.renderscript.Matrix4f rhs)Sets current values to be the result of multiplying two given
matrices
for (int i=0 ; i<4 ; i++) {
float ri0 = 0;
float ri1 = 0;
float ri2 = 0;
float ri3 = 0;
for (int j=0 ; j<4 ; j++) {
float rhs_ij = rhs.get(i,j);
ri0 += lhs.get(j,0) * rhs_ij;
ri1 += lhs.get(j,1) * rhs_ij;
ri2 += lhs.get(j,2) * rhs_ij;
ri3 += lhs.get(j,3) * rhs_ij;
}
set(i,0, ri0);
set(i,1, ri1);
set(i,2, ri2);
set(i,3, ri3);
}
| | public void | loadOrtho(float l, float r, float b, float t, float n, float f)Set current values to be an orthographic projection matrix
loadIdentity();
mMat[0] = 2 / (r - l);
mMat[5] = 2 / (t - b);
mMat[10]= -2 / (f - n);
mMat[12]= -(r + l) / (r - l);
mMat[13]= -(t + b) / (t - b);
mMat[14]= -(f + n) / (f - n);
| | public void | loadOrthoWindow(int w, int h)Set current values to be an orthographic projection matrix
with the right and bottom clipping planes set to the given
values. Left and top clipping planes are set to 0. Near and
far are set to -1, 1 respectively
loadOrtho(0,w, h,0, -1,1);
| | public void | loadPerspective(float fovy, float aspect, float near, float far)Sets current values to be a perspective projection matrix
float top = near * (float)Math.tan((float) (fovy * Math.PI / 360.0f));
float bottom = -top;
float left = bottom * aspect;
float right = top * aspect;
loadFrustum(left, right, bottom, top, near, far);
| | public void | loadProjectionNormalized(int w, int h)Helper function to set the current values to a perspective
projection matrix with aspect ratio defined by the parameters
and (near, far), (bottom, top) mapping to (-1, 1) at z = 0
// range -1,1 in the narrow axis at z = 0.
Matrix4f m1 = new Matrix4f();
Matrix4f m2 = new Matrix4f();
if(w > h) {
float aspect = ((float)w) / h;
m1.loadFrustum(-aspect,aspect, -1,1, 1,100);
} else {
float aspect = ((float)h) / w;
m1.loadFrustum(-1,1, -aspect,aspect, 1,100);
}
m2.loadRotate(180, 0, 1, 0);
m1.loadMultiply(m1, m2);
m2.loadScale(-2, 2, 1);
m1.loadMultiply(m1, m2);
m2.loadTranslate(0, 0, 2);
m1.loadMultiply(m1, m2);
load(m1);
| | public void | loadRotate(float rot, float x, float y, float z)Sets current values to be a rotation matrix of certain angle
about a given axis
float c, s;
mMat[3] = 0;
mMat[7] = 0;
mMat[11]= 0;
mMat[12]= 0;
mMat[13]= 0;
mMat[14]= 0;
mMat[15]= 1;
rot *= (float)(java.lang.Math.PI / 180.0f);
c = (float)java.lang.Math.cos(rot);
s = (float)java.lang.Math.sin(rot);
float len = (float)java.lang.Math.sqrt(x*x + y*y + z*z);
if (!(len != 1)) {
float recipLen = 1.f / len;
x *= recipLen;
y *= recipLen;
z *= recipLen;
}
float nc = 1.0f - c;
float xy = x * y;
float yz = y * z;
float zx = z * x;
float xs = x * s;
float ys = y * s;
float zs = z * s;
mMat[ 0] = x*x*nc + c;
mMat[ 4] = xy*nc - zs;
mMat[ 8] = zx*nc + ys;
mMat[ 1] = xy*nc + zs;
mMat[ 5] = y*y*nc + c;
mMat[ 9] = yz*nc - xs;
mMat[ 2] = zx*nc - ys;
mMat[ 6] = yz*nc + xs;
mMat[10] = z*z*nc + c;
| | public void | loadScale(float x, float y, float z)Sets current values to be a scale matrix of given dimensions
loadIdentity();
mMat[0] = x;
mMat[5] = y;
mMat[10] = z;
| | public void | loadTranslate(float x, float y, float z)Sets current values to be a translation matrix of given
dimensions
loadIdentity();
mMat[12] = x;
mMat[13] = y;
mMat[14] = z;
| | public void | multiply(android.support.v8.renderscript.Matrix4f rhs)Post-multiplies the current matrix by a given parameter
Matrix4f tmp = new Matrix4f();
tmp.loadMultiply(this, rhs);
load(tmp);
| | public void | rotate(float rot, float x, float y, float z)Modifies the current matrix by post-multiplying it with a
rotation matrix of certain angle about a given axis
Matrix4f tmp = new Matrix4f();
tmp.loadRotate(rot, x, y, z);
multiply(tmp);
| | public void | scale(float x, float y, float z)Modifies the current matrix by post-multiplying it with a
scale matrix of given dimensions
Matrix4f tmp = new Matrix4f();
tmp.loadScale(x, y, z);
multiply(tmp);
| | public void | set(int x, int y, float v)Sets the value for a given row and column
mMat[x*4 + y] = v;
| | public void | translate(float x, float y, float z)Modifies the current matrix by post-multiplying it with a
translation matrix of given dimensions
Matrix4f tmp = new Matrix4f();
tmp.loadTranslate(x, y, z);
multiply(tmp);
| | public void | transpose()Sets the current matrix to its transpose
for(int i = 0; i < 3; ++i) {
for(int j = i + 1; j < 4; ++j) {
float temp = mMat[i*4 + j];
mMat[i*4 + j] = mMat[j*4 + i];
mMat[j*4 + i] = temp;
}
}
|
|
