commit 45686da26c3ec4c27c03a2e4f16038b9fde0dcb6
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Wed Jan 22 13:29:09 2020 +0000

    RubikCube: remove all awareness of rotations from RubikRenderer.

diff --git a/src/main/java/org/distorted/magic/RubikRenderer.java b/src/main/java/org/distorted/magic/RubikRenderer.java
index 1c250bb8..be8ad10a 100644
--- a/src/main/java/org/distorted/magic/RubikRenderer.java
+++ b/src/main/java/org/distorted/magic/RubikRenderer.java
@@ -29,7 +29,6 @@ import org.distorted.library.main.DistortedScreen;
 import org.distorted.library.main.DistortedTexture;
 import org.distorted.library.mesh.MeshFlat;
 import org.distorted.library.message.EffectListener;
-import org.distorted.library.type.Static4D;
 
 import javax.microedition.khronos.egl.EGLConfig;
 import javax.microedition.khronos.opengles.GL10;
@@ -44,14 +43,12 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
 
     private RubikSurfaceView mView;
     private DistortedScreen mScreen;
-    private Static4D mQuatCurrent, mQuatAccumulated;
-    private Static4D mTempCurrent, mTempAccumulated;
     private float mCubeSizeInScreenSpace;
     private int mNextCubeSize, mScrambleCubeNum;
     private long mRotationFinishedID;
     private long[] mEffectID;
     private boolean mFinishRotation, mRemoveRotation, mFinishDragCurrent, mFinishDragAccumulated, mSolveCube, mScrambleCube;
-    private boolean mCanRotate, mCanDrag, mCanScramble, mCanSolve;
+    private boolean mCanRotate, mCanDrag, mCanUI;
     private RubikCube mOldCube, mNewCube;
     private int mScreenWidth, mScreenHeight;
     private MeshFlat mMesh;
@@ -67,11 +64,6 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
       mOldCube = null;
       mNewCube = null;
 
-      mTempCurrent     = new Static4D(0,0,0,1);
-      mTempAccumulated = new Static4D(0,0,0,1);
-      mQuatCurrent     = new Static4D(0,0,0,1);
-      mQuatAccumulated = new Static4D(0,0,0,1);
-
       mScreenWidth = mScreenHeight = 0;
       mScrambleCubeNum = 0;
 
@@ -84,8 +76,7 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
 
       mCanRotate   = true;
       mCanDrag     = true;
-      mCanScramble = true;
-      mCanSolve    = true;
+      mCanUI       = true;
 
       mEffectID = new long[BaseEffect.Type.LENGTH];
 
@@ -105,13 +96,13 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
       if( mFinishDragCurrent )
         {
         mFinishDragCurrent = false;
-        mQuatCurrent.set(mTempCurrent);
+        mView.setQuatCurrent();
         }
 
       if( mFinishDragAccumulated )
         {
         mFinishDragAccumulated = false;
-        mQuatAccumulated.set(mTempAccumulated);
+        mView.setQuatAccumulated();
         }
 
       if( mFinishRotation )
@@ -142,8 +133,7 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
         mSolveCube   = false;
         mCanDrag     = false;
         mCanRotate   = false;
-        mCanScramble = false;
-        mCanSolve    = false;
+        mCanUI       = false;
         doEffectNow(1);
         }
 
@@ -152,8 +142,7 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
         mScrambleCube = false;
         mCanDrag      = false;
         mCanRotate    = false;
-        mCanScramble  = false;
-        mCanSolve     = false;
+        mCanUI        = false;
         doEffectNow(2);
         }
       }
@@ -201,28 +190,22 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
 
    public void effectFinished(final long effectID)
      {
-     if(      effectID == mRotationFinishedID )
+     if( effectID == mRotationFinishedID )
        {
        mRemoveRotation = true;
        }
-     else if( effectID == mEffectID[0] )
-       {
-       mCanRotate   = true;
-       mCanDrag     = true;
-       }
-     else if( effectID == mEffectID[1] )
-       {
-       mCanRotate   = true;
-       mCanDrag     = true;
-       mCanSolve    = true;
-       mCanScramble = true;
-       }
-     else if( effectID == mEffectID[2] )
+     else
        {
-       mCanRotate   = true;
-       mCanDrag     = true;
-       mCanSolve    = true;
-       mCanScramble = true;
+       for(int i=0; i<BaseEffect.Type.LENGTH; i++)
+         {
+         if( effectID == mEffectID[i] )
+           {
+           mCanRotate   = true;
+           mCanDrag     = true;
+           mCanUI       = true;
+           break;
+           }
+         }
        }
      }
 
