commit 8fbe9426284dae2f2df2bab305f8f805372d4004
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Sun Apr 7 00:48:00 2019 +0100

    RubikApp: make the rotations smooth.

diff --git a/src/main/java/org/distorted/examples/rubik/RubikRenderer.java b/src/main/java/org/distorted/examples/rubik/RubikRenderer.java
index 312cf44..f0e10b8 100644
--- a/src/main/java/org/distorted/examples/rubik/RubikRenderer.java
+++ b/src/main/java/org/distorted/examples/rubik/RubikRenderer.java
@@ -164,7 +164,7 @@ class RubikRenderer implements GLSurfaceView.Renderer
 
     Static4D initializeQuat()
       {
-      return new Static4D(-0.25189602f,0.3546389f,0.009657208f,0.90038127f);
+      return new Static4D(0,0,0,1);//(-0.25189602f,0.3546389f,0.009657208f,0.90038127f);
       }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/examples/rubik/RubikSurfaceView.java b/src/main/java/org/distorted/examples/rubik/RubikSurfaceView.java
index 706e0d9..a97d101 100644
--- a/src/main/java/org/distorted/examples/rubik/RubikSurfaceView.java
+++ b/src/main/java/org/distorted/examples/rubik/RubikSurfaceView.java
@@ -52,7 +52,7 @@ class RubikSurfaceView extends GLSurfaceView
     private RubikRenderer mRenderer;
     private RubikCube mCube;
 
-    private float[] mPoi, mCam, mTouchedPointCastOntoFace, mDiff; // all in screen space
+    private float[] mPoint, mCamera, mTouchPointCastOntoFace, mDiff, mTouchPoint; // all in screen space
     private int mLastTouchedFace;
     private int mScreenWidth, mScreenHeight, mScreenMin;
     private float mCameraDistance;
@@ -67,10 +67,11 @@ class RubikSurfaceView extends GLSurfaceView
       mBeginRot = false;
       mRotationVect = VECT[0];
 
-      mPoi   = new float[3];
-      mCam   = new float[3];
+      mPoint = new float[3];
+      mCamera= new float[3];
       mDiff  = new float[3];
-      mTouchedPointCastOntoFace = new float[3];
+      mTouchPoint = new float[3];
+      mTouchPointCastOntoFace = new float[3];
 
       mScreenWidth = mScreenHeight = mScreenMin = 0;
 
@@ -165,8 +166,6 @@ class RubikSurfaceView extends GLSurfaceView
       }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// mTouchedPointCastOntoFace[x] is the x distance between the x-center of the face and the point
