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

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.effect.VertexEffectScale;

import org.distorted.library.effect.VertexEffectSink;

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

import org.distorted.library.mesh.MeshPolygon;

import org.distorted.library.mesh.MeshTriangle;

import org.distorted.library.type.DynamicQuat;

import org.distorted.library.type.Static1D;

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 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.25189602f,0.3546389f,0.009657208f,0.90038127f);

      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.setMax(EffectType.VERTEX, 14);

      DistortedLibrary.onCreate(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)

      {

      switch(resourceID)

          {

          case  R.raw.deferredjob:

          case  R.raw.meshjoin   : final int[] TET_COLORS4 = new int[] { 0xffffff00,

                                                                         0xff00ff00,

                                                                         0xff0000ff,

                                                                         0xffff0000 };

                                   return createTetrahedronTexture(TET_COLORS4);

          case  PROCEDURAL       :

          case  R.raw.predeform  : return createGridTexture(3);

          case  R.raw.cube2      :

          case  R.raw.cube3      :

          case  R.raw.cube4      :

          case  R.raw.cube5      : final int[] CUBE_COLORS = new int[] { 0xffffff00,

                                                                         0xffffffff,

                                                                         0xff0000ff,

                                                                         0xff00ff00,

                                                                         0xffff0000,

                                                                         0xffb5651d };

                                   return createCubeTexture(CUBE_COLORS);

          case  R.raw.pyra3      :

          case  R.raw.pyra4      :

          case  R.raw.pyra5      : final int[] TET_COLORS5 = new int[] { 0xffffff00,

                                                                         0xff00ff00,

                                                                         0xff0000ff,

                                                                         0xffff0000,

                                                                         0xff000000 };

                                   return createTetrahedronTexture(TET_COLORS5);

          case  R.raw.dino       : final int[] TET_COLORS7 = new int[] { 0xffffff00,

                                                                         0xffffffff,

                                                                         0xff0000ff,

                                                                         0xff00ff00,

                                                                         0xffff0000,

                                                                         0xffb5651d,

                                                                         0xff000000 };

                                   return createTetrahedronTexture(TET_COLORS7);

          case R.raw.skewb       : final int[] SKEW_COLORS = new int[] { 0xffffff00,

                                                                         0xffffffff,

                                                                         0xff0000ff,

                                                                         0xff00ff00,

                                                                         0xffff0000,

                                                                         0xffb5651d };

                                   return createSkewbTexture(SKEW_COLORS);

          }

      return null;

      }

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

    private Bitmap createCubeTexture(int[] faceColors)

      {

      final int FACES=faceColors.length;

      int SIZE = 200;

      final float R = SIZE*0.10f;

      final float M = SIZE*0.05f;

      Bitmap bitmap;

      Paint paint = new Paint();

      bitmap = Bitmap.createBitmap( (FACES+1)*SIZE, SIZE, Bitmap.Config.ARGB_8888);

      Canvas canvas = new Canvas(bitmap);

      paint.setStyle(Paint.Style.FILL);

      paint.setColor(0xff000000);

      canvas.drawRect(0, 0, (FACES+1)*SIZE, SIZE, paint);

      for(int face=0; face<FACES; face++)

        {

        paint.setColor(faceColors[face]);

        canvas.drawRoundRect( face*SIZE+M, M, (face+1)*SIZE-M, SIZE-M, R, R, paint);

        }

      return bitmap;

      }

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

    private Bitmap createGridTexture(int lines)

      {

      int SIZE = 200;

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

      Canvas canvas = new Canvas(bitmap);

      Paint paint = new Paint();

      paint.setColor(0xff008800);

      paint.setStyle(Paint.Style.FILL);

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

      paint.setColor(0xffffffff);

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

        {

        int x = (SIZE*i)/lines;

        canvas.drawRect(x-1,   0,  x+1, SIZE, paint);

        canvas.drawRect(  0, x-1, SIZE,  x+1, paint);

        }

      return bitmap;

      }

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

    private Bitmap createTetrahedronTexture(int[] faceColors)

      {

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

      final int FACES=faceColors.length;

      int SIZE = 256;

      float STROKE = 0.05f*SIZE;

      float OFF = STROKE/2 -1;

      float OFF2 = 0.5f*SIZE + OFF;

      float HEIGHT = SIZE - OFF;

      float RADIUS = SIZE/12.0f;

      float ARC1_H = 0.2f*SIZE;

      float ARC1_W = SIZE*0.5f;

      float ARC2_W = 0.153f*SIZE;

      float ARC2_H = 0.905f*SIZE;

      float ARC3_W = SIZE-ARC2_W;

      float M = SQ3/2;

      float D = (M/2 - 0.51f)*SIZE;

      Bitmap result = Bitmap.createBitmap(FACES*SIZE,SIZE, Bitmap.Config.ARGB_8888);

      Canvas canvas = new Canvas(result);

      Paint paint = new Paint();

      paint.setAntiAlias(true);

      paint.setStrokeWidth(STROKE);

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

        {

        paint.setColor(faceColors[i]);

        paint.setStyle(Paint.Style.FILL);

        canvas.drawRect(i*SIZE,0,(i+1)*SIZE,SIZE,paint);

        paint.setColor(0xff000000);

        paint.setStyle(Paint.Style.STROKE);

        canvas.drawLine(           i*SIZE, M*HEIGHT+D,  SIZE       +i*SIZE, M*HEIGHT+D, paint);

        canvas.drawLine(      OFF +i*SIZE, M*SIZE  +D,       OFF2  +i*SIZE,          D, paint);

        canvas.drawLine((SIZE-OFF)+i*SIZE, M*SIZE  +D, (SIZE-OFF2) +i*SIZE,          D, paint);

        canvas.drawArc( ARC1_W-RADIUS+i*SIZE, M*(ARC1_H-RADIUS)+D, ARC1_W+RADIUS+i*SIZE, M*(ARC1_H+RADIUS)+D, 225, 90, false, paint);

        canvas.drawArc( ARC2_W-RADIUS+i*SIZE, M*(ARC2_H-RADIUS)+D, ARC2_W+RADIUS+i*SIZE, M*(ARC2_H+RADIUS)+D, 105, 90, false, paint);

        canvas.drawArc( ARC3_W-RADIUS+i*SIZE, M*(ARC2_H-RADIUS)+D, ARC3_W+RADIUS+i*SIZE, M*(ARC2_H+RADIUS)+D, 345, 90, false, paint);

        }

      return result;

      }

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

  void createSkewbFaceTexture(Canvas canvas, Paint paint, int[] faceColors, int face, int left, int top, int side)

    {

    final int COLORS = 6;

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

    if( face<COLORS )

      {

      float STROKE = 0.035f*side;

      float L= left+0.125f*side;

      float H= 0.375f*side;

      float LEN = 0.5f*side;

      paint.setAntiAlias(true);

      paint.setStrokeWidth(STROKE);

      paint.setColor(faceColors[face]);

      paint.setStyle(Paint.Style.FILL);

      canvas.drawRect(left,top,left+side,top+side,paint);

      paint.setColor(0xff000000);

      paint.setStyle(Paint.Style.STROKE);

      canvas.drawLine( L    , H,  L+LEN, H    , paint);

      canvas.drawLine( L    , H,  L+LEN, H+LEN, paint);

      canvas.drawLine( L+LEN, H,  L+LEN, H+LEN, paint);

      float S1 = 0.125f*side;

      float S2 = 0.070f*side;

      float X  = 0.7f*S2;

      float LA = left+0.625f*side;

      float RA = left+0.125f*side;

      float TA = 0.375f*side;

      float BA = 0.875f*side;

      canvas.drawArc( LA-S1, TA     , LA     , TA+S1, 270, 90, false, paint);

      canvas.drawArc( RA+X , TA     , RA+X+S2, TA+S2, 135,135, false, paint);

      canvas.drawArc( LA-S2, BA-X-S2, LA     , BA-X ,   0,135, false, paint);

      }

    else

      {

      final float R = (SQ2/2)*side*0.10f;

      final float M = side*(0.5f-SQ2/4+0.018f);

      paint.setColor(faceColors[face-COLORS]);

      paint.setStyle(Paint.Style.FILL);

      canvas.drawRoundRect( left+M, top+M, left+side-M, top+side-M, R, R, paint);

      }

    }

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

    private Bitmap createSkewbTexture(int[] faceColors)

      {

      final int TEXTURE_HEIGHT = 256;

      final int NUM_TEXTURES = 2*6;

      Bitmap bitmap;

      Paint paint = new Paint();

      bitmap = Bitmap.createBitmap( (NUM_TEXTURES+1)*TEXTURE_HEIGHT, TEXTURE_HEIGHT, Bitmap.Config.ARGB_8888);

      Canvas canvas = new Canvas(bitmap);

      paint.setAntiAlias(true);

      paint.setTextAlign(Paint.Align.CENTER);

      paint.setStyle(Paint.Style.FILL);

      paint.setColor(0xff000000);

      canvas.drawRect(0, 0, (NUM_TEXTURES+1)*TEXTURE_HEIGHT, TEXTURE_HEIGHT, paint);

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

        {

        createSkewbFaceTexture(canvas, paint, faceColors, i, i*TEXTURE_HEIGHT, 0, TEXTURE_HEIGHT);

        }

      return bitmap;

      }

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

  private MeshBase createStaticMesh()

    {

    /*

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

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

    final float angleFaces = (float)((180/Math.PI)*(2*Math.asin(SQ3/3))); // angle between two faces of a tetrahedron

    final int MESHES=4;

    int association = 1;

    MeshBase[] meshes;

    float D = 0.0005f;

    float E = SQ3/2 - 3*D*SQ2;

    float F = 0.5f - D*SQ2*SQ3;

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

    float[] bands = new float[] {    1.0f    ,-D,

                                     1.0f  -D,-D*0.80f,

                                     1.0f-2*D,-D*0.65f,

                                     1.0f-4*D,+D*0.10f,

                                     0.50f, 0.035f,

                                     0.0f, 0.040f };

    meshes = new MeshPolygon[MESHES];

    meshes[0] = new MeshPolygon(vertices, bands, 2,2);

    meshes[0].setEffectAssociation(0,association,0);

    for(int i=1; i<MESHES; i++)

      {

      association <<= 1;

      meshes[i] = meshes[0].copy(true);

      meshes[i].setEffectAssociation(0,association,0);

      }

    MeshBase result = new MeshJoined(meshes);

    Static3D a0 = new Static3D(         0,        1,       0 );

    Static3D a1 = new Static3D(         0,  -1.0f/3, 2*SQ2/3 );

    Static3D a2 = new Static3D(-SQ2*SQ3/3,  -1.0f/3,  -SQ2/3 );

    Static3D a3 = new Static3D( SQ2*SQ3/3,  -1.0f/3,  -SQ2/3 );

    float tetraHeight = SQ2*SQ3/3;

    float d1 = (0.75f-2*SQ2*D)*tetraHeight;

    float d2 =-0.06f*tetraHeight;

    float d3 = 0.05f*tetraHeight;

    float d4 = 0.70f*tetraHeight;

    float d5 = 1.2f;

    Static3D dCen0 = new Static3D( d1*a0.get0(), d1*a0.get1(), d1*a0.get2() );

    Static3D dCen1 = new Static3D( d1*a1.get0(), d1*a1.get1(), d1*a1.get2() );

    Static3D dCen2 = new Static3D( d1*a2.get0(), d1*a2.get1(), d1*a2.get2() );

    Static3D dCen3 = new Static3D( d1*a3.get0(), d1*a3.get1(), d1*a3.get2() );

    Static3D dVec0 = new Static3D( d2*a0.get0(), d2*a0.get1(), d2*a0.get2() );

    Static3D dVec1 = new Static3D( d2*a1.get0(), d2*a1.get1(), d2*a1.get2() );

    Static3D dVec2 = new Static3D( d2*a2.get0(), d2*a2.get1(), d2*a2.get2() );

    Static3D dVec3 = new Static3D( d2*a3.get0(), d2*a3.get1(), d2*a3.get2() );

    Static4D dReg  = new Static4D(0,0,0,d3);

    Static1D dRad  = new Static1D(1);

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

    Static4D sReg  = new Static4D(0,0,0,d4);

    Static1D sink  = new Static1D(d5);

    Static1D angle  = new Static1D(angleFaces);

    Static3D axis1  = new Static3D(  -1, 0,      0);

    Static3D axis2  = new Static3D(0.5f, 0, -SQ3/2);

    Static3D axis3  = new Static3D(0.5f, 0, +SQ3/2);

    Static3D center1= new Static3D(0,-SQ3*SQ2/12,-SQ3/6);

    Static3D center2= new Static3D(0,-SQ3*SQ2/12,+SQ3/3);

    VertexEffectRotate  effect1 = new VertexEffectRotate( new Static1D(90), new Static3D(1,0,0), center );

    VertexEffectMove    effect2 = new VertexEffectMove  ( new Static3D(0,-SQ3*SQ2/12,0) );

    VertexEffectRotate  effect3 = new VertexEffectRotate( new Static1D(180), new Static3D(0,0,1), center1 );

    VertexEffectRotate  effect4 = new VertexEffectRotate( angle, axis1, center1 );

    VertexEffectRotate  effect5 = new VertexEffectRotate( angle, axis2, center2 );

    VertexEffectRotate  effect6 = new VertexEffectRotate( angle, axis3, center2 );

    VertexEffectDeform  effect7 = new VertexEffectDeform(dVec0, dRad, dCen0, dReg);

    VertexEffectDeform  effect8 = new VertexEffectDeform(dVec1, dRad, dCen1, dReg);

    VertexEffectDeform  effect9 = new VertexEffectDeform(dVec2, dRad, dCen2, dReg);

    VertexEffectDeform  effect10= new VertexEffectDeform(dVec3, dRad, dCen3, dReg);

    VertexEffectSink    effect11= new VertexEffectSink(sink,center, sReg);

    effect3.setMeshAssociation(14,-1);  // apply to mesh[1], [2] and [3]

    effect4.setMeshAssociation( 2,-1);  // apply only to mesh[1]

    effect5.setMeshAssociation( 4,-1);  // apply only to mesh[2]

    effect6.setMeshAssociation( 8,-1);  // apply only to mesh[3]

    result.apply(effect1);

    result.apply(effect2);

    result.apply(effect3);

    result.apply(effect4);

    result.apply(effect5);

    result.apply(effect6);

    result.apply(effect7);

    result.apply(effect8);

    result.apply(effect9);

    result.apply(effect10);

    result.apply(effect11);

    final float ratio = 0.2f;

    final Static4D[] maps = new Static4D[MESHES];

    for(int mesh=0; mesh<MESHES; mesh++)

      {

      maps[mesh] = new Static4D( mesh*ratio, 0.0f, ratio, 1.0f);

      }

    result.setTextureMap(maps,0);

    result.setShowNormals(true);

    return result;

     */

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

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

    final int FACES_PER_CUBIT=6;

    float D = 0.02f;

    float E = 0.5f;

    float F = SQ2/2;

    float[] vertices0 = { -E+E/4,E/4, E/4,-E+E/4, E/4,E/4};

    float[] bands0 = { 1.0f    , 0,

                       1.0f-2*D, D*0.25f,

                       1.0f-4*D, D*0.35f,

                       1.0f-8*D, D*0.6f,

                       0.60f   , D*1.0f,

                       0.30f   , D*1.375f,

                       0.0f    , D*1.4f };

    MeshBase[] meshes = new MeshBase[FACES_PER_CUBIT];

    meshes[0] = new MeshPolygon(vertices0, bands0, 3, 3);

    meshes[0].setEffectAssociation(0,1,0);

    meshes[1] = meshes[0].copy(true);

    meshes[1].setEffectAssociation(0,2,0);

    meshes[2] = meshes[0].copy(true);

    meshes[2].setEffectAssociation(0,4,0);

    float[] vertices1 = { 0,0, F,0, F/2,(SQ3/2)*F };

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

    meshes[3] = new MeshPolygon(vertices1,bands1,0,0);

    meshes[3].setEffectAssociation(0,8,0);

    meshes[4] = meshes[3].copy(true);

    meshes[4].setEffectAssociation(0,16,0);

    meshes[5] = meshes[3].copy(true);

    meshes[5].setEffectAssociation(0,32,0);

    MeshBase result = new MeshJoined(meshes);

    Static3D axisX  = new Static3D(1,0,0);

    Static3D axisY  = new Static3D(0,1,0);

    Static3D axis0  = new Static3D(-SQ2/2,0,SQ2/2);

    Static3D axis1  = new Static3D(+SQ3/3,+SQ3/3,+SQ3/3);

    Static1D angle1 = new Static1D(+90);

    Static1D angle2 = new Static1D(-90);

    Static1D angle3 = new Static1D(-15);

    Static1D angle4 = new Static1D((float)((180.0f/Math.PI)*Math.acos(SQ3/3)));

    Static1D angle5 = new Static1D(120);

    Static1D angle6 = new Static1D(240);

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

    Static3D center2= new Static3D(-0.5f,-0.5f,-0.5f);

    Static3D move1  = new Static3D(-E/4,-E/4,0);

    Static3D move2  = new Static3D(-0.5f,-0.5f,-0.5f);

    float d0 =-0.04f;

    float d1 = 0.04f;

    float r0 = 0.15f;

    float r1 = 0.10f;

    Static3D vec0   = new Static3D(d0*(+SQ3/3),d0*(+SQ3/3),d0*(+SQ3/3));

    Static3D vec1   = new Static3D(d1*(+SQ3/3),d1*(-SQ3/3),d1*(-SQ3/3));

    Static3D vec2   = new Static3D(d1*(-SQ3/3),d1*(+SQ3/3),d1*(-SQ3/3));

    Static3D vec3   = new Static3D(d1*(-SQ3/3),d1*(-SQ3/3),d1*(+SQ3/3));

    Static1D radius = new Static1D(0.5f);

    Static3D cent0  = new Static3D( 0.0f, 0.0f, 0.0f);

    Static3D cent1  = new Static3D(-0.5f, 0.0f, 0.0f);

    Static3D cent2  = new Static3D( 0.0f,-0.5f, 0.0f);

    Static3D cent3  = new Static3D( 0.0f, 0.0f,-0.5f);

    Static4D reg0   = new Static4D(0,0,0,r0);

    Static4D reg1   = new Static4D(0,0,0,r1);

    VertexEffectMove   effect0 = new VertexEffectMove(move1);

    VertexEffectScale  effect1 = new VertexEffectScale(new Static3D(1,1,-1));

    VertexEffectRotate effect2 = new VertexEffectRotate(angle1,axisX,center1);

    VertexEffectRotate effect3 = new VertexEffectRotate(angle2,axisY,center1);

    VertexEffectMove   effect4 = new VertexEffectMove(move2);

    VertexEffectRotate effect5 = new VertexEffectRotate(angle1,axisX,center2);

    VertexEffectRotate effect6 = new VertexEffectRotate(angle3,axisY,center2);

    VertexEffectRotate effect7 = new VertexEffectRotate(angle4,axis0,center2);

    VertexEffectRotate effect8 = new VertexEffectRotate(angle5,axis1,center2);

    VertexEffectRotate effect9 = new VertexEffectRotate(angle6,axis1,center2);

    VertexEffectDeform effect10= new VertexEffectDeform(vec0,radius,cent0,reg0);

    VertexEffectDeform effect11= new VertexEffectDeform(vec1,radius,cent1,reg1);

    VertexEffectDeform effect12= new VertexEffectDeform(vec2,radius,cent2,reg1);

    VertexEffectDeform effect13= new VertexEffectDeform(vec3,radius,cent3,reg1);

    effect0.setMeshAssociation( 7,-1);  // meshes 0,1,2

    effect1.setMeshAssociation( 6,-1);  // meshes 1,2

    effect2.setMeshAssociation( 2,-1);  // mesh 1

    effect3.setMeshAssociation( 4,-1);  // mesh 2

    effect4.setMeshAssociation(56,-1);  // meshes 3,4,5

    effect5.setMeshAssociation(56,-1);  // meshes 3,4,5

    effect6.setMeshAssociation(56,-1);  // meshes 3,4,5

    effect7.setMeshAssociation(56,-1);  // meshes 3,4,5

    effect8.setMeshAssociation(16,-1);  // mesh 4

    effect9.setMeshAssociation(32,-1);  // mesh 5

    effect10.setMeshAssociation(63,-1); // all meshes

    effect11.setMeshAssociation(63,-1); // all meshes

    effect12.setMeshAssociation(63,-1); // all meshes

    effect13.setMeshAssociation(63,-1); // all meshes

    result.apply(effect0);

    result.apply(effect1);

    result.apply(effect2);

    result.apply(effect3);

    result.apply(effect4);

    result.apply(effect5);

    result.apply(effect6);

    result.apply(effect7);

    result.apply(effect8);

    result.apply(effect9);

    result.apply(effect10);

    result.apply(effect11);

    result.apply(effect12);

    result.apply(effect13);

//result.setShowNormals(true);

    return result;

    }

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

    private void createMesh()

      {

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

      }

}