@@ -271,7 +254,7 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
 
    void scrambleCube(int num)
      {
-     if( mCanScramble )
+     if( mCanUI )
        {
        mScrambleCube = true;
        mScrambleCubeNum = num;
@@ -282,7 +265,7 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
 
    void solveCube()
      {
-     if( mCanSolve )
+     if( mCanUI )
        {
        mSolveCube = true;
        }
@@ -298,7 +281,7 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
      DistortedTexture texture = new DistortedTexture(TEXTURE_SIZE,TEXTURE_SIZE);
      DistortedEffects effects = new DistortedEffects();
 
-     mNewCube = new RubikCube(newSize, mQuatCurrent, mQuatAccumulated, texture, mMesh, effects);
+     mNewCube = new RubikCube(newSize, mView.getQuatCurrent(), mView.getQuatAccumulated(), texture, mMesh, effects);
      mNewCube.createTexture();
 
      if( mScreenWidth!=0 )
@@ -371,17 +354,15 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-   void setQuatCurrent(Static4D current)
+   void setQuatCurrentOnNextRender()
      {
-     mTempCurrent.set(current);
      mFinishDragCurrent = true;
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-   void setQuatAccumulated(Static4D accumulated)
+   void setQuatAccumulatedOnNextRender()
      {
-     mTempAccumulated.set(accumulated);
      mFinishDragAccumulated = true;
      }
 }
diff --git a/src/main/java/org/distorted/magic/RubikSurfaceView.java b/src/main/java/org/distorted/magic/RubikSurfaceView.java
index 716d0724..b495520e 100644
--- a/src/main/java/org/distorted/magic/RubikSurfaceView.java
+++ b/src/main/java/org/distorted/magic/RubikSurfaceView.java
@@ -59,8 +59,10 @@ class RubikSurfaceView extends GLSurfaceView
     private int mScreenWidth, mScreenHeight, mScreenMin;
     private float mCameraDistance;
 
-    private static Static4D mQuatCurrent    =new Static4D(0,0,0,1);
-    private static Static4D mQuatAccumulated=new Static4D(-0.25189602f,0.3546389f,0.009657208f,0.90038127f);
+    private static Static4D mQuatCurrent    = new Static4D(0,0,0,1);
+    private static Static4D mQuatAccumulated= new Static4D(-0.25189602f,0.3546389f,0.009657208f,0.90038127f);
+    private static Static4D mTempCurrent    = new Static4D(0,0,0,1);
+    private static Static4D mTempAccumulated= new Static4D(0,0,0,1);
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -81,7 +83,6 @@ class RubikSurfaceView extends GLSurfaceView
         mScreenWidth = mScreenHeight = mScreenMin = 0;
 
         mRenderer = new RubikRenderer(this);
-        mRenderer.setQuatAccumulated(mQuatAccumulated);
 
         final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
         final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
@@ -120,8 +121,8 @@ class RubikSurfaceView extends GLSurfaceView
                                        break;
          case MotionEvent.ACTION_MOVE: if( mDragging )
                                          {
-                                         mQuatCurrent.set(quatFromDrag(mX-x,mY-y));
-                                         mRenderer.setQuatCurrent(mQuatCurrent);
+                                         mTempCurrent.set(quatFromDrag(mX-x,mY-y));
+                                         mRenderer.setQuatCurrentOnNextRender();
                                          }
                                        if( mBeginningRotation )
                                          {
@@ -141,10 +142,10 @@ class RubikSurfaceView extends GLSurfaceView
                                        break;
          case MotionEvent.ACTION_UP  : if( mDragging )
                                          {
-                                         mQuatAccumulated.set(quatMultiply(mQuatCurrent, mQuatAccumulated));
-                                         mQuatCurrent.set(0f, 0f, 0f, 1f);
-                                         mRenderer.setQuatCurrent(mQuatCurrent);
-                                         mRenderer.setQuatAccumulated(mQuatAccumulated);
+                                         mTempAccumulated.set(quatMultiply(mQuatCurrent, mQuatAccumulated));
+                                         mTempCurrent.set(0f, 0f, 0f, 1f);
+                                         mRenderer.setQuatCurrentOnNextRender();
+                                         mRenderer.setQuatAccumulatedOnNextRender();
                                          }
 
                                        if( mContinuingRotation )
@@ -158,6 +159,34 @@ class RubikSurfaceView extends GLSurfaceView
       return true;
       }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+    void setQuatAccumulated()
+      {
+      mQuatAccumulated.set(mTempAccumulated);
+      }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+    void setQuatCurrent()
+      {
+      mQuatCurrent.set(mTempCurrent);
+      }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+    Static4D getQuatAccumulated()
+      {
+      return mQuatAccumulated;
+      }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+    Static4D getQuatCurrent()
+      {
+      return mQuatCurrent;
+      }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
     RubikRenderer getRenderer()