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

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffectDeform;

import org.distorted.library.effect.VertexEffectDisappear;

import org.distorted.library.effect.VertexEffectRotate;

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.mesh.MeshPolygon;

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 final float DEFAULT_SCALE = 0.3f;

    private GLSurfaceView mView;

    private DistortedTexture mTexture;

    private DistortedScreen mScreen;

    private DistortedEffects mEffects;

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

      VertexEffectDisappear.enable();

      VertexEffectRotate.enable();

      VertexEffectDeform.enable();

      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 MeshBase createStaticMesh()

    {

    /*

    MeshBase triangle = new MeshTriangle(5);

    VertexEffectMove move = new VertexEffectMove( new Static3D(1,0,0) );

    triangle.apply(move);

    triangle.mergeEffComponents();

    VertexEffectScale scale = new VertexEffectScale( new Static3D(2,1,1) );

    triangle.apply(scale);

    return triangle;

     */

/*

    final float DIST  = 0.2f;

    float[] vertices = new float[6];

    vertices[0] =  0.5f-DIST;

    vertices[1] = -0.5f-DIST;

    vertices[2] =  0.5f-DIST;

    vertices[3] =  0.5f-DIST;

    vertices[4] = -0.5f-DIST;

    vertices[5] =  0.5f-DIST;

    float[] bands0 = new float[] {1.0f, 0.0f, 0.5f, 0.03f, 0.0f, 0.05f};

    MeshBase mesh = new MeshPolygon(vertices,bands0,0,0);

    mesh.setShowNormals(true);

    return mesh;

    */

    final float IVY_D = 0.10f;

    final int   IVY_N = 8;

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

    final float CORR  = 1.0f - IVY_D*SQ2;

    final float DIST  = 0.4f;

    final float CORR2 = 0.5f;

    float[] vertices = new float[2*(IVY_N+1)+6];

    vertices[0] = ( 0.5f      -DIST)*CORR2;

    vertices[1] = (-0.5f+IVY_D-DIST)*CORR2;

    vertices[2] = ( 0.5f      -DIST)*CORR2;

    vertices[3] = ( 0.5f      -DIST)*CORR2;

    vertices[4] = (-0.5f+IVY_D-DIST)*CORR2;

    vertices[5] = ( 0.5f      -DIST)*CORR2;

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

      {

      float ang = (IVY_N-i)*angle;

      float sin = (float)Math.sin(ang);

      float cos = (float)Math.cos(ang);

      vertices[2*i+6] = (CORR*(cos-0.5f)-DIST)*CORR2;

      vertices[2*i+7] = (CORR*(sin-0.5f)-DIST)*CORR2;

      }

    float[] bands = new float[] {1.0f, 0.0f, 0.5f, 0.03f, 0.0f, 0.05f};

    MeshBase mesh = new MeshPolygon(vertices,bands,0,0);

    mesh.setShowNormals(true);

    return mesh;

    }

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

    private void createMesh()

      {

      FactoryCubit factory = FactoryCubit.getInstance();

      mMesh = factory.createMegaminxCornerMesh();

      //mMesh = createStaticMesh();

      int numEff = mMesh.numEffComponents();

      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.numEffComponents();

      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.numEffComponents();

      }

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

    int getTexComponentNum()

      {

      return mMesh.numTexComponents();

      }

}