content: /*
   * Copyright (C) 2009-2012 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package androidx.renderscript;
  
  import java.lang.Math;
  import android.util.Log;
  
  
  /**
   * Class for exposing the native RenderScript rs_matrix4x4 type back to the Android system.
   *
   **/
  public class Matrix4f {
  
      /**
      * Creates a new identity 4x4 matrix
      */
      public Matrix4f() {
          mMat = new float[16];
          loadIdentity();
      }
  
      /**
      * Creates a new matrix and sets its values from the given
      * parameter
      *
      * @param dataArray values to set the matrix to, must be 16
      *                  floats long
      */
      public Matrix4f(float[] dataArray) {
          mMat = new float[16];
          System.arraycopy(dataArray, 0, mMat, 0, mMat.length);
      }
  
      /**
      * Return a reference to the internal array representing matrix
      * values. Modifying this array will also change the matrix
      *
      * @return internal array representing the matrix
      */
      public float[] getArray() {
          return mMat;
      }
  
      /**
      * Returns the value for a given row and column
      *
      * @param x column of the value to return
      * @param y row of the value to return
      *
      * @return value in the yth row and xth column
      */
      public float get(int x, int y) {
          return mMat[x*4 + y];
      }
  
      /**
      * Sets the value for a given row and column
      *
      * @param x column of the value to set
      * @param y row of the value to set
      */
      public void set(int x, int y, float v) {
          mMat[x*4 + y] = v;
      }
  
      /**
      * Sets the matrix values to identity
      */
      public void loadIdentity() {
          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;
      }
  
      /**
      * Sets the values of the matrix to those of the parameter
      *
      * @param src matrix to load the values from
      */
      public void load(Matrix4f src) {
          System.arraycopy(src.getArray(), 0, mMat, 0, mMat.length);
      }
  
      /**
      * Sets the values of the matrix to those of the parameter
      *
      * @param src matrix to load the values from
      * @hide
      */
      public void load(Matrix3f src) {
          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;
      }
  
      /**
      * Sets current values to be a rotation matrix of certain angle
      * about a given axis
      *
      * @param rot angle of rotation
      * @param x rotation axis x
      * @param y rotation axis y
      * @param z rotation axis z
      */
      public void loadRotate(float rot, float x, float y, float z) {
          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;
      }
  
      /**
      * Sets current values to be a scale matrix of given dimensions
      *
      * @param x scale component x
      * @param y scale component y
      * @param z scale component z
      */
      public void loadScale(float x, float y, float z) {
          loadIdentity();
          mMat[0] = x;
          mMat[5] = y;
          mMat[10] = z;
      }
  
      /**
      * Sets current values to be a translation matrix of given
      * dimensions
      *
      * @param x translation component x
      * @param y translation component y
      * @param z translation component z
      */
      public void loadTranslate(float x, float y, float z) {
          loadIdentity();
          mMat[12] = x;
          mMat[13] = y;
          mMat[14] = z;
      }
  
      /**
      * Sets current values to be the result of multiplying two given
      * matrices
      *
      * @param lhs left hand side matrix
      * @param rhs right hand side matrix
      */
      public void loadMultiply(Matrix4f lhs, Matrix4f rhs) {
          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);
          }
      }
  
      /**
      * Set current values to be an orthographic projection matrix
      *
      * @param l location of the left vertical clipping plane
      * @param r location of the right vertical clipping plane
      * @param b location of the bottom horizontal clipping plane
      * @param t location of the top horizontal clipping plane
      * @param n location of the near clipping plane
      * @param f location of the far clipping plane
      */
      public void loadOrtho(float l, float r, float b, float t, float n, float f) {
          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);
      }
  
      /**
      * 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
      *
      * @param w location of the right vertical clipping plane
      * @param h location of the bottom horizontal clipping plane
      *
      */
      public void loadOrthoWindow(int w, int h) {
          loadOrtho(0,w, h,0, -1,1);
      }
  
      /**
      * Sets current values to be a perspective projection matrix
      *
      * @param l location of the left vertical clipping plane
      * @param r location of the right vertical clipping plane
      * @param b location of the bottom horizontal clipping plane
      * @param t location of the top horizontal clipping plane
      * @param n location of the near clipping plane, must be positive
      * @param f location of the far clipping plane, must be positive
      *
      */
      public void loadFrustum(float l, float r, float b, float t, float n, float f) {
          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;
      }
  
      /**
      * Sets current values to be a perspective projection matrix
      *
      * @param fovy vertical field of view angle in degrees
      * @param aspect aspect ratio of the screen
      * @param near near cliping plane, must be positive
      * @param far far clipping plane, must be positive
      */
      public void loadPerspective(float fovy, float aspect, float near, float far) {
          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);
      }
  
      /**
      * 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
      *
      * @param w screen width
      * @param h screen height
      */
      public void loadProjectionNormalized(int w, int h) {
          // 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);
      }
  
      /**
      * Post-multiplies the current matrix by a given parameter
      *
      * @param rhs right hand side to multiply by
      */
      public void multiply(Matrix4f rhs) {
          Matrix4f tmp = new Matrix4f();
          tmp.loadMultiply(this, rhs);
          load(tmp);
      }
      /**
      * Modifies the current matrix by post-multiplying it with a
      * rotation matrix of certain angle about a given axis
      *
      * @param rot angle of rotation
      * @param x rotation axis x
      * @param y rotation axis y
      * @param z rotation axis z
      */
      public void rotate(float rot, float x, float y, float z) {
          Matrix4f tmp = new Matrix4f();
          tmp.loadRotate(rot, x, y, z);
          multiply(tmp);
      }
  
      /**
      * Modifies the current matrix by post-multiplying it with a
      * scale matrix of given dimensions
      *
      * @param x scale component x
      * @param y scale component y
      * @param z scale component z
      */
      public void scale(float x, float y, float z) {
          Matrix4f tmp = new Matrix4f();
          tmp.loadScale(x, y, z);
          multiply(tmp);
      }
  
      /**
      * Modifies the current matrix by post-multiplying it with a
      * translation matrix of given dimensions
      *
      * @param x translation component x
      * @param y translation component y
      * @param z translation component z
      */
      public void translate(float x, float y, float z) {
          Matrix4f tmp = new Matrix4f();
          tmp.loadTranslate(x, y, z);
          multiply(tmp);
      }
      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;
      }
  
      /**
      * Sets the current matrix to its inverse
      */
      public boolean 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;
      }
  
      /**
      * Sets the current matrix to its inverse transpose
      */
      public boolean inverseTranspose() {
  
          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;
      }
  
      /**
      * Sets the current matrix to its transpose
      */
      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[i*4 + j] = mMat[j*4 + i];
                  mMat[j*4 + i] = temp;
              }
          }
      }
  
      final float[] mMat;
  }
  