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.app.ActivityManager;

import android.content.Context;

import android.content.pm.ConfigurationInfo;

import android.opengl.GLSurfaceView;

import android.view.MotionEvent;

import org.distorted.library.type.Static4D;

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

class RubikSurfaceView extends GLSurfaceView

{

    private final static int NONE   =-1;

    private final static int FRONT  = 0;  // has to be 6 consecutive ints

    private final static int BACK   = 1;  // FRONT ... BOTTOM

    private final static int LEFT   = 2;  //

    private final static int RIGHT  = 3;  //

    private final static int TOP    = 4;  //

    private final static int BOTTOM = 5;  //

    private static final int DIR_UP   =0;

    private static final int DIR_DOWN =1;

    private static final int DIR_LEFT =2;

    private static final int DIR_RIGHT=3;

    static final int VECTX = 0;

    static final int VECTY = 1;

    static final int VECTZ = 2;

    static final int VECTN = 3;

    private boolean mDragging, mRotating;

    private int mX, mY;

    private Static4D mQuatCurrent, mQuatAccumulated;

    private int mRotationVect;

    private RubikRenderer mRenderer;

    private float mPoiX, mPoiY, mPoiZ, mCamX, mCamY, mCamZ;

    private float mStartX, mStartY, mStartZ;

    private int mLastTouchedFace;

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

    public RubikSurfaceView(Context context)

      {

      super(context);

      mDragging = false;

      mRotating = false;

      mRotationVect = VECTN;

      mRenderer = new RubikRenderer(this);

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

      mQuatAccumulated = mRenderer.initializeQuat();

      final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

      final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();

      setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );

