commit 582617c19eba88c42b5b10f84deee3ad66688bc1
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Thu Jun 3 22:46:22 2021 +0200

    Hide more stuff in the TwistyObject class.

diff --git a/src/main/java/org/distorted/objects/Cubit.java b/src/main/java/org/distorted/objects/Cubit.java
index 33f1f1c7..a8e044f6 100644
--- a/src/main/java/org/distorted/objects/Cubit.java
+++ b/src/main/java/org/distorted/objects/Cubit.java
@@ -39,7 +39,7 @@ class Cubit
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Cubit(TwistyObject parent, float[] position)
+  Cubit(TwistyObject parent, float[] position, int numAxis)
     {
     mQuatIndex= 0;
     mParent   = parent;
@@ -54,7 +54,7 @@ class Cubit
       mCurrentPosition[i] = position[i];
       }
 
-    mNumAxis     = mParent.ROTATION_AXIS.length;
+    mNumAxis     = numAxis;
     mRotationRow = new int[mNumAxis];
     computeRotationRow();
     }
diff --git a/src/main/java/org/distorted/objects/TwistyBandagedFused.java b/src/main/java/org/distorted/objects/TwistyBandagedFused.java
index 5be927d5..80e69fba 100644
--- a/src/main/java/org/distorted/objects/TwistyBandagedFused.java
+++ b/src/main/java/org/distorted/objects/TwistyBandagedFused.java
@@ -94,11 +94,11 @@ class TwistyBandagedFused extends TwistyBandagedAbstract
     {
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
diff --git a/src/main/java/org/distorted/objects/TwistyCube.java b/src/main/java/org/distorted/objects/TwistyCube.java
index b5894624..92219f61 100644
--- a/src/main/java/org/distorted/objects/TwistyCube.java
+++ b/src/main/java/org/distorted/objects/TwistyCube.java
@@ -298,11 +298,11 @@ class TwistyCube extends TwistyObject
     {
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
diff --git a/src/main/java/org/distorted/objects/TwistyDiamond.java b/src/main/java/org/distorted/objects/TwistyDiamond.java
index 328b57b8..bc3ff867 100644
--- a/src/main/java/org/distorted/objects/TwistyDiamond.java
+++ b/src/main/java/org/distorted/objects/TwistyDiamond.java
@@ -521,11 +521,11 @@ public class TwistyDiamond extends TwistyObject
     {
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
diff --git a/src/main/java/org/distorted/objects/TwistyDino4.java b/src/main/java/org/distorted/objects/TwistyDino4.java
index 1f0fbf52..de47bf6e 100644
--- a/src/main/java/org/distorted/objects/TwistyDino4.java
+++ b/src/main/java/org/distorted/objects/TwistyDino4.java
@@ -108,12 +108,12 @@ public class TwistyDino4 extends TwistyDino
     {
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       scramble[num][1] = (scramble[num][0]==1 || scramble[num][0]==2) ? 0:2;
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       scramble[num][1] = scramble[num-1][0]+scramble[num][0]==3 ? 2-scramble[num-1][1] : scramble[num-1][1];
       }
diff --git a/src/main/java/org/distorted/objects/TwistyDino6.java b/src/main/java/org/distorted/objects/TwistyDino6.java
index d805b200..4465cabb 100644
--- a/src/main/java/org/distorted/objects/TwistyDino6.java
+++ b/src/main/java/org/distorted/objects/TwistyDino6.java
@@ -70,12 +70,12 @@ public class TwistyDino6 extends TwistyDino
     {
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       scramble[num][1] = rnd.nextFloat()<=0.5f ? 0:2;
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       scramble[num][1] = scramble[num-1][0]+scramble[num][0]==3 ? 2-scramble[num-1][1] : scramble[num-1][1];
       }
diff --git a/src/main/java/org/distorted/objects/TwistyHelicopter.java b/src/main/java/org/distorted/objects/TwistyHelicopter.java
index f0ace352..dda1c219 100644
--- a/src/main/java/org/distorted/objects/TwistyHelicopter.java
+++ b/src/main/java/org/distorted/objects/TwistyHelicopter.java
@@ -414,11 +414,11 @@ public class TwistyHelicopter extends TwistyObject
     {
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-2);
+      int newVector = rnd.nextInt(NUM_AXIS -2);
 
       switch(scramble[num-1][0])
         {
diff --git a/src/main/java/org/distorted/objects/TwistyIvy.java b/src/main/java/org/distorted/objects/TwistyIvy.java
index 60b01359..085a03a9 100644
--- a/src/main/java/org/distorted/objects/TwistyIvy.java
+++ b/src/main/java/org/distorted/objects/TwistyIvy.java
@@ -437,11 +437,11 @@ public class TwistyIvy extends TwistyObject
     {
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
diff --git a/src/main/java/org/distorted/objects/TwistyMinx.java b/src/main/java/org/distorted/objects/TwistyMinx.java
index fbbf8bf2..95feeb30 100644
--- a/src/main/java/org/distorted/objects/TwistyMinx.java
+++ b/src/main/java/org/distorted/objects/TwistyMinx.java
@@ -465,11 +465,11 @@ abstract class TwistyMinx extends TwistyObject
 
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
diff --git a/src/main/java/org/distorted/objects/TwistyObject.java b/src/main/java/org/distorted/objects/TwistyObject.java
index 5a75e2ff..5367c7f2 100644
--- a/src/main/java/org/distorted/objects/TwistyObject.java
+++ b/src/main/java/org/distorted/objects/TwistyObject.java
@@ -84,22 +84,22 @@ public abstract class TwistyObject extends DistortedNode
   private static final Static3D CENTER = new Static3D(0,0,0);
   private static final int POST_ROTATION_MILLISEC = 500;
 
-  final Static3D[] ROTATION_AXIS;
   final Static4D[] QUATS;
   final Cubit[] CUBITS;
   final int NUM_FACES;
   final int NUM_TEXTURES;
-  final int NUM_CUBIT_FACES;
-  final int NUM_AXIS;
   final int NUM_CUBITS;
-  final float[] CUTS;
-  final int NUM_CUTS;
+  final int NUM_AXIS;
 
   private static float mInitScreenRatio;
   private static float mObjectScreenRatio = 1.0f;
   private static final float[] mTmp1 = new float[4];
   private static final float[] mTmp2 = new float[4];
 
+  private final int mNumCubitFaces;
+  private final Static3D[] mAxis;
+  private final float[] mCuts;
+  private final int mNumCuts;
   private final int mNodeSize;
   private final float[][] mOrigPos;
   private final Static3D mNodeScale;
@@ -113,16 +113,13 @@ public abstract class TwistyObject extends DistortedNode
   private final Static3D mObjectScale;
   private final int[] mQuatDebug;
   private final float mCameraDist;
+  private final Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;
+  private final DistortedTexture mTexture;
   private int mNumTexRows, mNumTexCols;
   private int mRotRowBitmap;
   private int mRotAxis;
   private MeshBase mMesh;
 
-  Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;
-  DistortedTexture mTexture;
-  MatrixEffectScale mScaleEffect;
-  MatrixEffectQuaternion mQuatEffect;
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   TwistyObject(int numLayers, int realSize, Static4D quat, DistortedTexture nodeTexture, MeshSquare nodeMesh,
@@ -138,17 +135,17 @@ public abstract class TwistyObject extends DistortedNode
     mRealSize = realSize;
     mList = list;
     mOrigPos = getCubitPositions(mNumLayers);
+    mAxis = getRotationAxis();
+    mInitScreenRatio = getScreenRatio();
+    mNumCubitFaces = getNumCubitFaces();
+    mCuts = getCuts(mNumLayers);
+    mNumCuts = mCuts== null ? 0: mCuts.length;
 
     QUATS = getQuats();
     NUM_CUBITS  = mOrigPos.length;
-    ROTATION_AXIS = getRotationAxis();
-    NUM_AXIS = ROTATION_AXIS.length;
-    mInitScreenRatio = getScreenRatio();
     NUM_FACES = getNumFaces();
-    NUM_CUBIT_FACES = getNumCubitFaces();
     NUM_TEXTURES = getNumStickerTypes(mNumLayers)*NUM_FACES;
-    CUTS = getCuts(mNumLayers);
-    NUM_CUTS = CUTS== null ? 0: CUTS.length;
+    NUM_AXIS = mAxis.length;
 
     mQuatDebug = new int[NUM_CUBITS];
 
@@ -168,8 +165,8 @@ public abstract class TwistyObject extends DistortedNode
 
     float scale  = mObjectScreenRatio*mInitScreenRatio*mNodeSize/mRealSize;
     mObjectScale = new Static3D(scale,scale,scale);
-    mScaleEffect = new MatrixEffectScale(mObjectScale);
-    mQuatEffect  = new MatrixEffectQuaternion(quat, CENTER);
+    MatrixEffectScale scaleEffect = new MatrixEffectScale(mObjectScale);
+    MatrixEffectQuaternion quatEffect  = new MatrixEffectQuaternion(quat, CENTER);
 
     MatrixEffectScale nodeScaleEffect = new MatrixEffectScale(mNodeScale);
     nodeEffects.apply(nodeScaleEffect);
@@ -194,8 +191,8 @@ public abstract class TwistyObject extends DistortedNode
       }
 
     mEffects.apply(mRotateEffect);
-    mEffects.apply(mQuatEffect);
-    mEffects.apply(mScaleEffect);
+    mEffects.apply(quatEffect);
+    mEffects.apply(scaleEffect);
 
     // Now postprocessed effects (the glow when you solve an object) require component centers. In
     // order for the effect to be in front of the object, we need to set the center to be behind it.
@@ -259,7 +256,7 @@ public abstract class TwistyObject extends DistortedNode
 
       for(int i=0; i<NUM_CUBITS; i++)
         {
-        CUBITS[i] = new Cubit(this,mOrigPos[i]);
+        CUBITS[i] = new Cubit(this,mOrigPos[i], NUM_AXIS);
         mMesh.setEffectAssociation(i, CUBITS[i].computeAssociation(), 0);
         }
 
@@ -271,7 +268,7 @@ public abstract class TwistyObject extends DistortedNode
 
       for(int i=0; i<NUM_CUBITS; i++)
         {
-        CUBITS[i] = new Cubit(this,mOrigPos[i]);
+        CUBITS[i] = new Cubit(this,mOrigPos[i], NUM_AXIS);
         cubitMesh[i] = createCubitMesh(i,mNumLayers);
         Static3D pos = getPos(mOrigPos[i]);
         cubitMesh[i].apply(new MatrixEffectMove(pos),1,0);
@@ -309,7 +306,7 @@ public abstract class TwistyObject extends DistortedNode
     {
     int ret=0;
     int len = pos.length / 3;
-    Static3D axis = ROTATION_AXIS[rotIndex];
+    Static3D axis = mAxis[rotIndex];
     float axisX = axis.get0();
     float axisY = axis.get1();
     float axisZ = axis.get2();
@@ -326,12 +323,12 @@ public abstract class TwistyObject extends DistortedNode
 
   private int computeRow(float casted)
     {
-    for(int i=0; i<NUM_CUTS; i++)
+    for(int i=0; i<mNumCuts; i++)
       {
-      if( casted<CUTS[i] ) return (1<<i);
+      if( casted<mCuts[i] ) return (1<<i);
       }
 
-    return (1<<NUM_CUTS);
+    return (1<<mNumCuts);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -354,7 +351,7 @@ public abstract class TwistyObject extends DistortedNode
 
   private Static4D makeQuaternion(int axisIndex, int angleInDegrees)
     {
-    Static3D axis = ROTATION_AXIS[axisIndex];
+    Static3D axis = mAxis[axisIndex];
 
     while( angleInDegrees<0 ) angleInDegrees += 360;
     angleInDegrees %= 360;
@@ -511,7 +508,7 @@ public abstract class TwistyObject extends DistortedNode
     int belongsToHowManyFaces = 0;
     int bitmap = (1<<(getNumLayers()-1)) + 1;
 
-    for(int i=0; i<NUM_AXIS; i++)
+    for(int i = 0; i< NUM_AXIS; i++)
       {
       if( (cubit.mRotationRow[i] & bitmap) != 0 ) belongsToHowManyFaces++;
       }
@@ -531,7 +528,7 @@ public abstract class TwistyObject extends DistortedNode
                rotated1.get(mTmp1, 0, 0, 0);
                rotated2.get(mTmp2, 0, 0, 0);
 
-               for(int i=0; i<NUM_AXIS; i++)
+               for(int i = 0; i< NUM_AXIS; i++)
                  {
                  if( (computeRow(mTmp1,i) & computeRow(mTmp2,i) & bitmap) != 0 ) return false;
                  }
@@ -740,9 +737,9 @@ public abstract class TwistyObject extends DistortedNode
 
     for(int cubit=0; cubit<NUM_CUBITS; cubit++)
       {
-      final Static4D[] maps = new Static4D[NUM_CUBIT_FACES];
+      final Static4D[] maps = new Static4D[mNumCubitFaces];
 
-      for(int cubitface=0; cubitface<NUM_CUBIT_FACES; cubitface++)
+      for(int cubitface=0; cubitface<mNumCubitFaces; cubitface++)
         {
         color = getFaceColor(cubit,cubitface,mNumLayers);
         row = (mNumTexRows-1) - color/mNumTexCols;
@@ -750,7 +747,7 @@ public abstract class TwistyObject extends DistortedNode
         maps[cubitface] = new Static4D( col*ratioW, row*ratioH, ratioW, ratioH);
         }
 
-      mMesh.setTextureMap(maps,NUM_CUBIT_FACES*cubit);
+      mMesh.setTextureMap(maps,mNumCubitFaces*cubit);
       }
     }
 
@@ -760,19 +757,19 @@ public abstract class TwistyObject extends DistortedNode
     {
     final float ratioW = 1.0f/mNumTexCols;
     final float ratioH = 1.0f/mNumTexRows;
-    final Static4D[] maps = new Static4D[NUM_CUBIT_FACES];
+    final Static4D[] maps = new Static4D[mNumCubitFaces];
     int row = (mNumTexRows-1) - newColor/mNumTexCols;
     int col = newColor%mNumTexCols;
 
     maps[face] = new Static4D( col*ratioW, row*ratioH, ratioW, ratioH);
-    mMesh.setTextureMap(maps,NUM_CUBIT_FACES*cubit);
+    mMesh.setTextureMap(maps,mNumCubitFaces*cubit);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public synchronized void beginNewRotation(int axis, int row )
     {
-    if( axis<0 || axis>=ROTATION_AXIS.length )
+    if( axis<0 || axis>=NUM_AXIS )
       {
       android.util.Log.e("object", "invalid rotation axis: "+axis);
       return;
@@ -786,7 +783,7 @@ public abstract class TwistyObject extends DistortedNode
     mRotAxis     = axis;
     mRotRowBitmap= computeBitmapFromRow( (1<<row),axis );
     mRotationAngleStatic.set0(0.0f);
-    mRotationAxis.set( ROTATION_AXIS[axis] );
+    mRotationAxis.set( mAxis[axis] );
     mRotationAngle.add(mRotationAngleStatic);
     mRotateEffect.setMeshAssociation( mRotRowBitmap<<(axis* ObjectList.MAX_OBJECT_SIZE) , -1);
     }
@@ -801,7 +798,7 @@ public abstract class TwistyObject extends DistortedNode
       mRotRowBitmap= computeBitmapFromRow( rowBitmap,axis );
 
       mRotationAngleStatic.set0(0.0f);
-      mRotationAxis.set( ROTATION_AXIS[axis] );
+      mRotationAxis.set( mAxis[axis] );
       mRotationAngle.setDuration(durationMillis);
       mRotationAngle.resetToBeginning();
       mRotationAngle.add(new Static1D(0));
@@ -866,9 +863,9 @@ public abstract class TwistyObject extends DistortedNode
     double nearestAngleInRadians = angle*Math.PI/180;
     float sinA =-(float)Math.sin(nearestAngleInRadians*0.5);
     float cosA = (float)Math.cos(nearestAngleInRadians*0.5);
-    float axisX = ROTATION_AXIS[mRotAxis].get0();
-    float axisY = ROTATION_AXIS[mRotAxis].get1();
-    float axisZ = ROTATION_AXIS[mRotAxis].get2();
+    float axisX = mAxis[mRotAxis].get0();
+    float axisY = mAxis[mRotAxis].get1();
+    float axisZ = mAxis[mRotAxis].get2();
     Static4D quat = new Static4D( axisX*sinA, axisY*sinA, axisZ*sinA, cosA);
 
     mRotationAngle.removeAll();
diff --git a/src/main/java/org/distorted/objects/TwistyPyraminx.java b/src/main/java/org/distorted/objects/TwistyPyraminx.java
index ef21d14e..b76bc3d4 100644
--- a/src/main/java/org/distorted/objects/TwistyPyraminx.java
+++ b/src/main/java/org/distorted/objects/TwistyPyraminx.java
@@ -392,11 +392,11 @@ public class TwistyPyraminx extends TwistyObject
 
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
diff --git a/src/main/java/org/distorted/objects/TwistyRedi.java b/src/main/java/org/distorted/objects/TwistyRedi.java
index 02dab9a9..f17da7bf 100644
--- a/src/main/java/org/distorted/objects/TwistyRedi.java
+++ b/src/main/java/org/distorted/objects/TwistyRedi.java
@@ -427,12 +427,12 @@ public class TwistyRedi extends TwistyObject
     {
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       scramble[num][1] = rnd.nextFloat()<=0.5f ? 0:2;
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       scramble[num][1] = (scramble[num-1][0]+scramble[num][0]==3 ? 2-scramble[num-1][1] : scramble[num-1][1]);
       }
diff --git a/src/main/java/org/distorted/objects/TwistyRex.java b/src/main/java/org/distorted/objects/TwistyRex.java
index 935fe371..a1bdecae 100644
--- a/src/main/java/org/distorted/objects/TwistyRex.java
+++ b/src/main/java/org/distorted/objects/TwistyRex.java
@@ -602,11 +602,11 @@ public class TwistyRex extends TwistyObject
     {
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
diff --git a/src/main/java/org/distorted/objects/TwistySkewb.java b/src/main/java/org/distorted/objects/TwistySkewb.java
index a9a49db1..d5d3d998 100644
--- a/src/main/java/org/distorted/objects/TwistySkewb.java
+++ b/src/main/java/org/distorted/objects/TwistySkewb.java
@@ -622,11 +622,11 @@ public class TwistySkewb extends TwistyObject
     {
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
diff --git a/src/main/java/org/distorted/objects/TwistySquare1.java b/src/main/java/org/distorted/objects/TwistySquare1.java
index e18cc25c..3267be9b 100644
--- a/src/main/java/org/distorted/objects/TwistySquare1.java
+++ b/src/main/java/org/distorted/objects/TwistySquare1.java
@@ -45,192 +45,192 @@ class TwistySquare1 extends TwistyObject
   private static final float     X = 3*(2-SQ3)/2;
 
   static final Static3D[] ROT_AXIS = new Static3D[]
-         {
-           new Static3D(0,1,0),
-           new Static3D(COS15,0,SIN15)
-         };
+    {
+      new Static3D(0,1,0),
+      new Static3D(COS15,0,SIN15)
+    };
 
   private static final int[] FACE_COLORS = new int[]
-         {
-           COLOR_YELLOW, COLOR_WHITE,
-           COLOR_BLUE  , COLOR_GREEN,
-           COLOR_RED   , COLOR_ORANGE
-         };
+    {
+      COLOR_YELLOW, COLOR_WHITE,
+      COLOR_BLUE  , COLOR_GREEN,
+      COLOR_RED   , COLOR_ORANGE
+    };
 
   private static final Static4D[] QUATS = new Static4D[]
-         {
-           new Static4D(  0.0f,  0.0f,  0.0f,  1.0f ),
-           new Static4D(  0.0f, SIN15,  0.0f, COS15 ),
-           new Static4D(  0.0f,  0.5f,  0.0f, SQ3/2 ),
-           new Static4D(  0.0f, SQ2/2,  0.0f, SQ2/2 ),
-           new Static4D(  0.0f, SQ3/2,  0.0f,  0.5f ),
-           new Static4D(  0.0f, COS15,  0.0f, SIN15 ),
-           new Static4D(  0.0f,  1.0f,  0.0f,  0.0f ),
-           new Static4D(  0.0f, COS15,  0.0f,-SIN15 ),
-           new Static4D(  0.0f, SQ3/2,  0.0f, -0.5f ),
-           new Static4D(  0.0f, SQ2/2,  0.0f,-SQ2/2 ),
-           new Static4D(  0.0f,  0.5f,  0.0f,-SQ3/2 ),
-           new Static4D(  0.0f, SIN15,  0.0f,-COS15 ),
-
-           new Static4D(  1.0f,  0.0f,  0.0f,  0.0f ),
-           new Static4D( COS15,  0.0f, SIN15,  0.0f ),
-           new Static4D( SQ3/2,  0.0f,  0.5f,  0.0f ),
-           new Static4D( SQ2/2,  0.0f, SQ2/2,  0.0f ),
-           new Static4D(  0.5f,  0.0f, SQ3/2,  0.0f ),
-           new Static4D( SIN15,  0.0f, COS15,  0.0f ),
-           new Static4D(  0.0f,  0.0f,  1.0f,  0.0f ),
-           new Static4D(-SIN15,  0.0f, COS15,  0.0f ),
-           new Static4D( -0.5f,  0.0f, SQ3/2,  0.0f ),
-           new Static4D(-SQ2/2,  0.0f, SQ2/2,  0.0f ),
-           new Static4D(-SQ3/2,  0.0f,  0.5f,  0.0f ),
-           new Static4D(-COS15,  0.0f, SIN15,  0.0f )
-         };
+    {
+      new Static4D(  0.0f,  0.0f,  0.0f,  1.0f ),
+      new Static4D(  0.0f, SIN15,  0.0f, COS15 ),
+      new Static4D(  0.0f,  0.5f,  0.0f, SQ3/2 ),
+      new Static4D(  0.0f, SQ2/2,  0.0f, SQ2/2 ),
+      new Static4D(  0.0f, SQ3/2,  0.0f,  0.5f ),
+      new Static4D(  0.0f, COS15,  0.0f, SIN15 ),
+      new Static4D(  0.0f,  1.0f,  0.0f,  0.0f ),
+      new Static4D(  0.0f, COS15,  0.0f,-SIN15 ),
+      new Static4D(  0.0f, SQ3/2,  0.0f, -0.5f ),
+      new Static4D(  0.0f, SQ2/2,  0.0f,-SQ2/2 ),
+      new Static4D(  0.0f,  0.5f,  0.0f,-SQ3/2 ),
+      new Static4D(  0.0f, SIN15,  0.0f,-COS15 ),
+
+      new Static4D(  1.0f,  0.0f,  0.0f,  0.0f ),
+      new Static4D( COS15,  0.0f, SIN15,  0.0f ),
+      new Static4D( SQ3/2,  0.0f,  0.5f,  0.0f ),
+      new Static4D( SQ2/2,  0.0f, SQ2/2,  0.0f ),
+      new Static4D(  0.5f,  0.0f, SQ3/2,  0.0f ),
+      new Static4D( SIN15,  0.0f, COS15,  0.0f ),
+      new Static4D(  0.0f,  0.0f,  1.0f,  0.0f ),
+      new Static4D(-SIN15,  0.0f, COS15,  0.0f ),
+      new Static4D( -0.5f,  0.0f, SQ3/2,  0.0f ),
+      new Static4D(-SQ2/2,  0.0f, SQ2/2,  0.0f ),
+      new Static4D(-SQ3/2,  0.0f,  0.5f,  0.0f ),
+      new Static4D(-COS15,  0.0f, SIN15,  0.0f )
+    };
 
   private static final int[] QUAT_NUMBER = new int[]
-         {
-           0, 6,
-           0, 9, 6, 3, 18, 15, 12, 21,
-           0, 9, 6, 3, 15, 12, 21, 18
-         };
+    {
+      0, 6,
+      0, 9, 6, 3, 18, 15, 12, 21,
+      0, 9, 6, 3, 15, 12, 21, 18
+    };
 
   // centers of the 2 middles + 8 edges + 8 corners
   private static final float[][] CENTERS = new float[][]
-         {
-             { 1.5f, 0.0f, 0.0f },
-             {-1.5f, 0.0f, 0.0f },
-
-             { 0.0f, 1.0f, 1.5f },
-             { 1.5f, 1.0f, 0.0f },
-             { 0.0f, 1.0f,-1.5f },
-             {-1.5f, 1.0f, 0.0f },
-             { 0.0f,-1.0f, 1.5f },
-             { 1.5f,-1.0f, 0.0f },
-             { 0.0f,-1.0f,-1.5f },
-             {-1.5f,-1.0f, 0.0f },
-
-             { 1.5f, 1.0f, 1.5f },
-             { 1.5f, 1.0f,-1.5f },
-             {-1.5f, 1.0f,-1.5f },
-             {-1.5f, 1.0f, 1.5f },
-             { 1.5f,-1.0f, 1.5f },
-             { 1.5f,-1.0f,-1.5f },
-             {-1.5f,-1.0f,-1.5f },
-             {-1.5f,-1.0f, 1.5f },
-         };
+    {
+      { 1.5f, 0.0f, 0.0f },
+      {-1.5f, 0.0f, 0.0f },
+
+      { 0.0f, 1.0f, 1.5f },
+      { 1.5f, 1.0f, 0.0f },
+      { 0.0f, 1.0f,-1.5f },
+      {-1.5f, 1.0f, 0.0f },
+      { 0.0f,-1.0f, 1.5f },
+      { 1.5f,-1.0f, 0.0f },
+      { 0.0f,-1.0f,-1.5f },
+      {-1.5f,-1.0f, 0.0f },
+
+      { 1.5f, 1.0f, 1.5f },
+      { 1.5f, 1.0f,-1.5f },
+      {-1.5f, 1.0f,-1.5f },
+      {-1.5f, 1.0f, 1.5f },
+      { 1.5f,-1.0f, 1.5f },
+      { 1.5f,-1.0f,-1.5f },
+      {-1.5f,-1.0f,-1.5f },
+      {-1.5f,-1.0f, 1.5f },
+    };
 
   private static final double[][] VERTICES_MIDDLE = new double[][]
-          {
-              { -1.5-X, 0.5, 1.5 },
-              {    0.0, 0.5, 1.5 },
-              {    0.0, 0.5,-1.5 },
-              { -1.5+X, 0.5,-1.5 },
-              { -1.5-X,-0.5, 1.5 },
-              {    0.0,-0.5, 1.5 },
-              {    0.0,-0.5,-1.5 },
-              { -1.5+X,-0.5,-1.5 }
-          };
+    {
+      { -1.5-X, 0.5, 1.5 },
+      {    0.0, 0.5, 1.5 },
+      {    0.0, 0.5,-1.5 },
+      { -1.5+X, 0.5,-1.5 },
+      { -1.5-X,-0.5, 1.5 },
+      {    0.0,-0.5, 1.5 },
+      {    0.0,-0.5,-1.5 },
+      { -1.5+X,-0.5,-1.5 }
+    };
 
   private static final int[][] VERT_INDEXES_MIDDLE = new int[][]
-          {
-              {0,1,2,3},   // counterclockwise!
-              {4,5,6,7},
-              {4,5,1,0},
-              {5,6,2,1},
-              {6,7,3,2},
-              {7,4,0,3}
-          };
+    {
+      {0,1,2,3},   // counterclockwise!
+      {4,5,6,7},
+      {4,5,1,0},
+      {5,6,2,1},
+      {6,7,3,2},
+      {7,4,0,3}
+    };
 
   private static final double[][] VERTICES_EDGE = new double[][]
-          {
-              { -X, 0.5, 0.0 },
-              { +X, 0.5, 0.0 },
-              {0.0, 0.5,-1.5 },
-              { -X,-0.5, 0.0 },
-              { +X,-0.5, 0.0 },
-              {0.0,-0.5,-1.5 },
-          };
+    {
+      { -X, 0.5, 0.0 },
+      { +X, 0.5, 0.0 },
+      {0.0, 0.5,-1.5 },
+      { -X,-0.5, 0.0 },
+      { +X,-0.5, 0.0 },
+      {0.0,-0.5,-1.5 },
+    };
 
   private static final int[][] VERT_INDEXES_EDGE = new int[][]
-          {
-              {0,1,2},   // counterclockwise!
-              {3,4,5},
-              {3,4,1,0},
-              {4,5,2,1},
-              {5,3,0,2}
-          };
+    {
+      {0,1,2},   // counterclockwise!
+      {3,4,5},
+      {3,4,1,0},
+      {4,5,2,1},
+      {5,3,0,2}
+    };
 
   private static final double[][] VERTICES_CORNER = new double[][]
-          {
-              { X-1.5, 0.5,  0.0 },
-              {   0.0, 0.5,  0.0 },
-              {   0.0, 0.5,X-1.5 },
-              {  -1.5, 0.5, -1.5 },
-              { X-1.5,-0.5,  0.0 },
-              {   0.0,-0.5,  0.0 },
-              {   0.0,-0.5,X-1.5 },
-              {  -1.5,-0.5, -1.5 }
-          };
+    {
+      { X-1.5, 0.5,  0.0 },
+      {   0.0, 0.5,  0.0 },
+      {   0.0, 0.5,X-1.5 },
+      {  -1.5, 0.5, -1.5 },
+      { X-1.5,-0.5,  0.0 },
+      {   0.0,-0.5,  0.0 },
+      {   0.0,-0.5,X-1.5 },
+      {  -1.5,-0.5, -1.5 }
+    };
 
   private static final int[][] VERT_INDEXES_CORNER = new int[][]
-          {
-              {0,1,2,3},   // counterclockwise!
-              {4,5,6,7},
-              {4,5,1,0},
-              {5,6,2,1},
-              {7,4,0,3},
-              {6,7,3,2}
-          };
+    {
+      {0,1,2,3},   // counterclockwise!
+      {4,5,6,7},
+      {4,5,1,0},
+      {5,6,2,1},
+      {7,4,0,3},
+      {6,7,3,2}
+    };
 
   private static final float[][] STICKERS = new float[][]
-          {
-              { -0.5f, -0.26289170f, 0.5f, -0.26289170f, 0.5f, 0.26289170f, -0.5f, 0.26289170f }, // middle front
-              { -0.5f, -0.16666667f, 0.5f, -0.16666667f, 0.5f, 0.16666667f, -0.5f, 0.16666667f }, // middle right
-              { -0.5f, -0.45534182f, 0.5f, -0.45534182f, 0.5f, 0.45534182f, -0.5f, 0.45534182f }, // middle back
-              { -0.20096192f, -0.25f, 0.20096192f, -0.25f, 0.0f, 0.5f },                          // edge top
-              { -0.40192384f, -0.5f, 0.40192384f, -0.5f, 0.40192384f, 0.5f, -0.40192384f, 0.5f }, // edge face
-              { -0.2637079f, -0.38185397f, 0.38185397f, -0.38185397f, 0.38185397f, 0.2637079f, -0.5f, 0.5f } // corner top
-          };
+    {
+      { -0.5f, -0.26289170f, 0.5f, -0.26289170f, 0.5f, 0.26289170f, -0.5f, 0.26289170f }, // middle front
+      { -0.5f, -0.16666667f, 0.5f, -0.16666667f, 0.5f, 0.16666667f, -0.5f, 0.16666667f }, // middle right
+      { -0.5f, -0.45534182f, 0.5f, -0.45534182f, 0.5f, 0.45534182f, -0.5f, 0.45534182f }, // middle back
+      { -0.20096192f, -0.25f, 0.20096192f, -0.25f, 0.0f, 0.5f },                          // edge top
+      { -0.40192384f, -0.5f, 0.40192384f, -0.5f, 0.40192384f, 0.5f, -0.40192384f, 0.5f }, // edge face
+      { -0.2637079f, -0.38185397f, 0.38185397f, -0.38185397f, 0.38185397f, 0.2637079f, -0.5f, 0.5f } // corner top
+    };
 
   private static final int NUM_ST = STICKERS.length;
 
   private static final int[][] mStickerType = new int[][]
-         {
-           {  NUM_ST,NUM_ST,0,     1,     2,NUM_ST },
-           {       3,NUM_ST,4,NUM_ST,NUM_ST,NUM_ST },
-           {       5,NUM_ST,2,     2,NUM_ST,NUM_ST }
-         };
+    {
+      {  NUM_ST,NUM_ST,0,     1,     2,NUM_ST },
+      {       3,NUM_ST,4,NUM_ST,NUM_ST,NUM_ST },
+      {       5,NUM_ST,2,     2,NUM_ST,NUM_ST }
+    };
 
   // YELLOW 0 WHITE 1 BLUE 2 GREEN 3 RED 4 ORANGE 5
   private static final int[][] mStickerColor = new int[][]
-         {
-           { 0, 0, 4, 0, 5, 0 },
-           { 0, 0, 5, 1, 4, 0 },
-
-           { 2, 0, 4, 0, 0, 0 },
-           { 2, 0, 0, 0, 0, 0 },
-           { 2, 0, 5, 0, 0, 0 },
-           { 2, 0, 1, 0, 0, 0 },
-           { 3, 0, 4, 0, 0, 0 },
-           { 3, 0, 0, 0, 0, 0 },
-           { 3, 0, 5, 0, 0, 0 },
-           { 3, 0, 1, 0, 0, 0 },
-
-           { 2, 0, 4, 0, 0, 0 },
-           { 2, 0, 0, 5, 0, 0 },
-           { 2, 0, 5, 1, 0, 0 },
-           { 2, 0, 1, 4, 0, 0 },
-           { 3, 0, 0, 4, 0, 0 },
-           { 3, 0, 5, 0, 0, 0 },
-           { 3, 0, 1, 5, 0, 0 },
-           { 3, 0, 4, 1, 0, 0 },
-         };
+    {
+      { 0, 0, 4, 0, 5, 0 },
+      { 0, 0, 5, 1, 4, 0 },
+
+      { 2, 0, 4, 0, 0, 0 },
+      { 2, 0, 0, 0, 0, 0 },
+      { 2, 0, 5, 0, 0, 0 },
+      { 2, 0, 1, 0, 0, 0 },
+      { 3, 0, 4, 0, 0, 0 },
+      { 3, 0, 0, 0, 0, 0 },
+      { 3, 0, 5, 0, 0, 0 },
+      { 3, 0, 1, 0, 0, 0 },
+
+      { 2, 0, 4, 0, 0, 0 },
+      { 2, 0, 0, 5, 0, 0 },
+      { 2, 0, 5, 1, 0, 0 },
+      { 2, 0, 1, 4, 0, 0 },
+      { 3, 0, 0, 4, 0, 0 },
+      { 3, 0, 5, 0, 0, 0 },
+      { 3, 0, 1, 5, 0, 0 },
+      { 3, 0, 4, 1, 0, 0 },
+    };
 
   private static MeshBase[] mMeshes;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  TwistySquare1(int size, Static4D quat, DistortedTexture texture,
-                MeshSquare mesh, DistortedEffects effects, int[][] moves, Resources res, int scrWidth)
+  TwistySquare1(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh,
+                DistortedEffects effects, int[][] moves, Resources res, int scrWidth)
     {
     super(size, size, quat, texture, mesh, effects, moves, ObjectList.SQU1, res, scrWidth);
     }
@@ -389,21 +389,6 @@ class TwistySquare1 extends TwistyObject
     return FACE_COLORS.length;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// TODO
-
-  float[] getCuts(int numLayers)
-    {
-    float[] cuts = new float[numLayers-1];
-
-    for(int i=0; i<numLayers-1; i++)
-      {
-      cuts[i] = (2-numLayers)*0.5f + i;
-      }
-
-    return cuts;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   int getNumStickerTypes(int numLayers)
@@ -445,6 +430,21 @@ class TwistySquare1 extends TwistyObject
     return 1.0f;
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// TODO
+
+  float[] getCuts(int numLayers)
+    {
+    float[] cuts = new float[numLayers-1];
+
+    for(int i=0; i<numLayers-1; i++)
+      {
+      cuts[i] = (2-numLayers)*0.5f + i;
+      }
+
+    return cuts;
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
@@ -468,11 +468,11 @@ class TwistySquare1 extends TwistyObject
     {
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
diff --git a/src/main/java/org/distorted/objects/TwistyUltimate.java b/src/main/java/org/distorted/objects/TwistyUltimate.java
index c8fc6079..b3c3a1c6 100644
--- a/src/main/java/org/distorted/objects/TwistyUltimate.java
+++ b/src/main/java/org/distorted/objects/TwistyUltimate.java
@@ -445,11 +445,11 @@ class TwistyUltimate extends TwistyObject
     {
     if( num==0 )
       {
-      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
+      scramble[num][0] = rnd.nextInt(NUM_AXIS);
       }
     else
       {
-      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);
+      int newVector = rnd.nextInt(NUM_AXIS -1);
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }