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.res.Resources;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.opengl.GLSurfaceView;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectShape;

import java.io.IOException;

import java.io.InputStream;

import javax.microedition.khronos.opengles.GL10;

    private final DistortedEffects mEffects;

    private final Static3D mScale;

    private DistortedTexture mTexture;

    private MeshBase mMesh;

    Static4D mQuat1, mQuat2;

    int mScreenMin;

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

    MeshFileRenderer(GLSurfaceView v)

      {

      mView = v;

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

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

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

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

      quatInt1.add(mQuat1);

      quatInt2.add(mQuat2);

      disappear.setMeshAssociation(1,-1);

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

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

      mEffects.apply( new MatrixEffectScale(mScale));

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

    public void onDrawFrame(GL10 glUnused) 

      {

      mScreen.render( System.currentTimeMillis() );

      }

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

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

      {

      mScreenMin = Math.min(width, height);

      mScreen.resize(width, height);

      }

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

    public void onSurfaceCreated(GL10 glUnused, EGLConfig config) 

      {

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

//   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);

      }

        }

      else if( resourceID==POLYGON )

        {

        createPolygon();

        {

        createMultigon();

        }

        {

        createTriangle();

        }

        {

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

      float[] vertices;

      int[] colors;

      float F = 0.5f;

      float E = SQ3/2;

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

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

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

        }

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

      Canvas canvas = new Canvas(bitmap);

      Paint paint = new Paint();

    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;

      int extraVertices = 0;

/*

      int numBands      = 5;

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

        {

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

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

        }

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

    private void createMultigon()

      {

      float A = 0.5f;

      int extraVertices = 0;

      float[] v2 = new float[] { -1,0, -0.5f, -SQ3/2, 0,0 };

      float[] v3 = new float[] {  0,0, -0.5f, -SQ3/2, 0.5f, -SQ3/2 };

      float[][] vertices = new float[][] {v1,v2,v3};

/*

      float[] v4 = new float[] {  -A, A,   A, A,   A,3*A,   -A,3*A };

      float[] v5 = new float[] {-3*A, A,  -A, A,  -A,3*A, -3*A,3*A };

      float[][] vertices = new float[][] {v1,v2,v3,v4,v5};

      float[] c2 = new float[] { 1.5f*A,0 };

      float[] c4 = new float[] { 0,1.5f*A };

      float[] c5 = new float[] { -1.5f*A,1.5f*A };

      float[][] centers = new float[][] { c1,c2,c3,c4,c5 };

*/

      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;

      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 void createMesh()

      {

          {

              { 0.5f, 0.5f, 0.5f },

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

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

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

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

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

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

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

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

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

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

              {   -A, 0.5f, 0.5f },

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

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

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

      int[][][] vertIndices =

          {

              { {15,14,12,13} },

              { {11,10, 6, 7} },

              { {12, 0, 1,13} },

              { {11, 9, 8,10} },

              { {15, 7, 6,14} },

              { {14, 6, 4,12}, { 6, 2, 0, 4}, {10, 8, 2, 6} },

              { { 3, 7, 5, 1}, { 9,11, 7, 3}, { 7,15,13, 5} }

      int extraI = 1;

      int extraV = 1;

      float[][] corners= { {0.036f,0.12f} };

      float[][] centers= { {0.0f, 0.0f, 0.0f} };

      float[][] vertices = { {-1.5f, 0.0f, 0.0f},{ 1.5f, 0.0f, 0.0f},{ 0.0f,-1.5f, 0.0f},{ 0.0f, 0.0f,-1.5f},{0,0,0} };

      int[][][] vertIndices = { {{2,1,4},{4,0,2}},{{3,0,4},{4,1,3}},{{2,3,1}},{{3,2,0}} };

      float h1 = 0.035f;

      float h2 = 0.010f;

      int angle = 30;

      int N   = 6;

      int exV = 0;

      int[] bandIndices= { 0,0,1,1 };

      float[] convex = null;

      float[][] corners   = { {0.07f,0.40f}, {0.05f,0.30f} };

      int[] cornerIndices = { 0,0,1,1,-1 };

      float[][] centers   = { {0.0f, -0.75f, -0.75f} };

      int[] centerIndices = { 0,0,0,0,-1 };

      ObjectShape shape = new ObjectShape(vertices, vertIndices);

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

      int numFaces = shape.getNumFaces();

      int[] outer = new int[numFaces];

      int numEff = mMesh.getNumEffComponents();

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

      Resources res = con.getResources();

      InputStream is = res.openRawResource(resourceID);

      DataInputStream dos = new DataInputStream(is);

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

        {

        mMesh.setEffectAssociation(i, 0, i);

        }

        {

        is.close();

        }

      catch(IOException e)

        {

      return mMesh;

      }

    long getTime()

      {

      return mTime;

      }

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

    int getBytes()

      {

        {

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

        }

      return 0;

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

    int getVertices()

      {

      }

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

    int getEndEffIndex(int component)

      {

      return mMesh.getLastVertexEff(component);

      }

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

    int getEndTexIndex(int component)

      {

      return mMesh.getLastVertexTex(component);

      }

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

    int getEffComponentNum()

      {

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

    int getTexComponentNum()

      {

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

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

      }