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.MeshBandedTriangle;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshFile;

import org.distorted.library.mesh.MeshMultigon;

import org.distorted.library.mesh.MeshPolygon;

import org.distorted.library.type.DynamicQuat;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.FactoryCubit;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectShape;

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.MULTIGON;

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

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

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

import static org.distorted.objectlib.main.TwistyObject.MESH_NICE;

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

class MeshFileRenderer implements GLSurfaceView.Renderer, DistortedLibrary.LibraryUser

{

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

    private final float DEFAULT_SCALE = 0.3f;

    private final GLSurfaceView mView;

    private final Resources mResources;

    private final DistortedScreen mScreen;

    private final DistortedEffects mEffects;

    private final Static3D mScale;

    private DistortedTexture mTexture;

    private MeshBase mMesh;

    private long mTime;

    private float mCurrentScale;

    private boolean mNormals;

    Static4D mQuat1, mQuat2;

    int mScreenMin;

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

    MeshFileRenderer(GLSurfaceView v)

      {

      mView = v;

      mResources = v.getResources();

      mScreen = new DistortedScreen();

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

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

      mCurrentScale = DEFAULT_SCALE;

      mNormals = false;

      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(this);

      }

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

//   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 flipNormals()

      {

      mNormals = !mNormals;

      if( mMesh!=null ) mMesh.setShowNormals(mNormals);

      }

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

    void open(int resourceID)

      {

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

      mTexture.setTexture( createTexture(resourceID) );

      long t1 = System.currentTimeMillis();

      if( resourceID==PROCEDURAL )

        {

        createMesh();

        }

      else if( resourceID==POLYGON )

        {

        createPolygon();

        }

      else if( resourceID==MULTIGON )

        {

        createMultigon();

        }

      else if( resourceID==TRIANGLE )

        {

        createTriangle();

        }

      else

        {

        openMesh(resourceID);

        }

      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;

      if( resourceID == R.raw.deferredjob || resourceID == R.raw.meshjoin    ||

          resourceID == PROCEDURAL        || resourceID == POLYGON           ||

          resourceID == MULTIGON          || resourceID == TRIANGLE          ||

          resourceID == R.raw.predeform    ) return createWhiteTexture();

      if( resourceID == R.raw.cube2       ||

          resourceID == R.raw.cube3       ||

          resourceID == R.raw.cube4       ||

          resourceID == 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);

        }