      setRenderer(mRenderer);

      }

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

    public RubikRenderer getRenderer()

      {

      return mRenderer;

      }

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

    @Override

    public boolean onTouchEvent(MotionEvent event)

      {

      int action = event.getAction();

      int x = (int)event.getX();

      int y = (int)event.getY();

      switch(action)

         {

         case MotionEvent.ACTION_DOWN: mX = x;

                                       mY = y;

                                       mLastTouchedFace = faceTouched(x,y);

                                       if( mLastTouchedFace != NONE )

                                         {

                                         mRotating = true;

                                         }

                                       else

                                         {

                                         mDragging = true;

                                         }

                                       break;

         case MotionEvent.ACTION_MOVE: if( mDragging )

                                         {

                                         mQuatCurrent.set(quatFromDrag(mX-x,mY-y));

                                         mRenderer.setQuatCurrent(mQuatCurrent);

                                         }

                                       else if( mRotating )

                                         {

                                         int minimumToRotate = (mRenderer.mScreenMin*mRenderer.mScreenMin)/36;

                                         if( (mX-x)*(mX-x)+(mY-y)*(mY-y)>minimumToRotate )

                                           {

                                           addNewRotation(x,y);

                                           mX = x;

                                           mY = y;

                                           mRotating = false;

                                           }

                                         }

                                       else

                                         {

                                         continueRotation(x,y);

                                         }

                                       break;

         case MotionEvent.ACTION_UP  : if( !mDragging ) finishRotation();

                                       mDragging = false;

                                       mRotating = false;

                                       mQuatAccumulated.set(quatMultiply(mQuatCurrent, mQuatAccumulated));

                                       mQuatCurrent.set(0f, 0f, 0f, 1f);

                                       mRenderer.setQuatCurrent(mQuatCurrent);

                                       mRenderer.setQuatAccumulated(mQuatAccumulated);

                                       break;

         }

      return true;

      }

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

    private void addNewRotation(int x, int y)

      {

      fillTouchPoint(x,y);

      float cubeHalfSize= mRenderer.returnCubeSize()*0.5f;

      float tmp = RubikRenderer.NUM_CUBES/(2*cubeHalfSize);

      float A=retA(mLastTouchedFace,cubeHalfSize);

      float diffX = (mPoiX-mCamX)*A + mCamX - mStartX;

      float diffY = (mPoiY-mCamY)*A + mCamY - mStartY;

      float diffZ = (mPoiZ-mCamZ)*A + mCamZ - mStartZ;

      int dir, row=1;

      switch(mLastTouchedFace)

        {

        case FRONT : dir = retDirection( diffX, diffY);

                     mRotationVect = (dir==DIR_UP || dir==DIR_DOWN) ? VECTX:VECTY;

                     row = (int)( tmp*((mRotationVect==VECTX?mStartX:mStartY)+cubeHalfSize) );

                     break;

        case BACK  : dir = retDirection(-diffX, diffY);

                     mRotationVect = (dir==DIR_UP || dir==DIR_DOWN) ? VECTX:VECTY;

                     row = (int)( tmp*((mRotationVect==VECTX?mStartX:mStartY)+cubeHalfSize) );

                     break;

        case LEFT  : dir = retDirection( diffZ, diffY);

                     mRotationVect = (dir==DIR_UP || dir==DIR_DOWN) ? VECTZ:VECTY;

                     row = (int)( tmp*((mRotationVect==VECTZ?mStartZ:mStartY)+cubeHalfSize) );

                     break;

        case RIGHT : dir = retDirection(-diffZ, diffY);

                     mRotationVect = (dir==DIR_UP || dir==DIR_DOWN) ? VECTZ:VECTY;

                     row = (int)( tmp*((mRotationVect==VECTZ?mStartZ:mStartY)+cubeHalfSize) );

                     break;

        case TOP   : dir = retDirection( diffX,-diffZ);

                     mRotationVect = (dir==DIR_UP || dir==DIR_DOWN) ? VECTX:VECTZ;

                     row = (int)( tmp*((mRotationVect==VECTX?mStartX:mStartZ)+cubeHalfSize) );

                     break;

        case BOTTOM: dir = retDirection( diffX, diffZ);

                     mRotationVect = (dir==DIR_UP || dir==DIR_DOWN) ? VECTX:VECTZ;

                     row = (int)( tmp*((mRotationVect==VECTX?mStartX:mStartZ)+cubeHalfSize) );

                     break;

        }

      mStartX = diffX + mStartX;

      mStartY = diffY + mStartY;

      mStartZ = diffZ + mStartZ;

      mRenderer.addNewRotation(mRotationVect,row);

      }

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

    private void continueRotation(int x, int y)

      {

      fillTouchPoint(x,y);

      int sign=1;

      float cubeHalfSize= mRenderer.returnCubeSize()*0.5f;

      float A=retA(mLastTouchedFace,cubeHalfSize);

      float diffX = (mPoiX-mCamX)*A + mCamX - mStartX;

      float diffY = (mPoiY-mCamY)*A + mCamY - mStartY;

      float diffZ = (mPoiZ-mCamZ)*A + mCamZ - mStartZ;

      switch(mRotationVect)

        {

        case VECTX: switch(mLastTouchedFace)

                      {

                      case FRONT : sign = returnSign(-diffY); break;

                      case BACK  : sign = returnSign( diffY); break;

                      case TOP   : sign = returnSign( diffZ); break;

                      case BOTTOM: sign = returnSign(-diffZ); break;

                      }

                    break;

        case VECTY: switch(mLastTouchedFace)

                      {

                      case FRONT : sign = returnSign( diffX); break;

                      case BACK  : sign = returnSign(-diffX); break;

                      case LEFT  : sign = returnSign( diffZ); break;

                      case RIGHT : sign = returnSign(-diffZ); break;

                      }

                    break;

        case VECTZ: switch(mLastTouchedFace)

                      {

                      case TOP   : sign = returnSign(-diffX); break;

                      case BOTTOM: sign = returnSign( diffX); break;

                      case LEFT  : sign = returnSign(-diffY); break;

                      case RIGHT : sign = returnSign( diffY); break;

                      }

                    break;

        default   : android.util.Log.e("View", "impossible vector: "+mRotationVect);

        }

      float dX = mX-x;

      float dY = mY-y;

      float calibration = (float)Math.sqrt(dX*dX+dY*dY);

      mRenderer.continueRotation(calibration*sign);

      }

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

    private void finishRotation()

      {

      mRotationVect = VECTN;

      mRenderer.finishRotation();

      }

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

    private int returnSign(float diff)

      {

      return diff>0 ? 1 : -1;

      }

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

    private int retDirection(float a, float b)

      {

      if( b>a ) return a>-b ? DIR_UP   :DIR_LEFT;

      else      return a>-b ? DIR_RIGHT:DIR_DOWN;

      }

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