-// we just touched cast onto the face. The face is touched iff -cH <= mTouchedPointCastOntoFace[0,1,2] <= +cH
 
     private int faceTouched(int xTouch, int yTouch)
       {
@@ -179,11 +178,11 @@ class RubikSurfaceView extends GLSurfaceView
         {
         if( faceIsVisible(face,cubeHalfSize) )
           {
-          castTouchPointOntoFace(face,cubeHalfSize, mTouchedPointCastOntoFace);
+          castTouchPointOntoFace(face,cubeHalfSize, mTouchPointCastOntoFace);
 
-          float qX= (mTouchedPointCastOntoFace[0]+cubeHalfSize) / (2*cubeHalfSize);
-          float qY= (mTouchedPointCastOntoFace[1]+cubeHalfSize) / (2*cubeHalfSize);
-          float qZ= (mTouchedPointCastOntoFace[2]+cubeHalfSize) / (2*cubeHalfSize);
+          float qX= (mTouchPointCastOntoFace[0]+cubeHalfSize) / (2*cubeHalfSize);
+          float qY= (mTouchPointCastOntoFace[1]+cubeHalfSize) / (2*cubeHalfSize);
+          float qZ= (mTouchPointCastOntoFace[2]+cubeHalfSize) / (2*cubeHalfSize);
 
           if( qX<=1 && qX>=0 && qY<=1 && qY>=0 && qZ<=1 && qZ>=0 ) return face;
           }
@@ -201,18 +200,18 @@ class RubikSurfaceView extends GLSurfaceView
       convertTouchPointToScreenSpace(x,y);
       castTouchPointOntoFace(mLastTouchedFace,cubeHalfSize,mDiff);
 
-      mDiff[0] -= mTouchedPointCastOntoFace[0];
-      mDiff[1] -= mTouchedPointCastOntoFace[1];
-      mDiff[2] -= mTouchedPointCastOntoFace[2];
+      mDiff[0] -= mTouchPointCastOntoFace[0];
+      mDiff[1] -= mTouchPointCastOntoFace[1];
+      mDiff[2] -= mTouchPointCastOntoFace[2];
 
       int xAxis = retFaceXaxis(mLastTouchedFace);
       int yAxis = retFaceYaxis(mLastTouchedFace);
       mRotationVect = (isVertical( mDiff[xAxis], mDiff[yAxis]) ? VECT[xAxis]:VECT[yAxis]);
-      float offset= (mTouchedPointCastOntoFace[mRotationVect]+cubeHalfSize)/(2*cubeHalfSize);
+      float offset= (mTouchPointCastOntoFace[mRotationVect]+cubeHalfSize)/(2*cubeHalfSize);
 
-      mTouchedPointCastOntoFace[0] = mDiff[0] + mTouchedPointCastOntoFace[0];
-      mTouchedPointCastOntoFace[1] = mDiff[1] + mTouchedPointCastOntoFace[1];
-      mTouchedPointCastOntoFace[2] = mDiff[2] + mTouchedPointCastOntoFace[2];
+      mTouchPoint[0] = mPoint[0];
+      mTouchPoint[1] = mPoint[1];
+      mTouchPoint[2] = mPoint[2];
 
       mCube.addNewRotation(mRotationVect,offset);
       }
@@ -228,19 +227,15 @@ class RubikSurfaceView extends GLSurfaceView
 
     private void continueRotation(int x, int y)
       {
-      float cubeHalfSize= mRenderer.returnCubeSizeInScreenSpace()*0.5f;
-
       convertTouchPointToScreenSpace(x,y);
-      castTouchPointOntoFace(mLastTouchedFace,cubeHalfSize,mDiff);
 
-      mDiff[0] -= mTouchedPointCastOntoFace[0];
-      mDiff[1] -= mTouchedPointCastOntoFace[1];
-      mDiff[2] -= mTouchedPointCastOntoFace[2];
+      mDiff[0] = mPoint[0]-mTouchPoint[0];
+      mDiff[1] = mPoint[1]-mTouchPoint[1];
+      mDiff[2] = mPoint[2]-mTouchPoint[2];
 
       int xAxis= retFaceXaxis(mLastTouchedFace);
       int yAxis= retFaceYaxis(mLastTouchedFace);
       int sign = retFaceRotationSign(mLastTouchedFace);
-
       float angle = (mRotationVect==xAxis ? mDiff[yAxis] : -mDiff[xAxis]);
 
       mCube.continueRotation(200.0f*sign*angle/mScreenMin);
@@ -339,7 +334,7 @@ class RubikSurfaceView extends GLSurfaceView
       int sign = retFaceSign(face);
       int zAxis= retFaceZaxis(face);
 
-      return sign*mCam[zAxis] > cubeHalfSize;
+      return sign*mCamera[zAxis] > cubeHalfSize;
       }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -351,9 +346,9 @@ class RubikSurfaceView extends GLSurfaceView
       Static4D touchPoint = new Static4D(x-halfScrWidth, halfScrHeight-y, 0, 0);
       Static4D rotatedTouchPoint= rotateVectorByInvertedQuat(touchPoint, mQuatAccumulated);
 
-      mPoi[0] = rotatedTouchPoint.get1();
-      mPoi[1] = rotatedTouchPoint.get2();
-      mPoi[2] = rotatedTouchPoint.get3();
+      mPoint[0] = rotatedTouchPoint.get1();
+      mPoint[1] = rotatedTouchPoint.get2();
+      mPoint[2] = rotatedTouchPoint.get3();
       }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -363,9 +358,9 @@ class RubikSurfaceView extends GLSurfaceView
       Static4D cameraPoint = new Static4D(0, 0, mCameraDistance, 0);
       Static4D rotatedCamera= rotateVectorByInvertedQuat(cameraPoint, mQuatAccumulated);
 
-      mCam[0] = rotatedCamera.get1();
-      mCam[1] = rotatedCamera.get2();
-      mCam[2] = rotatedCamera.get3();
+      mCamera[0] = rotatedCamera.get1();
+      mCamera[1] = rotatedCamera.get2();
+      mCamera[2] = rotatedCamera.get3();
       }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -377,13 +372,13 @@ class RubikSurfaceView extends GLSurfaceView
       {
       int sign = retFaceSign(face);
       int zAxis= retFaceZaxis(face);
-      float diff = mPoi[zAxis]-mCam[zAxis];
+      float diff = mPoint[zAxis]-mCamera[zAxis];
 
-      float ratio =  diff!=0.0f ? (sign*cubeHalfSize-mCam[zAxis])/diff : 0.0f;
+      float ratio =  diff!=0.0f ? (sign*cubeHalfSize-mCamera[zAxis])/diff : 0.0f;
 
-      output[0] = (mPoi[0]-mCam[0])*ratio + mCam[0];
-      output[1] = (mPoi[1]-mCam[1])*ratio + mCam[1];
-      output[2] = (mPoi[2]-mCam[2])*ratio + mCam[2];
+      output[0] = (mPoint[0]-mCamera[0])*ratio + mCamera[0];
+      output[1] = (mPoint[1]-mCamera[1])*ratio + mCamera[1];
+      output[2] = (mPoint[2]-mCamera[2])*ratio + mCamera[2];
       }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
