Distorted Android

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2023 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

// This library is distributed in the hope that it will be useful,                               //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU                             //

// Lesser General Public License for more details.                                               //

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.library.helpers;

///////////////////////////////////////////////////////////////////////////////////////////////////

public class MatrixHelper

  {

  public static void setIdentity(float[] output)

    {

    output[ 0] = 1;

    output[ 1] = 0;

    output[ 2] = 0;

    output[ 3] = 0;

    output[ 4] = 0;

    output[ 5] = 1;

    output[ 6] = 0;

    output[ 7] = 0;

    output[ 8] = 0;

    output[ 9] = 0;

    output[10] = 1;

    output[11] = 0;

    output[12] = 0;

    output[13] = 0;

    output[14] = 0;

    output[15] = 1;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static void multiply(float[] output, float[] m1, float[] m2)

    {

    output[ 0] = m1[ 0]*m2[ 0] + m1[ 4]*m2[ 1] + m1[ 8]*m2[ 2] + m1[12]*m2[ 3];

    output[ 1] = m1[ 1]*m2[ 0] + m1[ 5]*m2[ 1] + m1[ 9]*m2[ 2] + m1[13]*m2[ 3];

    output[ 2] = m1[ 2]*m2[ 0] + m1[ 6]*m2[ 1] + m1[10]*m2[ 2] + m1[14]*m2[ 3];

    output[ 3] = m1[ 3]*m2[ 0] + m1[ 7]*m2[ 1] + m1[11]*m2[ 2] + m1[15]*m2[ 3];

    output[ 4] = m1[ 0]*m2[ 4] + m1[ 4]*m2[ 5] + m1[ 8]*m2[ 6] + m1[12]*m2[ 7];

    output[ 5] = m1[ 1]*m2[ 4] + m1[ 5]*m2[ 5] + m1[ 9]*m2[ 6] + m1[13]*m2[ 7];

    output[ 6] = m1[ 2]*m2[ 4] + m1[ 6]*m2[ 5] + m1[10]*m2[ 6] + m1[14]*m2[ 7];

    output[ 7] = m1[ 3]*m2[ 4] + m1[ 7]*m2[ 5] + m1[11]*m2[ 6] + m1[15]*m2[ 7];

    output[ 8] = m1[ 0]*m2[ 8] + m1[ 4]*m2[ 9] + m1[ 8]*m2[10] + m1[12]*m2[11];

    output[ 9] = m1[ 1]*m2[ 8] + m1[ 5]*m2[ 9] + m1[ 9]*m2[10] + m1[13]*m2[11];

    output[10] = m1[ 2]*m2[ 8] + m1[ 6]*m2[ 9] + m1[10]*m2[10] + m1[14]*m2[11];

    output[11] = m1[ 3]*m2[ 8] + m1[ 7]*m2[ 9] + m1[11]*m2[10] + m1[15]*m2[11];

    output[12] = m1[ 0]*m2[12] + m1[ 4]*m2[13] + m1[ 8]*m2[14] + m1[12]*m2[15];

    output[13] = m1[ 1]*m2[12] + m1[ 5]*m2[13] + m1[ 9]*m2[14] + m1[13]*m2[15];

    output[14] = m1[ 2]*m2[12] + m1[ 6]*m2[13] + m1[10]*m2[14] + m1[14]*m2[15];

    output[15] = m1[ 3]*m2[12] + m1[ 7]*m2[13] + m1[11]*m2[14] + m1[15]*m2[15];

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static void frustum(float[] output, float l, float r, float b, float t, float n, float f)

    {

    output[0]  =  2 * n / (r - l);

    output[1]  =  0;

    output[2]  =  0;

    output[3]  =  0;

    output[4]  =  0;

    output[5]  =  2 * n / (t - b);

    output[6]  =  0;

    output[7]  =  0;

    output[8]  =  (r + l) / (r - l);

    output[9]  =  (t + b) / (t - b);

    output[10] = -(f + n) / (f - n);

    output[11] = -1;

    output[12] =  0;

    output[13] =  0;

    output[14] = -(2 * f * n) / (f - n);

    output[15] =  0;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static void ortho(float[] output, float l, float r, float b, float t, float n, float f)

    {

    output[0]  =  2 / (r - l);

    output[1]  =  0;

    output[2]  =  0;

    output[3]  =  0;

    output[4]  =  0;

    output[5]  =  2 / (t - b);

    output[6]  =  0;

    output[7]  =  0;

    output[8]  =  0;

    output[9]  =  0;

    output[10] = -2 / (f - n);

    output[11] =  0;

    output[12] = -(r + l) / (r - l);

    output[13] = -(t + b) / (t - b);

    output[14] = -(f + n) / (f - n);

    output[15] =  1;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static void setLookAt(float[] output, float eyeX , float eyeY , float eyeZ ,

                                               float lookX, float lookY, float lookZ,

                                               float upX  , float upY  , float upZ  )

    {

    // TODO

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// this is android.opengl.Matrix.rotateM(), but with pre-computed sin and cos of the angle

// and also we have to pre-allocate and pass here two temp arrays.

  public static void rotateSinCos(float[] output, float[] tmp1, float[] tmp2, float sin, float cos, float x, float y, float z)

    {

    tmp1[0]  = (1-cos)*x*x + cos;

    tmp1[1]  = (1-cos)*x*y + sin*z;

    tmp1[2]  = (1-cos)*x*z - sin*y;

    tmp1[3]  = 0;

    tmp1[4]  = (1-cos)*x*y - sin*z;

    tmp1[5]  = (1-cos)*y*y + cos;

    tmp1[6]  = (1-cos)*y*z + sin*x;

    tmp1[7]  = 0;

    tmp1[8]  = (1-cos)*x*z + sin*y;

    tmp1[9]  = (1-cos)*y*z - sin*x;

    tmp1[10] = (1-cos)*z*z + cos;

    tmp1[11] = 0;

    tmp1[12] = 0;

    tmp1[13] = 0;

    tmp1[14] = 0;

    tmp1[15] = 1;

    tmp2[0]  =  output[ 0];

    tmp2[1]  =  output[ 1];

    tmp2[2]  =  output[ 2];

    tmp2[3]  =  output[ 3];

    tmp2[4]  =  output[ 4];

    tmp2[5]  =  output[ 5];

    tmp2[6]  =  output[ 6];

    tmp2[7]  =  output[ 7];

    tmp2[8]  =  output[ 8];

    tmp2[9]  =  output[ 9];

    tmp2[10] =  output[10];

    tmp2[11] =  output[11];

    tmp2[12] =  output[12];

    tmp2[13] =  output[13];

    tmp2[14] =  output[14];

    tmp2[15] =  output[15];

    multiply(output,tmp2,tmp1);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static void translate(float[] output, float dx, float dy, float dz)

    {

    output[12] += ( output[ 0]*dx + output[ 4]*dy + output[ 8]*dz);

    output[13] += ( output[ 1]*dx + output[ 5]*dy + output[ 9]*dz);

    output[14] += ( output[ 2]*dx + output[ 6]*dy + output[10]*dz);

    output[15] += ( output[ 3]*dx + output[ 7]*dy + output[11]*dz);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static void scale(float[] output, float sx, float sy, float sz)

    {

    output[ 0] *= sx;

    output[ 1] *= sx;

    output[ 2] *= sx;

    output[ 3] *= sx;

    output[ 4] *= sy;

    output[ 5] *= sy;

    output[ 6] *= sy;

    output[ 7] *= sy;

    output[ 8] *= sz;

    output[ 9] *= sz;

    output[10] *= sz;

    output[11] *= sz;

    }

  }