// return quat1*quat2

    static Static4D quatMultiply( Static4D quat1, Static4D quat2 )

      {

      float qx = quat1.get1();

      float qy = quat1.get2();

      float qz = quat1.get3();

      float qw = quat1.get4();

      float rx = quat2.get1();

      float ry = quat2.get2();

      float rz = quat2.get3();

      float rw = quat2.get4();

      float tx = rw*qx - rz*qy + ry*qz + rx*qw;

      float ty = rw*qy + rz*qx + ry*qw - rx*qz;

      float tz = rw*qz + rz*qw - ry*qx + rx*qy;

      float tw = rw*qw - rz*qz - ry*qy - rx*qx;

      return new Static4D(tx,ty,tz,tw);

      }

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

    private Static4D quatFromDrag(float dragX, float dragY)

      {

      float axisX = dragY;  // inverted X and Y - rotation axis is

      float axisY = dragX;  // perpendicular to (dragX,dragY)

      float axisZ = 0;

      float axisL = (float)Math.sqrt(axisX*axisX + axisY*axisY + axisZ*axisZ);

      if( axisL>0 )

        {

        axisX /= axisL;

        axisY /= axisL;

        axisZ /= axisL;

        float cosA = (float)Math.cos(axisL*Math.PI/mRenderer.mScreenMin);

        float sinA = (float)Math.sqrt(1-cosA*cosA);

        return new Static4D(axisX*sinA, axisY*sinA, axisZ*sinA, cosA);

        }

      return new Static4D(0f, 0f, 0f, 1f);

      }

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

    private int returnFrontFace()

      {

      Static4D rotated = rotateVector(new Static4D(0,0,1,0));

      float rotatedX = rotated.get1();

      float rotatedY = rotated.get2();

      float rotatedZ = rotated.get3();

      float absX = rotatedX>0 ? rotatedX : -rotatedX;

      float absY = rotatedY>0 ? rotatedY : -rotatedY;

      float absZ = rotatedZ>0 ? rotatedZ : -rotatedZ;

      if( absX>absY && absX>absZ ) return rotatedX>0 ? RIGHT:LEFT;

      if( absY>absX && absY>absZ ) return rotatedY>0 ? TOP:BOTTOM;

      if( absZ>absX && absZ>absY ) return rotatedZ>0 ? FRONT:BACK;

      return NONE;

      }

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

    private boolean faceIsVisible(int face)

      {

      float cameraDistance = mRenderer.returnCameraDistance();

      float cubeHalfSize   = mRenderer.returnCubeSize()*0.5f;

      Static4D rotated = rotateVector(new Static4D(0,0,cameraDistance,0));

      switch(face)

        {

        case FRONT : return rotated.get3() >  cubeHalfSize;

        case BACK  : return rotated.get3() < -cubeHalfSize;

        case LEFT  : return rotated.get1() < -cubeHalfSize;

        case RIGHT : return rotated.get1() >  cubeHalfSize;

        case TOP   : return rotated.get2() >  cubeHalfSize;

        case BOTTOM: return rotated.get2() < -cubeHalfSize;

        }

      return false;

      }

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

