Matrix Utils : Matrix « Game « Android

Matrix Utils

```
//package edu.union;

class FixedPointUtils {
public static final int ONE = 0x10000;

/**
* Convert a float to  16.16 fixed-point representation
* @param val The value to convert
* @return The resulting fixed-point representation
*/
public static int toFixed(float val) {
return (int)(val * 65536F);
}
/**
* Convert an array of floats to 16.16 fixed-point
* @param arr The array
* @return A newly allocated array of fixed-point values.
*/
public static int[] toFixed(float[] arr) {
int[] res = new int[arr.length];
toFixed(arr, res);
return res;
}
/**
* Convert an array of floats to 16.16 fixed-point
* @param arr The array of floats
* @param storage The location to store the fixed-point values.
*/
public static void toFixed(float[] arr, int[] storage)
{
for (int i=0;i<storage.length;i++) {
storage[i] = toFixed(arr[i]);
}
}
/**
* Convert a 16.16 fixed-point value to floating point
* @param val The fixed-point value
* @return The equivalent floating-point value.
*/
public static float toFloat(int val) {
return ((float)val)/65536.0f;
}
/**
* Convert an array of 16.16 fixed-point values to floating point
* @param arr The array to convert
* @return A newly allocated array of floats.
*/
public static float[] toFloat(int[] arr) {
float[] res = new float[arr.length];
toFloat(arr, res);
return res;
}
/**
* Convert an array of 16.16 fixed-point values to floating point
* @param arr The array to convert
* @param storage Pre-allocated storage for the result.
*/
public static void toFloat(int[] arr, float[] storage)
{
for (int i=0;i<storage.length;i++) {
storage[i] = toFloat(arr[i]);
}
}
/**
* Multiply two fixed-point values.
* @param x
* @param y
* @return
*/
public static int multiply (int x, int y) {
long z = (long) x * (long) y;
return ((int) (z >> 16));
}
/**
* Divide two fixed-point values.
* @param x
* @param y
* @return
*/
public static int divide (int x, int y) {
long z = (((long) x) << 32);
return (int) ((z / y) >> 16);
}
/**
* Find the sqrt of a fixed-point value.
* @param n
* @return
*/
public static int sqrt (int n) {
int s = (n + 65536) >> 1;
for (int i = 0; i < 8; i++) {
//converge six times
s = (s + divide(n, s)) >> 1;
}
return s;
}
}

class MatrixUtils {

/**
* Returns the transpose of a 4x4 matrix
* @param m The matrix to transpose
* @param result The place to store the transposed matrix
**/
public static void transpose(float[][] m, float[][] result) {
for (int i=0;i<4;i++)
for (int j=0;j<4;j++)
result[j][i] = m[i][j];
}

public static void transpose(float[]m, float[] result) {
for (int i=0;i<4;i++)
for (int j=0;j<4;j++)
result[j*4+i] = m[i*4+j];
}
/**
* Converts this vector into a normalized (unit length) vector
* <b>Modifies the input parameter</b>
* @param vector The vector to normalize
**/
public static void normalize(float[] vector) {
scalarMultiply(vector, 1/magnitude(vector));
}
/**
* Converts this vector into a normalized (unit length) vector
* <b>Modifies the input parameter</b>
* @param vector The vector to normalize
**/
public static void normalize(int[] vector) {
scalarMultiply(vector, 1/magnitude(vector));
}

/**
* Copy a vector from <code>from</code> into <code>to</code>
* @param from The source
* @param to The destination
**/
public static void copy(float[] from, float[] to) {
for (int i=0;i<from.length;i++) {
to[i] = from[i];
}
}
/**
* Multiply two matrices by each other and store the result.
* result = m1 x m2
* @param m1 The first matrix
* @param m2 The second matrix
* @param reuslt Where to store the product of m1 x m2
**/
public static void multiply(float[][] m1, float[][] m2, float[][] result) {
for (int i=0;i<4;i++) {
for (int j=0;j<4;j++) {
result[i][j] =
m1[i][0]*m2[0][j]+
m1[i][1]*m2[1][j]+
m1[i][2]*m2[2][j]+
m1[i][3]*m2[3][j];
}
}
}
/**
* Multiply a vector by a scalar.  <b>Modifies the input vector</b>
* @param vector The vector
* @param scalar The scalar
**/
public static void scalarMultiply(float[] vector, float scalar) {
for (int i=0;i<vector.length;i++)
vector[i] *= scalar;
}
/**
* Multiply a vector by a scalar.  <b>Modifies the input vector</b>
* @param vector The vector
* @param scalar The scalar
**/
public static void scalarMultiply(int[] vector, int scalar) {
for (int i=0;i<vector.length;i++)
vector[i] = FixedPointUtils.multiply(vector[i],scalar);
}

/**
* Create the identity matrix I
* @param matrix The matrix to store the identity matrix in.
**/
public static void identity(float[][] matrix) {
for (int i=0;i<4;i++)
for (int j=0;j<4;j++)
matrix[i][j] = (i==j)?1:0;
}
/**
* Compute the dot product of two vectors
* @param v1 The first vector
* @param v2 The second vector
* @return v1 dot v2
**/
public static float dot(float[] v1, float[] v2) {
float res = 0;
for (int i=0;i<v1.length;i++)
res += v1[i]*v2[i];
return res;
}

/**
* Compute the cross product of two vectors
* @param v1 The first vector
* @param v2 The second vector
* @param result Where to store the cross product
**/
public static void cross(float[] p1, float[] p2, float[] result) {
result[0] = p1[1]*p2[2]-p2[1]*p1[2];
result[1] = p1[2]*p2[0]-p2[2]*p1[0];
result[2] = p1[0]*p2[1]-p2[0]*p1[1];
}
/**
* Compute the cross product of two vectors
* @param v1 The first vector
* @param v2 The second vector
* @param result Where to store the cross product
**/
public static void cross(int[] p1, int[] p2, int[] result) {
result[0] = FixedPointUtils.multiply(p1[1],p2[2])-FixedPointUtils.multiply(p2[1],p1[2]);
result[1] = FixedPointUtils.multiply(p1[2],p2[0])-FixedPointUtils.multiply(p2[2],p1[0]);
result[2] = FixedPointUtils.multiply(p1[0],p2[1])-FixedPointUtils.multiply(p2[0],p1[1]);
}
/**
* Compute the magnitude (length) of a vector
* @param vector The vector
* @return The magnitude of the vector
**/
public static float magnitude(float[] vector) {
return (float)Math.sqrt(vector[0]*vector[0]+
vector[1]*vector[1]+
vector[2]*vector[2]);
}

/**
* Compute the magnitude (length) of a vector
* @param vector The vector
* @return The magnitude of the vector
**/
public static int magnitude(int[] vector) {
return FixedPointUtils.sqrt(FixedPointUtils.multiply(vector[0],vector[0])+
FixedPointUtils.multiply(vector[1],vector[1])+
FixedPointUtils.multiply(vector[2],vector[2]));
}

public static void rotateZ(float[] v, float angle, float[] out) {
float[][] R = new float[4][4];
R[0][0] = (float)Math.cos(angle);
R[0][1] = (float)-Math.sin(angle);
R[1][0] = (float)Math.sin(angle);
R[1][1] = (float)Math.cos(angle);
R[2][2] = R[3][3] = 1;

multiply(R, v, out);
}

public static void rotateY(float[] v, float angle, float[] out) {
float[][] R = new float[4][4];
R[0][0] = (float)Math.cos(angle);
R[0][2] = (float)-Math.sin(angle);
R[1][0] = (float)Math.sin(angle);
R[1][2] = (float)Math.cos(angle);
R[1][1] = R[3][3] = 1;

multiply(R, v, out);
}

/**
* Multiply a vector and a matrix.  result = matrix x vector
* @param matrix The matrix.
* @param vector The vector
* @param result The result of the multiplication
**/
public static void multiply(float[][] matrix, float[] vector, float[] res)
{
for (int i=0;i<4;i++) {
res[i] =
matrix[i][0]*vector[0]+
matrix[i][1]*vector[1]+
matrix[i][2]*vector[2]+
matrix[i][3]*vector[3];
}
}

/**
* Pretty print a matrix to stdout.
* @param matrix The matrix
**/
public static void printMatrix(float[][] matrix) {
for (int i=0;i<4;i++) {
for (int j=0;j<4;j++)
System.out.print(matrix[i][j]+"\t");
System.out.println();
}
}

/**
* Homogenize a point (divide by its last element)
* @param pt The point <b>Modified</b>
**/
public static void homogenize(float[] pt)
{
scalarMultiply(pt, 1/pt[3]);
}

/**
* Pretty print a vector
* @param vec The vector to print
**/
public static void printVector(float[] vec) {
for (int i=0;i<vec.length;i++)
System.out.println(vec[i]);
}

/**
* Subtracts two vectors (a-b).
* @param a The first vector
* @param b The second vector
* @param result Storage for the result, if null, store in a.
**/
public static void minus(float[] a, float[] b, float[] result) {
float[] res = (result == null)?a:result;
for (int i=0;i<Math.min(a.length,b.length);i++)
res[i] = a[i]-b[i];
}

/**
* Subtracts two vectors (a-b).
* @param a The first vector
* @param b The second vector
* @param result Storage for the result, if null, store in a.
**/
public static void minus(int[] a, int[] b, int[] result) {
int[] res = (result == null)?a:result;
for (int i=0;i<Math.min(a.length,b.length);i++)
res[i] = a[i]-b[i];
}

/**
* @param a The first vector
* @param b The second vector
* @param result Storage for the result, if null, store in a.
**/
public static void plus(float[] a, float[] b, float[] result) {
float[] res = (result == null)?a:result;
for (int i=0;i<a.length;i++)
res[i] = a[i]+b[i];
}

/**
* @param a The first vector
* @param b The second vector
* @param result Storage for the result, if null, store in a.
**/
public static void plus(int[] a, int[] b, int[] result) {
int[] res = (result == null)?a:result;
for (int i=0;i<a.length;i++)
res[i] = a[i]+b[i];
}
}

```

Related examples in the same category

 1 How to implement a Matrix Palette 2 Matrix Operations 3 Rotate Matrix 4 Returns the transpose of a 4x4 matrix