      if( resourceID == R.raw.pyra3       ||

          resourceID == R.raw.pyra4       ||

          resourceID == 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);

        }

      if( resourceID == 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);

        }

      if( resourceID == R.raw.skewb )

        {

        colors = new int[] { 0xffffff00, 0xffffffff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffb5651d };

        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 createTriangle()

      {

      float[] vL = {-1.0f, -0.5f};

      float[] vR = { 1.0f, -0.5f};

      float[] vT = { 0.0f,  1.0f};

      float C = 2f;

      float[] bands = { 1.0f, 0.00f*C, /*0.9f, 0.05f*C,*/ 0.8f, 0.06f*C, 0.5f, 0.09f*C, 0.0f, 0.10f*C};

      float[] normL = { vL[0]-vT[0], vL[1]-vT[1] };

      float[] normR = { vR[0]-vT[0], vR[1]-vT[1] };

      int mode = MeshBandedTriangle.MODE_NORMAL;

      int extraBands    = 2;

      int extraVertices = 1;

      mMesh = new MeshBandedTriangle(vL,vR,vT,bands,normL,normR,mode,extraBands,extraVertices);

      mMesh.setEffectAssociation(0,0,0);

      }

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

    private void createPolygon()

      {

      float A = 0.5f;

      float B = 0.04f;

      int extraIndex    = 0;

      int extraVertices = 0;

      float[][] vertices = { {-A,-A}, {A,-A}, {A,A}, {-A,A} };

      float C = 2f;

      float[] bands = { 1.0f, 0.00f*C, 0.9f, 0.04f*C,  0.8f, 0.07f*C, 0.5f, 0.09f*C, 0.0f, 0.10f*C};

/*

      int numBands      = 5;

      float[] bands = new float[2*numBands];

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

        {

        bands[2*i  ] = 1 + i/(1.0f-numBands);

        bands[2*i+1] = B/(numBands-1)*i;

        }

*/

      mMesh = new MeshPolygon(vertices,bands,extraIndex,extraVertices,0.0f,0.0f);

      mMesh.setEffectAssociation(0,0,0);

      }

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

    private float[][] gen(float x, float y)

      {

      return new float[][] { {x+0.1f,y-0.1f} , {x-0.1f,y-0.1f} , {x-0.1f,y+0.1f} , {x+0.1f,y+0.1f} };

      }

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

    private void createMultigon()

      {

      float A = 0.5f;

      int extraIndex    = 0;

      int extraVertices = 0;

      float[][][] vertices = new float[19][][];

      vertices[ 0] = gen( 0.4f,-0.4f);

      vertices[ 1] = gen( 0.2f,-0.4f);

      vertices[ 2] = gen( 0.0f,-0.4f);

      vertices[ 3] = gen(-0.2f,-0.4f);

      vertices[ 4] = gen(-0.4f,-0.4f);

      vertices[ 5] = gen(-0.4f,-0.2f);

      vertices[ 6] = gen(-0.4f, 0.0f);

      vertices[ 7] = gen(-0.4f, 0.2f);

      vertices[ 8] = gen(-0.4f, 0.4f);

      vertices[ 9] = gen(-0.2f, 0.4f);

      vertices[10] = gen( 0.0f, 0.4f);

      vertices[11] = gen( 0.2f, 0.4f);

      vertices[12] = gen( 0.4f, 0.4f);

      vertices[13] = gen( 0.4f, 0.2f);

      vertices[14] = gen( 0.4f, 0.0f);

      vertices[15] = gen( 0.4f,-0.2f);

      vertices[16] = gen( 0.0f,-0.2f);

      vertices[17] = gen( 0.0f, 0.0f);

      vertices[18] = gen( 0.0f, 0.2f);

      float C = 0.5f;

      float[] bands = new float[] { 1.0f, 0.00f*C, 0.9f, 0.04f*C,  0.8f, 0.07f*C, 0.5f, 0.09f*C, 0.0f, 0.10f*C};

/*

      float B = 0.1f;

      int numBands = 7;

      float[] bands = new float[2*numBands];

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

        {

        bands[2*i  ] = 1 + i/(1.0f-numBands);

        bands[2*i+1] = B/(numBands-1)*i;

        }

*/

      mMesh = new MeshMultigon(vertices,bands,extraIndex,extraVertices);

      int numEff = mMesh.getNumEffComponents();

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

        {

        mMesh.setEffectAssociation(i, 0, i);

        }

      }

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

    private float[][] createV()

      {

      return new float[][]

              {

                      {-0.5f ,  1.5f , -0.5f },  //0

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

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

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

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

                      {-0.5f , -0.5f ,  0.5f },  //5

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

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

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

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

                      { 1.5f , -1.5f ,  0.5f },  //10

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

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

                      { 1.5f ,  0.5f ,  0.5f },

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

                      { 1.5f ,  1.5f ,  0.5f },  //15

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

                      {-2.5f ,  1.5f , -0.5f },

                      {-2.5f ,  1.5f ,  0.5f },

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

                      {-2.5f ,  0.5f , -0.5f },  //20

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

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

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

                      {-2.5f , -1.5f , -0.5f },

                      {-2.5f , -1.5f ,  0.5f },  //25

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

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

                      { 0.5f ,  1.5f ,  0.5f },

                      { 0.5f ,  0.5f ,  0.5f },

                      { 0.5f ,  0.5f , -0.5f },  //30

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

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

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

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

                      { 0.5f , -1.5f , -0.5f },  //35

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

                      { 2.5f , -1.5f ,  0.5f },

                      { 2.5f , -1.5f , -0.5f },

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

                      { 2.5f ,  0.5f ,  0.5f },  //40

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

                      { 2.5f ,  1.5f ,  0.5f },

                      { 2.5f ,  1.5f , -0.5f },

                      { 2.5f ,  2.5f ,  0.5f },

                      { 2.5f ,  2.5f , -0.5f },  //45

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

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

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

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

                      {-1.5f ,  0.5f , -0.5f },  //50

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

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

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

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

                      {-1.5f , -1.5f , -0.5f },  //55

                      {-1.5f , -2.5f , -0.5f },

                      {-1.5f , -2.5f ,  0.5f },

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

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

                      { 0.5f , -2.5f , -0.5f },  //60

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

                      { 1.5f , -2.5f , -0.5f },

                      { 1.5f , -2.5f ,  0.5f },

                      { 1.5f ,  2.5f , -0.5f },

                      { 1.5f ,  2.5f ,  0.5f },  //65

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

                      { 0.5f ,  2.5f ,  0.5f },

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

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

                      {-1.5f ,  2.5f , -0.5f },  //70

                      {-1.5f ,  2.5f ,  0.5f },

              };

      }

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

    private int[][][] createVI()

      {

      return new int[][][]

              {

                    //  { {  0, 1, 2, 3 } , {  1, 4, 5, 2 } , {  4, 6, 7, 5 } },

                    //  { {  8, 9,10,11 } , { 12, 8,11,13 } , { 14,12,13,15 } },

                    //  { { 16,17,18,19 } , { 17,20,21,18 } , { 20,22,23,21 } , { 22,24,25,23 } , { 24,26,27,25 } },

                    //  { { 28,29,30,31 } , { 29,32,33,30 } , { 32,34,35,33 } },

                    //  { { 36,37,38,39 } , { 40,36,39,41 } , { 42,40,41,43 } , { 44,42,43,45 } , { 37,46,47,38 } },

                    //  { { 48,49,50,51 } , { 49,52,53,50 } , { 52,54,55,53 } },

                    //  { { 28,31,14,15 } },

                    //  { { 48,51, 0, 3 } },

                    //  { { 27,26,56,57 } , { 57,56,58,59 } , { 59,58,60,61 } , { 61,60,62,63 } , { 63,62,47,46 } },

                    //  { { 64,65,44,45 } , { 66,67,65,64 } , { 68,69,67,66 } , { 70,71,69,68 } , { 16,19,71,70 } },

                    //  { { 55,54, 7, 6 } },

                    //  { { 35,34,10, 9 } },

                      { { 31,30, 1, 0 } , { 30,33, 4, 1 } , { 33,35, 6, 4 } , { 35,60,58, 6 } , {  6,58,56,55 } , { 55,56,26,24 } , { 53,55,24,22 } , { 50,53,22,20 } , { 51,50,20,17 } , { 70,51,17,16 } , { 68, 0,51,70 } , { 66,31, 0,68 } , { 64,14,31,66 } , { 45,43,14,64 } , { 43,41,12,14 } , { 41,39, 8,12 } , { 39,38, 9, 8 } , { 38,47,62, 9 } , {  9,62,60,35 } },

                      { {  3, 2,29,28 } , {  2, 5,32,29 } , {  5, 7,34,32 } , {  7,59,61,34 } , { 54,57,59, 7 } , { 25,27,57,54 } , { 23,25,54,52 } , { 21,23,52,49 } , { 18,21,49,48 } , { 19,18,48,71 } , { 71,48, 3,69 } , { 69, 3,28,67 } , { 67,28,15,65 } , { 65,15,42,44 } , { 15,13,40,42 } , { 13,11,36,40 } , { 11,10,37,36 } , { 10,63,46,37 } , { 34,61,63,10 } },

              };

      }

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

    private void createMesh()

      {

      float[][] vertices = createV();

      int[][][] vertIndices = createVI();

      int numFaces = vertIndices.length;

      float h = 0.001f;

      int angle = 30;

      float R = 0.1f;

      float S = 0.5f;

      int N   = 6;

      int exI = 0;

      int exV = 0;

      float[][] bands  = { {h,angle,R,S,N,exI,exV} };

      int[] bandIndices= new int[numFaces];

      ObjectShape shape = new ObjectShape(vertices, vertIndices);

      ObjectFaceShape face = new ObjectFaceShape(bands, bandIndices, null);

      int[] outer = new int[numFaces];

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.clear();

      factory.createNewFaceTransform(shape,outer);

      mMesh = factory.createRoundedSolid(shape,face,null,MESH_NICE,numFaces);

      int numEff = mMesh.getNumEffComponents();

      for(int i=0; i<numEff; i++) mMesh.setEffectAssociation(i, 0, i);

      }

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

    private void openMesh(int resourceID)

      {

      Context con = mView.getContext();

      Resources res = con.getResources();

      InputStream is = res.openRawResource(resourceID);

      DataInputStream dos = new DataInputStream(is);

      mMesh = new MeshFile(dos);

      int numEff = mMesh.getNumEffComponents();

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

        {

        mMesh.setEffectAssociation(i, 0, i);

        }

      try

        {

        is.close();

        }

      catch(IOException e)

        {

        android.util.Log.e("MeshFile", "Error closing InputStream: "+e.toString());

        }

      }

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

    MeshBase getMesh()

      {

      return mMesh;

      }

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

    long getTime()

      {

      return mTime;

      }

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

    int getBytes()

      {

      if( mMesh instanceof MeshFile )

        {

        return ((MeshFile)mMesh).getNumBytes();

        }

      return 0;

      }

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

    int getVertices()

      {

      return mMesh.getNumVertices();

      }

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

    int getEndEffIndex(int component)

      {

      return mMesh.getLastVertexEff(component);

      }

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

    int getEndTexIndex(int component)

      {

      return mMesh.getLastVertexTex(component);

      }

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

    int getEffComponentNum()

      {

      return mMesh.getNumEffComponents();

      }

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

    int getTexComponentNum()

      {

      return mMesh.getNumTexComponents();

      }

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

    public void distortedException(Exception ex)

      {

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

      }

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

    public InputStream localFile(int fileID)

      {

      return mResources.openRawResource(fileID);

      }

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

    public void logMessage(String message)

      {

      android.util.Log.e("MeshFile", message );

      }

}