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

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.opengl.GLSurfaceView;

import org.distorted.library.effect.EffectName;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.PostprocessEffectGlow;

import org.distorted.library.effect.VertexEffectSink;

import org.distorted.library.main.Distorted;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshCubes;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

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

class RubikRenderer implements GLSurfaceView.Renderer

{

            static final int NUM_CUBES =   3;

    private static final int SIZE      = 200;

    private static final float CUBE_SCREEN_RATIO = 0.5f;

    private GLSurfaceView mView;

    private DistortedTexture mTexture;

    private DistortedScreen mScreen;

    private Static3D mMove, mScale, mCenter;

    private MeshCubes[][][] mCubes;

    private DistortedEffects[][][] mEffects;

    private int mScreenWidth, mScreenHeight;

    private int mLastRow, mLastCol, mLastSli;

    private Static1D mGlowRadius;

    private Static4D mGlowColor;

    private Static4D mQuatCurrent, mQuatAccumulated;

    private Static4D mTempCurrent, mTempAccumulated;

    int mScreenMin;

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

    RubikRenderer(GLSurfaceView v)

      {

      mView = v;

      mScreen = new DistortedScreen();

      mScreen.setProjection(90.0f, 0.1f);

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

      mTempAccumulated = initializeQuat();

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

      mQuatAccumulated = initializeQuat();

      mCubes = new MeshCubes[NUM_CUBES][NUM_CUBES][NUM_CUBES];

      mEffects = new DistortedEffects[NUM_CUBES][NUM_CUBES][NUM_CUBES];

      Static3D[][][] cubeVectors = new Static3D[NUM_CUBES][NUM_CUBES][NUM_CUBES];

      float sinkDegree = 3.0f - 1.7f/NUM_CUBES; // f(1)=1.3, f(inf)=3

      VertexEffectSink sink = new VertexEffectSink( new Static1D(sinkDegree),

                                                    new Static3D(SIZE*0.5f, SIZE*0.5f, SIZE*0.5f),

                                                    new Static4D(0,0,0, SIZE*0.72f) );

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

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

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

      mLastRow = mLastCol = mLastSli = 0;

      mGlowRadius = new Static1D(5);

      mGlowColor  = new Static4D(1.0f,1.0f,1.0f,0.6f);

      MatrixEffectMove       move  = new MatrixEffectMove(mMove);

      MatrixEffectScale      scale = new MatrixEffectScale(mScale);

      MatrixEffectQuaternion quat1 = new MatrixEffectQuaternion(mQuatCurrent    , mCenter);

      MatrixEffectQuaternion quat2 = new MatrixEffectQuaternion(mQuatAccumulated, mCenter);

      // 3x2 bitmap = 6 squares:

      //

      // RED     GREEN   BLUE

      // YELLOW  WHITE   BROWN

      final float ze = 0.0f;

      final float ot = 1.0f/3.0f;

      final float tt = 2.0f/3.0f;

      final float oh = 1.0f/2.0f;

      final float of = 1.0f/40.0f;

      final Static4D mapFront = new Static4D(ze,oh, ze+ot,oh+oh);

      final Static4D mapBack  = new Static4D(tt,ze, tt+ot,ze+oh);

      final Static4D mapLeft  = new Static4D(ot,ze, ot+ot,ze+oh);

      final Static4D mapRight = new Static4D(ze,ze, ze+ot,ze+oh);

      final Static4D mapTop   = new Static4D(tt,oh, tt+ot,oh+oh);

      final Static4D mapBottom= new Static4D(ot,oh, ot+ot,oh+oh);

      final Static4D mapBlack = new Static4D(ze,ze, ze+of,ze+of);

      Static4D tmpFront, tmpBack, tmpLeft, tmpRight, tmpTop, tmpBottom;

      float nc = 0.5f*(NUM_CUBES-1);

      int vertices = (int)(24.0f/NUM_CUBES + 2.0f);

      for(int x = 0; x< NUM_CUBES; x++)

        for(int y = 0; y< NUM_CUBES; y++)

          for(int z = 0; z< NUM_CUBES; z++)

            {

            if( x==0 || x==NUM_CUBES-1 || y==0 || y==NUM_CUBES-1 || z==0 || z==NUM_CUBES-1 ) // only the external walls

              {

              tmpLeft  = (x==            0 ? mapLeft  :mapBlack);

              tmpRight = (x== NUM_CUBES -1 ? mapRight :mapBlack);

              tmpFront = (z== NUM_CUBES -1 ? mapFront :mapBlack);

              tmpBack  = (z==            0 ? mapBack  :mapBlack);

              tmpTop   = (y== NUM_CUBES -1 ? mapTop   :mapBlack);

              tmpBottom= (y==            0 ? mapBottom:mapBlack);

              mCubes[x][y][z] = new MeshCubes(vertices,vertices,vertices, tmpFront, tmpBack, tmpLeft, tmpRight, tmpTop, tmpBottom);

              cubeVectors[x][y][z] = new Static3D( SIZE*(x-nc), SIZE*(y-nc), SIZE*(z-nc) );

              mEffects[x][y][z] = new DistortedEffects();

              mEffects[x][y][z].apply(sink);

              mEffects[x][y][z].apply(move);

              mEffects[x][y][z].apply(scale);

              mEffects[x][y][z].apply(quat1);

              mEffects[x][y][z].apply(quat2);

              mEffects[x][y][z].apply( new MatrixEffectMove(cubeVectors[x][y][z]) );

              }

            }

      }

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

