Distorted Android

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

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted 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 General Public License for more details.                                                  //

//                                                                                               //

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

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

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

package org.distorted.examples.meshfile;

import android.content.Context;

import android.content.res.Resources;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.opengl.GLSurfaceView;

import org.distorted.examples.R;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffectDisappear;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshFile;

import org.distorted.library.type.DynamicQuat;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import java.io.DataInputStream;

import java.io.IOException;

import java.io.InputStream;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import static org.distorted.examples.meshfile.MeshFileActivity.PROCEDURAL;

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

class MeshFileRenderer implements GLSurfaceView.Renderer, DistortedLibrary.ExceptionListener

{

    private static final float SQ2 = (float)Math.sqrt(2);

    private static final float SQ3 = (float)Math.sqrt(3);

    private static final float SQ5 = (float)Math.sqrt(5);

    private final float DEFAULT_SCALE = 0.3f;

    private final GLSurfaceView mView;

    private DistortedTexture mTexture;

    private final DistortedScreen mScreen;

    private final DistortedEffects mEffects;

    private final Static3D mScale;

    private long mTime;

    private float mCurrentScale;

    private MeshBase mMesh;

    Static4D mQuat1, mQuat2;

    int mScreenMin;

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

    MeshFileRenderer(GLSurfaceView v)

      {

      mView = v;

      mScreen = new DistortedScreen();

      mScale= new Static3D(1,1,1);

      Static3D center=new Static3D(0,0,0);

      mCurrentScale = DEFAULT_SCALE;

      mQuat1 = new Static4D(0,0,0,1);

      mQuat2 = new Static4D(0,0,0,1);

      DynamicQuat quatInt1 = new DynamicQuat(0,0.5f);

      DynamicQuat quatInt2 = new DynamicQuat(0,0.5f);

      quatInt1.add(mQuat1);

      quatInt2.add(mQuat2);

      VertexEffectDisappear disappear = new VertexEffectDisappear();

      disappear.setMeshAssociation(1,-1);

      mEffects = new DistortedEffects();

      mEffects.apply( new MatrixEffectQuaternion(quatInt2, center) );

      mEffects.apply( new MatrixEffectQuaternion(quatInt1, center) );

      mEffects.apply( new MatrixEffectScale(mScale));

      mEffects.apply( disappear );

      mScreen.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);

      mScreen.showFPS();

      }

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

    public void onDrawFrame(GL10 glUnused) 

      {

      mScreen.render( System.currentTimeMillis() );

      }

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

    public void onSurfaceChanged(GL10 glUnused, int width, int height) 

      {

      mScreenMin = Math.min(width, height);

      float factor = mCurrentScale*mScreenMin;

      mScale.set(factor,factor,factor);

      mScreen.resize(width, height);

      }

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

    public void onSurfaceCreated(GL10 glUnused, EGLConfig config) 

      {

      if( mTexture==null ) mTexture = new DistortedTexture();

      Effect.enableEffects(EffectType.VERTEX);

      DistortedLibrary.setMax(EffectType.VERTEX, 20);

      DistortedLibrary.needTransformFeedback();

      DistortedLibrary.onSurfaceCreated(mView.getContext(), this);

      }

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

    public void distortedException(Exception ex)

      {

      android.util.Log.e("MeshFile", ex.getMessage() );

      }

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

//   0 ---> 0

//  50 ---> DEFAULT_SCALE