// rotate 'vector' by quaternion q=mQuatAccumulated^(-1)  ( i.e. return (q^-1)*vector*q )

    private Static4D rotateVector(Static4D vector)

      {

      float qx = mQuatAccumulated.get1();

      float qy = mQuatAccumulated.get2();

      float qz = mQuatAccumulated.get3();

      float qw = mQuatAccumulated.get4();

      Static4D quatInverted= new Static4D(-qx,-qy,-qz,qw);

      Static4D tmp = quatMultiply(quatInverted,vector);

      return quatMultiply(tmp,mQuatAccumulated);

      }

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

    private int faceTouched(int xTouch, int yTouch)

      {

      float cubeHalfSize= mRenderer.returnCubeSize()*0.5f;

      fillTouchPoint(xTouch,yTouch);

      fillCamera();

      for(int face=FRONT; face<=BOTTOM; face++)

        {

        if( faceIsVisible(face) && faceCondition(face) )

          {

          float A = retA(face,cubeHalfSize);

          mStartX = (mPoiX-mCamX)*A + mCamX;

          mStartY = (mPoiY-mCamY)*A + mCamY;

          mStartZ = (mPoiZ-mCamZ)*A + mCamZ;

          float qX= (mStartX+cubeHalfSize) / (2*cubeHalfSize);

          float qY= (mStartY+cubeHalfSize) / (2*cubeHalfSize);

          float qZ= (mStartZ+cubeHalfSize) / (2*cubeHalfSize);

          if( qX<=1 && qX>=0 && qY<=1 && qY>=0 && qZ<=1 && qZ>=0 ) return face;

          }

        }

      return NONE;

      }

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

    void fillTouchPoint(int x, int y)

      {

      float halfScrWidth  = mRenderer.getScreenWidth() *0.5f;

      float halfScrHeight = mRenderer.getScreenHeight()*0.5f;

      Static4D touchPoint = new Static4D(x-halfScrWidth, halfScrHeight-y, 0, 0);

      Static4D rotatedTouchPoint= rotateVector(touchPoint);

      mPoiX = rotatedTouchPoint.get1();

      mPoiY = rotatedTouchPoint.get2();

      mPoiZ = rotatedTouchPoint.get3();

      }

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

    void fillCamera()

      {

      float cameraDistance = mRenderer.returnCameraDistance();

      Static4D cameraPoint = new Static4D(0, 0, cameraDistance, 0);

      Static4D rotatedCamera= rotateVector(cameraPoint);

      mCamX = rotatedCamera.get1();

      mCamY = rotatedCamera.get2();

      mCamZ = rotatedCamera.get3();

      }

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

    float retA(int face, float cubeHalfSize)

      {

      switch(face)

        {

        case FRONT : return ( mPoiZ!=mCamZ ? ( cubeHalfSize-mCamZ)/(mPoiZ-mCamZ) : 0f);

        case BACK  : return ( mPoiZ!=mCamZ ? (-cubeHalfSize-mCamZ)/(mPoiZ-mCamZ) : 0f);

        case LEFT  : return ( mPoiX!=mCamX ? (-cubeHalfSize-mCamX)/(mPoiX-mCamX) : 0f);

        case RIGHT : return ( mPoiX!=mCamX ? ( cubeHalfSize-mCamX)/(mPoiX-mCamX) : 0f);

        case TOP   : return ( mPoiY!=mCamY ? ( cubeHalfSize-mCamY)/(mPoiY-mCamY) : 0f);

        case BOTTOM: return ( mPoiY!=mCamY ? (-cubeHalfSize-mCamY)/(mPoiY-mCamY) : 0f);

        }

      return 0.0f;

      }

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

    boolean faceCondition(int face)

      {

      switch(face)

        {

        case FRONT :

        case BACK  : return ( mPoiZ!=mCamZ );

        case LEFT  :

        case RIGHT : return ( mPoiX!=mCamX );

        case TOP   :

        case BOTTOM: return ( mPoiY!=mCamY );

        }

      return false;

      }

}