    public void onDrawFrame(GL10 glUnused) 

      {

      mScreen.render( System.currentTimeMillis() );

      mQuatCurrent.set(mTempCurrent);

      mQuatAccumulated.set(mTempAccumulated);

      }

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

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

      {

      mScreenWidth = width;

      mScreenHeight= height;

      mScreenMin = width<height ? width:height;

      float w = mTexture.getWidth();

      float h = mTexture.getHeight();

      float d = mTexture.getDepth(mCubes[0][0][0]);

      float factor = CUBE_SCREEN_RATIO*(width>height ? height/h:width/w)/ NUM_CUBES;

      mCenter.set(w/2,h/2,d/2);

      mMove.set( (width-factor*w)/2 , (height-factor*h)/2 , -factor*d/2 );

      mScale.set(factor,factor,factor);

      mScreen.resize(width, height);

      }

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

    public void onSurfaceCreated(GL10 glUnused, EGLConfig config) 

      {

      Bitmap bitmap;

      final int S = 128;

      final int W = 3*S;

      final int H = 2*S;

      final int R = S/10;

      final int M = S/20;

      Paint paint = new Paint();

      bitmap = Bitmap.createBitmap(W,H, Bitmap.Config.ARGB_8888);

      Canvas canvas = new Canvas(bitmap);

      paint.setAntiAlias(true);

      paint.setTextAlign(Paint.Align.CENTER);

      paint.setStyle(Paint.Style.FILL);

      // 3x2 bitmap = 6 squares:

      //

      // RED     GREEN   BLUE

      // YELLOW  WHITE   BROWN

      paint.setColor(0xff000000);                                  // BLACK BACKGROUND

      canvas.drawRect(0, 0, W, H, paint);                          //

      paint.setColor(0xffff0000);                                  // RED

      canvas.drawRoundRect(    M,   M,   S-M,   S-M, R, R, paint); //

      paint.setColor(0xff00ff00);                                  // GREEN

      canvas.drawRoundRect(  S+M,   M, 2*S-M,   S-M, R, R, paint); //

      paint.setColor(0xff0000ff);                                  // BLUE

      canvas.drawRoundRect(2*S+M,   M, 3*S-M,   S-M, R, R, paint); //

      paint.setColor(0xffffff00);                                  // YELLOW

      canvas.drawRoundRect(    M, S+M,   S-M, 2*S-M, R, R, paint); //

      paint.setColor(0xffffffff);                                  // WHITE

      canvas.drawRoundRect(  S+M, S+M, 2*S-M, 2*S-M, R, R, paint); //

      paint.setColor(0xffb5651d);                                  // BROWN

      canvas.drawRoundRect(2*S+M, S+M, 3*S-M, 2*S-M, R, R, paint); //

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

      mTexture.setTexture(bitmap);

      mScreen.detachAll();

      for(int x = 0; x< NUM_CUBES; x++)

        for(int y = 0; y< NUM_CUBES; y++)

          for(int z = 0; z< NUM_CUBES; z++)

            if( x==0 || x==NUM_CUBES-1 || y==0 || y==NUM_CUBES-1 || z==0 || z==NUM_CUBES-1 ) // only the external walls

              {

              mScreen.attach(mTexture,mEffects[x][y][z],mCubes[x][y][z]);

              }

      PostprocessEffectGlow.enable();

      VertexEffectSink.enable();

      try

        {

        Distorted.onCreate(mView.getContext());

        }

      catch(Exception ex)

        {

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

        }

      }

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

    float returnCameraDistance()

      {

      float fov = mScreen.getFOV();

      double fovInRadians = (fov*Math.PI) / 180.0;

      double distance = (mScreenHeight*0.5f)/Math.tan(fovInRadians*0.5);

      return (float)distance;

      }

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

// NUM_CUBES individual little cubes, each SIZE in size, times 'scaleFactor' (see onSurfaceChanged)

    float returnCubeSize()

      {

      float w = mTexture.getWidth();

      float h = mTexture.getHeight();

      float max = (mScreenWidth>mScreenHeight ? mScreenHeight/h:mScreenWidth/w);

      float scaleFactor = CUBE_SCREEN_RATIO*max/NUM_CUBES;

      return scaleFactor*NUM_CUBES*SIZE;

      }

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

    void rotateFace(Static3D vector, int angle, int row )

      {

      String vect = "("+vector.get1()+","+vector.get2()+","+vector.get3()+")";

      android.util.Log.e("rubik", "rotating by "+angle+" degrees, row="+row+" vector: "+vect);

      }

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

    float getScreenWidth()

      {

      return mScreenWidth;

      }

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

    float getScreenHeight()

      {

      return mScreenHeight;

      }

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

    void abortLastEffect()

      {

      mEffects[mLastCol][mLastRow][mLastSli].abortByName(EffectName.GLOW);

      }

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

    void applyNewEffect(int col, int row, int sli)

      {

      mLastCol = col;

      mLastRow = row;

      mLastSli = sli;

      mEffects[mLastCol][mLastRow][mLastSli].apply(new PostprocessEffectGlow(mGlowRadius,mGlowColor));

      }

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

// Initial rotation of the cube. Something semi-random that looks good.

    Static4D initializeQuat()

      {

      return new Static4D(-0.25189602f,0.3546389f,0.009657208f,0.90038127f);

      }

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

    void setQuatCurrent(Static4D current)

      {

      mTempCurrent.set(current);

      }

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

    void setQuatAccumulated(Static4D accumulated)

      {

      mTempAccumulated.set(accumulated);

      }

}