Adding more matrix math functions. (518f033b) · Commits · e / os / android_frameworks_base

graphics/java/android/renderscript/Matrix2f.java

+5 −0

Original line number	Diff line number	Diff line
		@@ -96,6 +96,11 @@ public class Matrix2f {
		tmp.loadScale(x, y);
		multiply(tmp);
		}
		public void transpose() {
		float temp = mMat[1];
		mMat[1] = mMat[2];
		mMat[2] = temp;
		}

		final float[] mMat;
		}

graphics/java/android/renderscript/Matrix3f.java

+9 −0

Original line number	Diff line number	Diff line
		@@ -165,6 +165,15 @@ public class Matrix3f {
		tmp.loadTranslate(x, y);
		multiply(tmp);
		}
		public void transpose() {
		for(int i = 0; i < 2; ++i) {
		for(int j = i + 1; j < 3; ++j) {
		float temp = mMat[i*3 + j];
		mMat[i3 + j] = mMat[j3 + i];
		mMat[j*3 + i] = temp;
		}
		}
		}

		final float[] mMat;
		}

graphics/java/android/renderscript/Matrix4f.java

+9 −0

Original line number	Diff line number	Diff line
		@@ -179,6 +179,15 @@ public class Matrix4f {
		tmp.loadTranslate(x, y, z);
		multiply(tmp);
		}
		public void transpose() {
		for(int i = 0; i < 3; ++i) {
		for(int j = i + 1; j < 4; ++j) {
		float temp = mMat[i*4 + j];
		mMat[i4 + j] = mMat[j4 + i];
		mMat[j*4 + i] = temp;
		}
		}
		}

		final float[] mMat;
		}

libs/rs/rsContext.cpp

+8 −8

Original line number	Diff line number	Diff line
		@@ -263,38 +263,38 @@ void Context::displayDebugStats()
		{
		char buffer[128];
		sprintf(buffer, "Frame %i ms, Script %i ms", mTimeMSLastFrame, mTimeMSLastScript);
		float oldR = mStateVertex.color[0];
		/*float oldR = mStateVertex.color[0];
		float oldG = mStateVertex.color[1];
		float oldB = mStateVertex.color[2];
		float oldA = mStateVertex.color[3];
		float oldA = mStateVertex.color[3];*/

		float shadowCol = 0.2f;
		mStateVertex.color[0] = shadowCol;
		/*mStateVertex.color[0] = shadowCol;
		mStateVertex.color[1] = shadowCol;
		mStateVertex.color[2] = shadowCol;
		mStateVertex.color[3] = 1.0f;
		if (!checkVersion2_0()) {
		glColor4f(shadowCol, shadowCol, shadowCol, 1.0f);
		}
		}*/
		mStateFont.renderText(buffer, 5, getHeight() - 5);

		float textCol = 0.9f;
		/*float textCol = 0.9f;
		mStateVertex.color[0] = textCol;
		mStateVertex.color[1] = textCol;
		mStateVertex.color[2] = textCol;
		mStateVertex.color[3] = 1.0f;
		if (!checkVersion2_0()) {
		glColor4f(textCol, textCol, textCol, 1.0f);
		}
		}*/
		mStateFont.renderText(buffer, 4, getHeight() - 6);

		mStateVertex.color[0] = oldR;
		/*mStateVertex.color[0] = oldR;
		mStateVertex.color[1] = oldG;
		mStateVertex.color[2] = oldB;
		mStateVertex.color[3] = oldA;
		if (!checkVersion2_0()) {
		glColor4f(oldR, oldG, oldB, oldA);
		}
		}*/
		}

		void * Context::threadProc(void *vrsc)

libs/rs/scriptc/rs_core.rsh

+118 −0