// 100 ---> 4*DEFAULT_SCALE

    void setScale(int scale)

      {

      if( scale<= 50 )

        {

        mCurrentScale = DEFAULT_SCALE * scale / 50.0f;

        }

      else

        {

        mCurrentScale = DEFAULT_SCALE * ( 3*(scale/50.0f) - 2.0f);

        }

      float factor = mCurrentScale*mScreenMin;

      mScale.set(factor,factor,factor);

      }

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

    void open(int resourceID)

      {

      if( mTexture==null ) mTexture = new DistortedTexture();

      mTexture.setTexture( createTexture(resourceID) );

      long t1 = System.currentTimeMillis();

      if( resourceID!=PROCEDURAL )

        {

        openMesh(resourceID);

        }

      else

        {

        createMesh();

        }

      long t2 = System.currentTimeMillis();

      mTime = t2-t1;

      mScreen.detachAll();

      mScreen.attach(mTexture,mEffects,mMesh);

      }

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

    private Bitmap createTexture(int resourceID)

      {

      TextureFactory factory = TextureFactory.getInstance();

      float[] vertices;

      int[] colors;

      float F = 0.5f;

      float E = SQ3/2;

      float G = SQ2/4;

      switch(resourceID)

          {

          case  R.raw.deferredjob:

          case  R.raw.meshjoin   :

          case  PROCEDURAL       :

          case  R.raw.predeform  : return createWhiteTexture();

          case  R.raw.cube2      :

          case  R.raw.cube3      :

          case  R.raw.cube4      :

          case  R.raw.cube5      : colors = new int[] { 0xffffff00, 0xffffffff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffb5651d };

                                   vertices = new float[] { -F,-F, +F,-F, +F,+F, -F,+F};

                                   return factory.createTexture(vertices,colors,0.10f, 0.10f, true);

          case  R.raw.pyra3      :

          case  R.raw.pyra4      :

          case  R.raw.pyra5      : colors = new int[] { 0xffffff00, 0xff00ff00, 0xff0000ff, 0xffff0000 };

                                   vertices = new float[] { -F,-E/3, +F,-E/3, 0.0f,2*E/3};

                                   return factory.createTexture(vertices,colors,0.05f, 0.05f, true);

          case  R.raw.dino       : colors = new int[] { 0xffffff00, 0xffffffff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffb5651d };

                                   vertices = new float[] { -F,F/3, 0,-2*F/3, +F,F/3 };

                                   return factory.createTexture(vertices,colors,0.05f, 0.03f, true);

          case R.raw.skewb       : colors = new int[] { 0xffffff00, 0xffffffff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffb5651d };

                                   //vertices = new float[] { -G,-G, +G,-G, +G,+G, -G,+G };

                                   vertices = new float[] { -F+F/4,F/4, F/4,-F+F/4, F/4,F/4};

                                   return factory.createTexture(vertices,colors,0.05f, 0.08f, true);

          }

      return null;

      }

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

    private Bitmap createWhiteTexture()

      {

      int SIZE = 1;

      Bitmap bitmap = Bitmap.createBitmap(SIZE,SIZE, Bitmap.Config.ARGB_8888);

      Canvas canvas = new Canvas(bitmap);

      Paint paint = new Paint();

      paint.setColor(0xffffff55);

      paint.setStyle(Paint.Style.FILL);

      canvas.drawRect(0, 0, SIZE, SIZE, paint);

      return bitmap;

      }

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

    private void createMesh()

      {

      int mode = 12;

      int numComponents = 0;

      double[][] vertices = null;

      int[][] vertIndexes = null;

      float[][] bands     = null;

      int[] bandIndexes   = null;

      float[][] corners   = null;

      int[] cornerIndexes = null;

      float[][] centers   = null;

      int[] centerIndexes = null;

      ///// CUBE ////////////////////////////////////////////////////////////////////////////////

      if( mode==0 )

        {

        vertices = new double[][]

          {

              { 0.5, 0.5, 0.5 },

              { 0.5, 0.5,-0.5 },

              { 0.5,-0.5, 0.5 },

              { 0.5,-0.5,-0.5 },

              {-0.5, 0.5, 0.5 },

              {-0.5, 0.5,-0.5 },

              {-0.5,-0.5, 0.5 },

              {-0.5,-0.5,-0.5 },

          };

        vertIndexes = new int[][]

          {

              {2,3,1,0},   // counterclockwise!

              {7,6,4,5},

              {4,0,1,5},

              {7,3,2,6},

              {6,2,0,4},

              {3,7,5,1}

          };

        bands = new float[][]

          {

              {0.05f,40,0.5f,0.2f,5,  2,2}

          };

        bandIndexes = new int[] { 0,0,0,0,0,0 };

        corners = new float[][]

          {

              { 0.01f, 0.10f }

          };

        cornerIndexes = new int[] { 0,0,0,0,0,0,0,0 };

        centers = new float[][]

          {

              { 0.0f, 0.0f, 0.0f }

          };

        centerIndexes = new int[] { 0,0,0,0,0,0,0,0 };

        numComponents = 8;

        }

      ///// TETRAHEDRON //////////////////////////////////////////////////////////////////////////

      else if( mode==1 )

        {

        vertices = new double[][]

          {

              {-0.5, SQ2/4, 0.0},

              { 0.5, SQ2/4, 0.0},

              { 0.0,-SQ2/4, 0.5},

              { 0.0,-SQ2/4,-0.5}

          };

        vertIndexes = new int[][]

          {

              {2,1,0},   // counterclockwise!

              {2,3,1},

              {3,2,0},

              {3,0,1}

          };

        bands = new float[][]

          {

              {0.05f,30,0.6f,0.5f,5,  2,2}

          };

        bandIndexes = new int[] { 0,0,0,0 };

        corners = new float[][]

          {

              { 0.02f, 0.10f }

          };

        cornerIndexes = new int[] { 0,0,0,0 };

        centers = new float[][]

          {

              { 0.0f, 0.0f, 0.0f }

          };

        centerIndexes = new int[] { 0,0,0,0 };

        numComponents = 4;

        }

      ///// DINO ////////////////////////////////////////////////////////////////////////////////

      else if( mode==2 )

        {

        vertices = new double[][]

          {

              {-0.5, 0.0, 0.0},

              { 0.5, 0.0, 0.0},

              { 0.0,-0.5, 0.0},

              { 0.0, 0.0,-0.5}

          };

        vertIndexes = new int[][]

          {

              {2,1,0},   // counterclockwise!

              {2,3,1},

              {3,2,0},

              {3,0,1}

          };

        bands = new float[][]

          {

              {0.028f,30,0.25f,0.1f,7,  2,5},

              {0.001f,30,0.25f,0.1f,7,  1,2}

          };

        bandIndexes = new int[] { 0,1,1,0 };

        corners = new float[][]

          {

              { 0.02f, 0.04f }

          };

        cornerIndexes = new int[] { 0,0,0,0 };

        centers = new float[][]

          {

              { 0.0f,-0.25f,-0.25f }

          };

        centerIndexes = new int[] { 0,0,0,0 };

        numComponents = 4;

        }

      ///// OCTAHEDRON ////////////////////////////////////////////////////////////////////////////

      else if( mode==3 )

        {

        vertices = new double[][]

          {

              { 0.5,   0.0, 0.5},

              { 0.5,   0.0,-0.5},

              {-0.5,   0.0,-0.5},

              {-0.5,   0.0, 0.5},

              { 0.0, SQ2/2, 0.0},

              { 0.0,-SQ2/2, 0.0},

          };

        vertIndexes = new int[][]

          {

              {3,0,4},   // counterclockwise!

              {0,1,4},

              {1,2,4},

              {2,3,4},

              {5,0,3},

              {5,1,0},

              {5,2,1},

              {5,3,2}

          };

        bands = new float[][]

          {

             {0.05f,17,0.5f,0.2f,5,  2,2}

          };

        bandIndexes = new int[] { 0,0,0,0,0,0,0,0 };

        corners = new float[][]

          {

              { 0.03f, 0.12f }

          };

        cornerIndexes = new int[] { 0,0,0,0,0,0 };

        centers = new float[][]

          {

              { 0.0f, 0.0f, 0.0f }

          };

        centerIndexes = new int[] { 0,0,0,0,0,0 };

        numComponents = 8;

        }

      ///// KILOMINX EDGE ////////////////////////////////////////////////////////////////////////

      else if( mode==4 )

        {

        double SQ5  = Math.sqrt(5);

        double SIN18= (SQ5-1)/4;

        double COS18= 0.25*Math.sqrt(10.0+2.0*SQ5);

        double H = 1.0;

        double L = 2.0;

        double X = H*Math.sqrt((5+SQ5)/10);

        double Y = H*Math.sqrt((5-SQ5)/10);

        double D = H*SIN18/COS18;

        vertices = new double[][]

          {

              { 0.0,   Y, L/2},

              {   X, 0.0, L/2},

              { 0.0,  -Y, L/2},

              {  -X, 0.0, L/2},

              { 0.0,  Y, -L/2 +D},

              {   X, 0.0,-L/2   },

              { 0.0, -Y, -L/2-D },

              {  -X, 0.0,-L/2   }

          };

        vertIndexes = new int[][]

          {

              {3,2,1,0},   // counterclockwise!

              {0,1,5,4},

              {3,0,4,7},

              {2,1,5,6},

              {3,2,6,7},

              {4,5,6,7}

          };

        bands = new float[][]

          {

             {0.04f,13,(float)(L/3),(float)L/8, 5,2,3},

             {0.00f, 0,(float)(L/2),(float)L/4, 5,2,3}

          };

        bandIndexes = new int[] { 1,0,0,1,1,1 };

        corners = new float[][]

          {

              { 0.04f, 0.12f }

          };

        cornerIndexes = new int[] { 0,-1,-1,-1,0,-1,-1,-1 };

        centers = new float[][]

          {

              { 0.0f, 0.0f, 0.0f }

          };

        centerIndexes = new int[] { 0,-1,-1,-1,0,-1,-1,-1 };

        numComponents = 6;

        }

      ///// IVY_CORNER ////////////////////////////////////////////////////////////////////////

      else if( mode==5 )

        {

        int IVY_N = 3;

        final float IVY_D = 0.003f;

        final double angle = Math.PI/(2*IVY_N);

        final double CORR  = 1.0 - 2*IVY_D;

        vertices = new double[3*IVY_N+7][3];

        vertIndexes = new int[6][IVY_N+4];

        vertices[0][0] = 0.0;

        vertices[0][1] = 0.0;

        vertices[0][2] = 0.0;

        vertices[1][0] =-1.0;

        vertices[1][1] = 0.0;

        vertices[1][2] = 0.0;

        vertices[2][0] = 0.0;

        vertices[2][1] =-1.0;

        vertices[2][2] = 0.0;

        vertices[3][0] = 0.0;

        vertices[3][1] = 0.0;

        vertices[3][2] =-1.0;

        vertIndexes[0][0] = 2;

        vertIndexes[0][1] = 0;

        vertIndexes[0][2] = 1;

        vertIndexes[3][0] = 2;

        vertIndexes[3][1] = 0;

        vertIndexes[3][2] = 1;

        vertIndexes[1][0] = 3;

        vertIndexes[1][1] = 0;

        vertIndexes[1][2] = 2;

        vertIndexes[4][0] = 3;

        vertIndexes[4][1] = 0;

        vertIndexes[4][2] = 2;

        vertIndexes[2][0] = 1;

        vertIndexes[2][1] = 0;

        vertIndexes[2][2] = 3;

        vertIndexes[5][0] = 1;

        vertIndexes[5][1] = 0;

        vertIndexes[5][2] = 3;

        int N1 = 4;

        int N2 = N1 + IVY_N + 1;

        int N3 = N2 + IVY_N + 1;

        for(int i=0; i<=IVY_N; i++)

          {

          double cos1 = Math.cos((IVY_N-i)*angle);

          double sin1 = Math.sin((IVY_N-i)*angle);

          double cos2 = Math.cos((      i)*angle);

          double sin2 = Math.sin((      i)*angle);

          vertices[N1+i][0] = CORR*(cos1-0.5) - 0.5;

          vertices[N1+i][1] = CORR*(sin1-0.5) - 0.5;

          vertices[N1+i][2] = 0.0;

          vertices[N2+i][0] = 0.0;

          vertices[N2+i][1] = CORR*(sin2-0.5) - 0.5;

          vertices[N2+i][2] = CORR*(cos2-0.5) - 0.5;

          vertices[N3+i][0] = CORR*(cos2-0.5) - 0.5;

          vertices[N3+i][1] = 0.0;

          vertices[N3+i][2] = CORR*(sin2-0.5) - 0.5;

          vertIndexes[0][i+3] = N1 + i;

          vertIndexes[1][i+3] = N2 + i;

          vertIndexes[2][i+3] = N3 + i;

          vertIndexes[3][i+3] = N1 + i;

          vertIndexes[4][i+3] = N2 + i;

          vertIndexes[5][i+3] = N3 + i;

          }

        bands = new float[][]

          {

             {+0.012f,20,0.2f,0.5f,7,1,2},

             {-0.100f,20,0.2f,0.0f,2,1,2}

          };

        bandIndexes = new int[] { 0,0,0,1,1,1 };

        corners = new float[][]

          {

              { 0.04f, 0.12f }

          };

        cornerIndexes = new int[3*IVY_N+7];

        centers = new float[][]

          {

              {-0.5f,-0.5f,-0.5f}

          };

        centerIndexes = new int[3*IVY_N+7];

        for(int i=0; i<4; i++)

          {

          cornerIndexes[i] = 0;

          centerIndexes[i] = 0;

          }

        for(int i=4; i<3*IVY_N+7; i++)

          {

          cornerIndexes[i] = -1;

          centerIndexes[i] = -1;

          }

        numComponents = 6;

        }

      ///// IVY_FACE ////////////////////////////////////////////////////////////////////////

      else if( mode==6 )

        {

        int IVY_N = 6;

        final float IVY_D = 0.003f;

        final double angle = Math.PI/(2*IVY_N);

        final double CORR  = 1.0 - 2*IVY_D;

        vertices   = new double[2*IVY_N][3];

        vertIndexes= new int[2][2*IVY_N];

        for(int i=0; i<IVY_N; i++)

          {

          double cos = Math.cos(i*angle);

          double sin = Math.sin(i*angle);

          vertices[i      ][0] = CORR*(0.5-cos);

          vertices[i      ][1] = CORR*(0.5-sin);

          vertices[i      ][2] = 0.0;

          vertices[i+IVY_N][0] = CORR*(cos-0.5);

          vertices[i+IVY_N][1] = CORR*(sin-0.5);

          vertices[i+IVY_N][2] = 0.0;

          vertIndexes[0][i      ] = i;

          vertIndexes[0][i+IVY_N] = i+IVY_N;

          vertIndexes[1][i      ] = i;

          vertIndexes[1][i+IVY_N] = i+IVY_N;

          }

        bands = new float[][]

          {

             {+0.012f,20,0.2f,0.5f,7,1,2},

             {-0.100f,20,0.2f,0.0f,2,1,2},

          };

        bandIndexes = new int[] { 0,1 };

        corners = new float[][]

          {

             {0.03f,0.10f}

          };

        centers = new float[][]

          {

              {-0.0f,-0.0f,-0.5f}

          };

        cornerIndexes = new int[2*IVY_N];

        centerIndexes = new int[2*IVY_N];

        for(int i=0; i<2*IVY_N; i++)

          {

          cornerIndexes[i] = -1;

          centerIndexes[i] = -1;

          }

        cornerIndexes[0    ] = 0;

        cornerIndexes[IVY_N] = 0;

        centerIndexes[0    ] = 0;

        centerIndexes[IVY_N] = 0;

        numComponents = 2;

        }

      ///// SKEWB Ultimate SMALL  /////////////////////////////////////////////////////////////

      else if( mode==7 )

        {

        double S = (SQ5+1)/4;

        vertices = new double[][]

          {

              { 0.0       ,  0.0      , 0.0       },

              { -0.5*S    , 0.5*S+0.25, -0.25     },

              {-0.25      , -S/2      , (-2*S-1)/4},

              { 0.5*S+0.25, 0.25      , -S/2      },

              { 0.0       , 0.5       , -S-0.5    },

              { 0.0       , 0.5       , 0.0       },

              { -0.5*S    ,-0.5*S+0.25, -0.25     },

              {  0.5*S    ,-0.5*S+0.25, -0.25     }

          };

        vertIndexes = new int[][]

          {

              {6,0,5,1},   // counterclockwise!

              {0,7,3,5},

              {0,6,2,7},

              {4,3,5,1},

              {4,2,7,3},

              {4,1,6,2},

          };

        bands = new float[][]

          {

             {0.04f,17,0.5f,0.2f,5,  2,2},

             {0.01f, 1,0.5f,0.2f,5,  2,2}

          };

        bandIndexes = new int[] { 0,0,0,1,1,1 };

        corners = new float[][]

          {

              { 0.013f, 0.08f }

          };

        cornerIndexes = new int[] { 0, 0, 0, 0,-1,0,0,0 };

        centers = new float[][]

          {

              { 0.0f,-0.5f, (float)(-S-0.5) }

          };

        centerIndexes = new int[] { 0,0,0,0,0,0,0,0 };

        numComponents = 8;

        }

      ///// SKEWB Ultimate BIG ///////////////////////////////////////////////////////////////

      else if( mode==8 )

        {

        double S = (SQ5+1)/4;

        vertices = new double[][]

          {

              {-S/2     ,-S/2+0.25,     0.25},

              { S/2     , S/2-0.25,    -0.25},

              {-S       ,     0.00,     0.00},

              {     0.25, S/2     ,-S/2-0.25},

              {-S/2     ,-S/2-0.25,     0.25},

              { S/2+0.25,    -0.25,-S/2     },

              {-S       ,    -0.50,     0.00},