Original line number	Diff line number	Diff line
		@@ -476,6 +476,124 @@ rsMatrixMultiply(rs_matrix2x2 *m, float2 in) {
		return ret;
		}

		// Returns true if the matrix was successfully inversed
		static bool __attribute__((overloadable))
		rsMatrixInverse(rs_matrix4x4 *m) {
		rs_matrix4x4 result;

		int i, j;
		for (i = 0; i < 4; ++i) {
		for (j = 0; j < 4; ++j) {
		// computeCofactor for 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 = (m->m[c0 + 4r0] (m->m[c1 + 4r1] m->m[c2 + 4r2] - m->m[c1 + 4r2] * m->m[c2 + 4*r1]))
		- (m->m[c0 + 4r1] (m->m[c1 + 4r0] m->m[c2 + 4r2] - m->m[c1 + 4r2] * m->m[c2 + 4*r0]))
		+ (m->m[c0 + 4r2] (m->m[c1 + 4r0] m->m[c2 + 4r1] - m->m[c1 + 4r1] * m->m[c2 + 4*r0]));

		float cofactor = (i+j) & 1 ? -minor : minor;

		result.m[4*i + j] = cofactor;
		}
		}

		// Dot product of 0th column of source and 0th row of result
		float det = m->m[0]result.m[0] + m->m[4]result.m[1] +
		m->m[8]result.m[2] + m->m[12]result.m[3];

		if (fabs(det) < 1e-6) {
		return false;
		}

		det = 1.0f / det;
		for (i = 0; i < 16; ++i) {
		m->m[i] = result.m[i] * det;
		}

		return true;
		}

		// Returns true if the matrix was successfully inversed
		static bool __attribute__((overloadable))
		rsMatrixInverseTranspose(rs_matrix4x4 *m) {
		rs_matrix4x4 result;

		int i, j;
		for (i = 0; i < 4; ++i) {
		for (j = 0; j < 4; ++j) {
		// computeCofactor for 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 = (m->m[c0 + 4r0] (m->m[c1 + 4r1] m->m[c2 + 4r2] - m->m[c1 + 4r2] * m->m[c2 + 4*r1]))
		- (m->m[c0 + 4r1] (m->m[c1 + 4r0] m->m[c2 + 4r2] - m->m[c1 + 4r2] * m->m[c2 + 4*r0]))
		+ (m->m[c0 + 4r2] (m->m[c1 + 4r0] m->m[c2 + 4r1] - m->m[c1 + 4r1] * m->m[c2 + 4*r0]));

		float cofactor = (i+j) & 1 ? -minor : minor;

		result.m[4*j + i] = cofactor;
		}
		}

		// Dot product of 0th column of source and 0th column of result
		float det = m->m[0]result.m[0] + m->m[4]result.m[4] +
		m->m[8]result.m[8] + m->m[12]result.m[12];

		if (fabs(det) < 1e-6) {
		return false;
		}

		det = 1.0f / det;
		for (i = 0; i < 16; ++i) {
		m->m[i] = result.m[i] * det;
		}

		return true;
		}

		static void __attribute__((overloadable))
		rsMatrixTranspose(rs_matrix4x4 *m) {
		int i, j;
		float temp;
		for (i = 0; i < 3; ++i) {
		for (j = i + 1; j < 4; ++j) {
		temp = m->m[i*4 + j];
		m->m[i4 + j] = m->m[j4 + i];
		m->m[j*4 + i] = temp;
		}
		}
		}

		static void __attribute__((overloadable))
		rsMatrixTranspose(rs_matrix3x3 *m) {
		int i, j;
		float temp;
		for (i = 0; i < 2; ++i) {
		for (j = i + 1; j < 3; ++j) {
		temp = m->m[i*3 + j];
		m->m[i3 + j] = m->m[j4 + i];
		m->m[j*3 + i] = temp;
		}
		}
		}

		static void __attribute__((overloadable))
		rsMatrixTranspose(rs_matrix2x2 *m) {
		float temp = m->m[1];
		m->m[1] = m->m[2];
		m->m[2] = temp;
		}


		/////////////////////////////////////////////////////
		// int ops
		/////////////////////////////////////////////////////