commit e6cf72832b7c8139a22167e1fd3bdb9a23e3a674
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Thu Mar 18 09:48:05 2021 +0100

    Change the Cubit center from a Static3D to a float[].
    The point: now we can have more than one center, and bandaged objects need more than one, because in this way they are going to fill up their RotationRow bitmaps.

diff --git a/src/main/java/org/distorted/objects/Cubit.java b/src/main/java/org/distorted/objects/Cubit.java
index 8b202e63..33f1f1c7 100644
--- a/src/main/java/org/distorted/objects/Cubit.java
+++ b/src/main/java/org/distorted/objects/Cubit.java
@@ -21,7 +21,6 @@ package org.distorted.objects;
 
 import android.content.SharedPreferences;
 
-import org.distorted.library.type.Static3D;
 import org.distorted.library.type.Static4D;
 import org.distorted.main.RubikSurfaceView;
 
@@ -29,26 +28,31 @@ import org.distorted.main.RubikSurfaceView;
 
 class Cubit
   {
-  private final Static3D mOrigPosition;
-  private final Static3D mCurrentPosition;
+  private final float[] mOrigPosition;
+  private final float[] mCurrentPosition;
   private TwistyObject mParent;
   private final int mNumAxis;
+  private final int mLen;
 
   int mQuatIndex;
   int[] mRotationRow;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Cubit(TwistyObject parent, Static3D position)
+  Cubit(TwistyObject parent, float[] position)
     {
-    float x = position.get0();
-    float y = position.get1();
-    float z = position.get2();
+    mQuatIndex= 0;
+    mParent   = parent;
+    mLen      = position.length;
 
-    mParent          = parent;
-    mOrigPosition    = new Static3D(x,y,z);
-    mCurrentPosition = new Static3D(x,y,z);
-    mQuatIndex       = 0;
+    mOrigPosition    = new float[mLen];
+    mCurrentPosition = new float[mLen];
+
+    for(int i=0; i<mLen; i++)
+      {
+      mOrigPosition[i]    = position[i];
+      mCurrentPosition[i] = position[i];
+      }
 
     mNumAxis     = mParent.ROTATION_AXIS.length;
     mRotationRow = new int[mNumAxis];
@@ -113,19 +117,15 @@ class Cubit
 
   private void computeRotationRow()
     {
-    float x = mCurrentPosition.get0();
-    float y = mCurrentPosition.get1();
-    float z = mCurrentPosition.get2();
-
     for(int i=0; i<mNumAxis; i++)
       {
-      mRotationRow[i] = mParent.computeRow(x,y,z,i);
+      mRotationRow[i] = mParent.computeRow(mCurrentPosition,i);
       }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Static3D getOrigPosition()
+  float[] getOrigPosition()
     {
     return mOrigPosition;
     }
@@ -134,19 +134,21 @@ class Cubit
 
   void modifyCurrentPosition(Static4D quat)
     {
-    float cubitCenterX = mCurrentPosition.get0();
-    float cubitCenterY = mCurrentPosition.get1();
-    float cubitCenterZ = mCurrentPosition.get2();
+    Static4D cubitCenter;
+    Static4D rotatedCenter;
+    int len = mLen/3;
 
-    Static4D cubitCenter =  new Static4D(cubitCenterX, cubitCenterY, cubitCenterZ, 0);
-    Static4D rotatedCenter = RubikSurfaceView.rotateVectorByQuat( cubitCenter, quat);
+    for(int i=0; i<len; i++)
+      {
+      cubitCenter =  new Static4D(mCurrentPosition[3*i], mCurrentPosition[3*i+1], mCurrentPosition[3*i+2], 0);
+      rotatedCenter = RubikSurfaceView.rotateVectorByQuat( cubitCenter, quat);
 
-    float rotatedX = rotatedCenter.get0();
-    float rotatedY = rotatedCenter.get1();
-    float rotatedZ = rotatedCenter.get2();
+      mCurrentPosition[3*i  ] = rotatedCenter.get0();
+      mCurrentPosition[3*i+1] = rotatedCenter.get1();
+      mCurrentPosition[3*i+2] = rotatedCenter.get2();
 
-    mCurrentPosition.set(rotatedX, rotatedY, rotatedZ);
-    mParent.clampPos(mCurrentPosition);
+      mParent.clampPos(mCurrentPosition, 3*i);
+      }
 
     computeRotationRow();
     }
@@ -170,7 +172,7 @@ class Cubit
 
   void savePreferences(SharedPreferences.Editor editor)
     {
-    String number = mOrigPosition.get0()+"_"+mOrigPosition.get1()+"_"+mOrigPosition.get2();
+    String number = mOrigPosition[0]+"_"+mOrigPosition[1]+"_"+mOrigPosition[2];
     editor.putInt("q_"+number, mQuatIndex);
     }
 
@@ -178,7 +180,7 @@ class Cubit
 
   int restorePreferences(SharedPreferences preferences)
     {
-    String number = mOrigPosition.get0()+"_"+mOrigPosition.get1()+"_"+mOrigPosition.get2();
+    String number = mOrigPosition[0]+"_"+mOrigPosition[1]+"_"+mOrigPosition[2];
     mQuatIndex = preferences.getInt("q_"+number, 0);
     return mQuatIndex;
     }
@@ -200,7 +202,7 @@ class Cubit
   void solve()
     {
     mQuatIndex = 0;
-    mCurrentPosition.set(mOrigPosition);
+    System.arraycopy(mOrigPosition, 0, mCurrentPosition, 0, mCurrentPosition.length);
     computeRotationRow();
     }
 
@@ -212,12 +214,14 @@ class Cubit
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
+// this is only needed for MODE_REPLACE objects (i.e. - currently - CUBE_3), so it is enough to only
+// take into consideration the first position.
 
   float getDistSquared(float[] point)
     {
-    float dx = mCurrentPosition.get0() - point[0];
-    float dy = mCurrentPosition.get1() - point[1];
-    float dz = mCurrentPosition.get2() - point[2];
+    float dx = mCurrentPosition[0] - point[0];
+    float dy = mCurrentPosition[1] - point[1];
+    float dz = mCurrentPosition[2] - point[2];
 
     return dx*dx + dy*dy + dz*dz;
     }
diff --git a/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java b/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java
index 19c1a2aa..2f7c5551 100644
--- a/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java
+++ b/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java
@@ -193,15 +193,14 @@ abstract class TwistyBandagedAbstract extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Static3D[] getCubitPositions(int size)
+  float[][] getCubitPositions(int size)
     {
     int numCubits = getNumCubits();
-    Static3D[] tmp = new Static3D[numCubits];
+    float[][] tmp = new float[numCubits][];
 
     for(int cubit=0; cubit<numCubits; cubit++)
       {
-      float[] pos = getCubitPosition(cubit);
-      tmp[cubit] = new Static3D(pos[0],pos[1],pos[2]);
+      tmp[cubit] = getCubitPosition(cubit);
       }
 
     return tmp;
diff --git a/src/main/java/org/distorted/objects/TwistyCube.java b/src/main/java/org/distorted/objects/TwistyCube.java
index a6c06031..eae64ba1 100644
--- a/src/main/java/org/distorted/objects/TwistyCube.java
+++ b/src/main/java/org/distorted/objects/TwistyCube.java
@@ -136,10 +136,10 @@ class TwistyCube extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Static3D[] getCubitPositions(int size)
+  float[][] getCubitPositions(int size)
     {
     int numCubits = size>1 ? 6*size*size - 12*size + 8 : 1;
-    Static3D[] tmp = new Static3D[numCubits];
+    float[][] tmp = new float[numCubits][];
 
     float diff = 0.5f*(size-1);
     int currentPosition = 0;
@@ -149,7 +149,7 @@ class TwistyCube extends TwistyObject
         for(int z = 0; z<size; z++)
           if( x==0 || x==size-1 || y==0 || y==size-1 || z==0 || z==size-1 )
             {
-            tmp[currentPosition++] = new Static3D(x-diff,y-diff,z-diff);
+            tmp[currentPosition++] = new float[] {x-diff,y-diff,z-diff};
             }
 
     return tmp;
diff --git a/src/main/java/org/distorted/objects/TwistyDiamond.java b/src/main/java/org/distorted/objects/TwistyDiamond.java
index faf29b0f..543917e4 100644
--- a/src/main/java/org/distorted/objects/TwistyDiamond.java
+++ b/src/main/java/org/distorted/objects/TwistyDiamond.java
@@ -81,23 +81,23 @@ public class TwistyDiamond extends TwistyObject
   private static final float DIST = 0.50f;
 
   // centers of the 6 octahedrons + 8 tetrahedrons ( i.e. of the all 14 cubits)
-  private static final Static3D[] CENTERS = new Static3D[]
+  private static final float[][] CENTERS = new float[][]
          {
-           new Static3D( DIST,          0, DIST ),
-           new Static3D( DIST,          0,-DIST ),
-           new Static3D(-DIST,          0,-DIST ),
-           new Static3D(-DIST,          0, DIST ),
-           new Static3D(    0, DIST*SQ2  ,    0 ),
-           new Static3D(    0,-DIST*SQ2  ,    0 ),
-
-           new Static3D(    0, DIST*SQ2/2, DIST ),
-           new Static3D( DIST, DIST*SQ2/2,    0 ),
-           new Static3D(    0, DIST*SQ2/2,-DIST ),
-           new Static3D(-DIST, DIST*SQ2/2,    0 ),
-           new Static3D(    0,-DIST*SQ2/2, DIST ),
-           new Static3D( DIST,-DIST*SQ2/2,    0 ),
-           new Static3D(    0,-DIST*SQ2/2,-DIST ),
-           new Static3D(-DIST,-DIST*SQ2/2,    0 )
+             { DIST,          0, DIST },
+             { DIST,          0,-DIST },
+             {-DIST,          0,-DIST },
+             {-DIST,          0, DIST },
+             {    0, DIST*SQ2  ,    0 },
+             {    0,-DIST*SQ2  ,    0 },
+
+             {    0, DIST*SQ2/2, DIST },
+             { DIST, DIST*SQ2/2,    0 },
+             {    0, DIST*SQ2/2,-DIST },
+             {-DIST, DIST*SQ2/2,    0 },
+             {    0,-DIST*SQ2/2, DIST },
+             { DIST,-DIST*SQ2/2,    0 },
+             {    0,-DIST*SQ2/2,-DIST },
+             {-DIST,-DIST*SQ2/2,    0 }
          };
 
   // Colors of the faces of cubits. Each cubit has 8 faces
@@ -183,7 +183,7 @@ public class TwistyDiamond extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Static3D[] getCubitPositions(int size)
+  float[][] getCubitPositions(int size)
     {
     return CENTERS;
     }
diff --git a/src/main/java/org/distorted/objects/TwistyDino.java b/src/main/java/org/distorted/objects/TwistyDino.java
index f91f957c..de26b728 100644
--- a/src/main/java/org/distorted/objects/TwistyDino.java
+++ b/src/main/java/org/distorted/objects/TwistyDino.java
@@ -74,20 +74,20 @@ public abstract class TwistyDino extends TwistyObject
          };
 
   // centers of the 12 edges. Must be in the same order like QUATs above.
-  private static final Static3D[] CENTERS = new Static3D[]
+  private static final float[][] CENTERS = new float[][]
          {
-           new Static3D( 0.0f, 1.5f, 1.5f ),
-           new Static3D( 1.5f, 0.0f, 1.5f ),
-           new Static3D( 0.0f,-1.5f, 1.5f ),
-           new Static3D(-1.5f, 0.0f, 1.5f ),
-           new Static3D( 1.5f, 1.5f, 0.0f ),
-           new Static3D( 1.5f,-1.5f, 0.0f ),
-           new Static3D(-1.5f,-1.5f, 0.0f ),
-           new Static3D(-1.5f, 1.5f, 0.0f ),
-           new Static3D( 0.0f, 1.5f,-1.5f ),
-           new Static3D( 1.5f, 0.0f,-1.5f ),
-           new Static3D( 0.0f,-1.5f,-1.5f ),
-           new Static3D(-1.5f, 0.0f,-1.5f )
+             { 0.0f, 1.5f, 1.5f },
+             { 1.5f, 0.0f, 1.5f },
+             { 0.0f,-1.5f, 1.5f },
+             {-1.5f, 0.0f, 1.5f },
+             { 1.5f, 1.5f, 0.0f },
+             { 1.5f,-1.5f, 0.0f },
+             {-1.5f,-1.5f, 0.0f },
+             {-1.5f, 1.5f, 0.0f },
+             { 0.0f, 1.5f,-1.5f },
+             { 1.5f, 0.0f,-1.5f },
+             { 0.0f,-1.5f,-1.5f },
+             {-1.5f, 0.0f,-1.5f }
          };
 
   private static MeshBase mMesh;
@@ -184,7 +184,7 @@ public abstract class TwistyDino extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Static3D[] getCubitPositions(int size)
+  float[][] getCubitPositions(int size)
     {
     return CENTERS;
     }
diff --git a/src/main/java/org/distorted/objects/TwistyHelicopter.java b/src/main/java/org/distorted/objects/TwistyHelicopter.java
index 5e449e4c..5b60eaa0 100644
--- a/src/main/java/org/distorted/objects/TwistyHelicopter.java
+++ b/src/main/java/org/distorted/objects/TwistyHelicopter.java
@@ -97,46 +97,46 @@ public class TwistyHelicopter extends TwistyObject
   private static final float XY_CENTER   = DIST_CORNER/3;
 
   // centers of the 8 corners + 6*4 face triangles ( i.e. of the all 32 cubits)
-  private static final Static3D[] CENTERS = new Static3D[]
+  private static final float[][] CENTERS = new float[][]
          {
-           new Static3D(   DIST_CORNER,   DIST_CORNER,   DIST_CORNER ),
-           new Static3D(   DIST_CORNER,   DIST_CORNER,  -DIST_CORNER ),
-           new Static3D(   DIST_CORNER,  -DIST_CORNER,   DIST_CORNER ),
-           new Static3D(   DIST_CORNER,  -DIST_CORNER,  -DIST_CORNER ),
-           new Static3D(  -DIST_CORNER,   DIST_CORNER,   DIST_CORNER ),
-           new Static3D(  -DIST_CORNER,   DIST_CORNER,  -DIST_CORNER ),
-           new Static3D(  -DIST_CORNER,  -DIST_CORNER,   DIST_CORNER ),
-           new Static3D(  -DIST_CORNER,  -DIST_CORNER,  -DIST_CORNER ),
-
-           new Static3D(   DIST_CENTER,     XY_CENTER,     XY_CENTER ),
-           new Static3D(   DIST_CENTER,     XY_CENTER,    -XY_CENTER ),
-           new Static3D(   DIST_CENTER,    -XY_CENTER,     XY_CENTER ),
-           new Static3D(   DIST_CENTER,    -XY_CENTER,    -XY_CENTER ),
-
-           new Static3D(  -DIST_CENTER,     XY_CENTER,     XY_CENTER ),
-           new Static3D(  -DIST_CENTER,     XY_CENTER,    -XY_CENTER ),
-           new Static3D(  -DIST_CENTER,    -XY_CENTER,     XY_CENTER ),
-           new Static3D(  -DIST_CENTER,    -XY_CENTER,    -XY_CENTER ),
-
-           new Static3D(   XY_CENTER  ,   DIST_CENTER,     XY_CENTER ),
-           new Static3D(   XY_CENTER  ,   DIST_CENTER,    -XY_CENTER ),
-           new Static3D(  -XY_CENTER  ,   DIST_CENTER,     XY_CENTER ),
-           new Static3D(  -XY_CENTER  ,   DIST_CENTER,    -XY_CENTER ),
-
-           new Static3D(   XY_CENTER  ,  -DIST_CENTER,     XY_CENTER ),
-           new Static3D(   XY_CENTER  ,  -DIST_CENTER,    -XY_CENTER ),
-           new Static3D(  -XY_CENTER  ,  -DIST_CENTER,     XY_CENTER ),
-           new Static3D(  -XY_CENTER  ,  -DIST_CENTER,    -XY_CENTER ),
-
-           new Static3D(   XY_CENTER  ,     XY_CENTER,   DIST_CENTER ),
-           new Static3D(   XY_CENTER  ,    -XY_CENTER,   DIST_CENTER ),
-           new Static3D(  -XY_CENTER  ,     XY_CENTER,   DIST_CENTER ),
-           new Static3D(  -XY_CENTER  ,    -XY_CENTER,   DIST_CENTER ),
-
-           new Static3D(   XY_CENTER  ,     XY_CENTER,  -DIST_CENTER ),
-           new Static3D(   XY_CENTER  ,    -XY_CENTER,  -DIST_CENTER ),
-           new Static3D(  -XY_CENTER  ,     XY_CENTER,  -DIST_CENTER ),
-           new Static3D(  -XY_CENTER  ,    -XY_CENTER,  -DIST_CENTER ),
+             {   DIST_CORNER,   DIST_CORNER,   DIST_CORNER },
+             {   DIST_CORNER,   DIST_CORNER,  -DIST_CORNER },
+             {   DIST_CORNER,  -DIST_CORNER,   DIST_CORNER },
+             {   DIST_CORNER,  -DIST_CORNER,  -DIST_CORNER },
+             {  -DIST_CORNER,   DIST_CORNER,   DIST_CORNER },
+             {  -DIST_CORNER,   DIST_CORNER,  -DIST_CORNER },
+             {  -DIST_CORNER,  -DIST_CORNER,   DIST_CORNER },
+             {  -DIST_CORNER,  -DIST_CORNER,  -DIST_CORNER },
+
+             {   DIST_CENTER,     XY_CENTER,     XY_CENTER },
+             {   DIST_CENTER,     XY_CENTER,    -XY_CENTER },
+             {   DIST_CENTER,    -XY_CENTER,     XY_CENTER },
+             {   DIST_CENTER,    -XY_CENTER,    -XY_CENTER },
+
+             {  -DIST_CENTER,     XY_CENTER,     XY_CENTER },
+             {  -DIST_CENTER,     XY_CENTER,    -XY_CENTER },
+             {  -DIST_CENTER,    -XY_CENTER,     XY_CENTER },
+             {  -DIST_CENTER,    -XY_CENTER,    -XY_CENTER },
+
+             {   XY_CENTER  ,   DIST_CENTER,     XY_CENTER },
+             {   XY_CENTER  ,   DIST_CENTER,    -XY_CENTER },
+             {  -XY_CENTER  ,   DIST_CENTER,     XY_CENTER },
+             {  -XY_CENTER  ,   DIST_CENTER,    -XY_CENTER },
+
+             {   XY_CENTER  ,  -DIST_CENTER,     XY_CENTER },
+             {   XY_CENTER  ,  -DIST_CENTER,    -XY_CENTER },
+             {  -XY_CENTER  ,  -DIST_CENTER,     XY_CENTER },
+             {  -XY_CENTER  ,  -DIST_CENTER,    -XY_CENTER },
+
+             {   XY_CENTER  ,     XY_CENTER,   DIST_CENTER },
+             {   XY_CENTER  ,    -XY_CENTER,   DIST_CENTER },
+             {  -XY_CENTER  ,     XY_CENTER,   DIST_CENTER },
+             {  -XY_CENTER  ,    -XY_CENTER,   DIST_CENTER },
+
+             {   XY_CENTER  ,     XY_CENTER,  -DIST_CENTER },
+             {   XY_CENTER  ,    -XY_CENTER,  -DIST_CENTER },
+             {  -XY_CENTER  ,     XY_CENTER,  -DIST_CENTER },
+             {  -XY_CENTER  ,    -XY_CENTER,  -DIST_CENTER },
          };
 
   // Colors of the faces of cubits. Each cubit has 6 faces
@@ -251,7 +251,7 @@ public class TwistyHelicopter extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Static3D[] getCubitPositions(int size)
+  float[][] getCubitPositions(int size)
     {
     return CENTERS;
     }
diff --git a/src/main/java/org/distorted/objects/TwistyIvy.java b/src/main/java/org/distorted/objects/TwistyIvy.java
index 48767382..94b98cc0 100644
--- a/src/main/java/org/distorted/objects/TwistyIvy.java
+++ b/src/main/java/org/distorted/objects/TwistyIvy.java
@@ -156,23 +156,23 @@ public class TwistyIvy extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Static3D[] getCubitPositions(int numLayers)
+  float[][] getCubitPositions(int numLayers)
     {
     final float DIST_CORNER = (numLayers-1)*0.50f;
     final float DIST_CENTER = (numLayers-1)*0.50f;
 
-    final Static3D[] CENTERS = new Static3D[10];
-
-    CENTERS[0] = new Static3D( DIST_CORNER, DIST_CORNER, DIST_CORNER );
-    CENTERS[1] = new Static3D(-DIST_CORNER, DIST_CORNER,-DIST_CORNER );
-    CENTERS[2] = new Static3D(-DIST_CORNER,-DIST_CORNER, DIST_CORNER );
-    CENTERS[3] = new Static3D( DIST_CORNER,-DIST_CORNER,-DIST_CORNER );
-    CENTERS[4] = new Static3D( DIST_CENTER,           0,           0 );
-    CENTERS[5] = new Static3D(-DIST_CENTER,           0,           0 );
-    CENTERS[6] = new Static3D(           0, DIST_CENTER,           0 );
-    CENTERS[7] = new Static3D(           0,-DIST_CENTER,           0 );
-    CENTERS[8] = new Static3D(           0,           0, DIST_CENTER );
-    CENTERS[9] = new Static3D(           0,           0,-DIST_CENTER );
+    final float[][] CENTERS = new float[10][];
+
+    CENTERS[0] = new float[] { DIST_CORNER, DIST_CORNER, DIST_CORNER };
+    CENTERS[1] = new float[] {-DIST_CORNER, DIST_CORNER,-DIST_CORNER };
+    CENTERS[2] = new float[] {-DIST_CORNER,-DIST_CORNER, DIST_CORNER };
+    CENTERS[3] = new float[] { DIST_CORNER,-DIST_CORNER,-DIST_CORNER };
+    CENTERS[4] = new float[] { DIST_CENTER,           0,           0 };
+    CENTERS[5] = new float[] {-DIST_CENTER,           0,           0 };
+    CENTERS[6] = new float[] {           0, DIST_CENTER,           0 };
+    CENTERS[7] = new float[] {           0,-DIST_CENTER,           0 };
+    CENTERS[8] = new float[] {           0,           0, DIST_CENTER };
+    CENTERS[9] = new float[] {           0,           0,-DIST_CENTER };
 
     return CENTERS;
     }
diff --git a/src/main/java/org/distorted/objects/TwistyKilominx.java b/src/main/java/org/distorted/objects/TwistyKilominx.java
index 13a9b763..549ef99a 100644
--- a/src/main/java/org/distorted/objects/TwistyKilominx.java
+++ b/src/main/java/org/distorted/objects/TwistyKilominx.java
@@ -62,7 +62,7 @@ public class TwistyKilominx extends TwistyMinx
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Static3D[] getCubitPositions(int numLayers)
+  float[][] getCubitPositions(int numLayers)
     {
     return CORNERS;
     }
diff --git a/src/main/java/org/distorted/objects/TwistyMegaminx.java b/src/main/java/org/distorted/objects/TwistyMegaminx.java
index b564b187..4de2a721 100644
--- a/src/main/java/org/distorted/objects/TwistyMegaminx.java
+++ b/src/main/java/org/distorted/objects/TwistyMegaminx.java
@@ -125,23 +125,23 @@ public class TwistyMegaminx extends TwistyMinx
       {
       int[] map = mCenterMap[center];
 
-      float x = CORNERS[map[0]].get0() +
-                CORNERS[map[1]].get0() +
-                CORNERS[map[2]].get0() +
-                CORNERS[map[3]].get0() +
-                CORNERS[map[4]].get0() ;
-
-      float y = CORNERS[map[0]].get1() +
-                CORNERS[map[1]].get1() +
-                CORNERS[map[2]].get1() +
-                CORNERS[map[3]].get1() +
-                CORNERS[map[4]].get1() ;
-
-      float z = CORNERS[map[0]].get2() +
-                CORNERS[map[1]].get2() +
-                CORNERS[map[2]].get2() +
-                CORNERS[map[3]].get2() +
-                CORNERS[map[4]].get2() ;
+      float x = CORNERS[map[0]][0] +
+                CORNERS[map[1]][0] +
+                CORNERS[map[2]][0] +
+                CORNERS[map[3]][0] +
+                CORNERS[map[4]][0] ;
+
+      float y = CORNERS[map[0]][1] +
+                CORNERS[map[1]][1] +
+                CORNERS[map[2]][1] +
+                CORNERS[map[3]][1] +
+                CORNERS[map[4]][1] ;
+
+      float z = CORNERS[map[0]][2] +
+                CORNERS[map[1]][2] +
+                CORNERS[map[2]][2] +
+                CORNERS[map[3]][2] +
+                CORNERS[map[4]][2] ;
 
       mCenterCoords[center][0] = x/5;
       mCenterCoords[center][1] = y/5;
@@ -225,12 +225,12 @@ public class TwistyMegaminx extends TwistyMinx
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private void computeCenter(Static3D pos, int center, int numLayers)
+  private float[] computeCenter(int center, int numLayers)
     {
     float[] coords = mCenterCoords[center];
     float A = numLayers/3.0f;
 
-    pos.set( A*coords[0], A*coords[1], A*coords[2] );
+    return new float[] { A*coords[0], A*coords[1], A*coords[2] };
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -248,14 +248,14 @@ public class TwistyMegaminx extends TwistyMinx
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private void computeCorner(Static3D pos, int numCubitsPerCorner, int numLayers, int corner, int part)
+  private float[] computeCorner(int numCubitsPerCorner, int numLayers, int corner, int part)
     {
     float D = numLayers/3.0f;
-    Static3D corn = CORNERS[corner];
+    float[] corn = CORNERS[corner];
 
     if( part==0 )
       {
-      pos.set( corn.get0()*D, corn.get1()*D, corn.get2()*D );
+      return new float[] { corn[0]*D, corn[1]*D, corn[2]*D };
       }
     else
       {
@@ -269,9 +269,11 @@ public class TwistyMegaminx extends TwistyMinx
       int multP = (block % ((numLayers-3)/2)) + 1;
       int multS = (block / ((numLayers-3)/2));
 
-      pos.set( corn.get0()*D + (pri.get0()*multP + sec.get0()*multS)*E,
-               corn.get1()*D + (pri.get1()*multP + sec.get1()*multS)*E,
-               corn.get2()*D + (pri.get2()*multP + sec.get2()*multS)*E );
+      return new float[] {
+                          corn[0]*D + (pri.get0()*multP + sec.get0()*multS)*E,
+                          corn[1]*D + (pri.get1()*multP + sec.get1()*multS)*E,
+                          corn[2]*D + (pri.get2()*multP + sec.get2()*multS)*E
+                         };
       }
     }
 
@@ -285,19 +287,19 @@ public class TwistyMegaminx extends TwistyMinx
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private void computeEdge(Static3D pos, int numLayers, int edge, int part)
+  private float[] computeEdge(int numLayers, int edge, int part)
     {
     float corr = numLayers/3.0f;
 
-    Static3D c1 = CORNERS[ mEdgeMap[edge][0] ];
-    Static3D c2 = CORNERS[ mEdgeMap[edge][1] ];
-    float x = corr*(c1.get0() + c2.get0())/2;
-    float y = corr*(c1.get1() + c2.get1())/2;
-    float z = corr*(c1.get2() + c2.get2())/2;
+    float[] c1 = CORNERS[ mEdgeMap[edge][0] ];
+    float[] c2 = CORNERS[ mEdgeMap[edge][1] ];
+    float x = corr * (c1[0]+c2[0]) / 2;
+    float y = corr * (c1[1]+c2[1]) / 2;
+    float z = corr * (c1[2]+c2[2]) / 2;
 
     if( part==0 )
       {
-      pos.set(x,y,z);
+      return new float[] { x, y, z };
       }
     else
       {
@@ -312,20 +314,20 @@ public class TwistyMegaminx extends TwistyMinx
       float len = (float)Math.sqrt(vX*vX+vY*vY+vZ*vZ);
       float A = mult*corr*(0.5f-MEGA_D)*COS18/((numLayers-1)*0.5f)/len;
 
-      pos.set( x+A*vX, y+A*vY, z+A*vZ );
+      return new float[] { x+A*vX, y+A*vY, z+A*vZ };
       }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Static3D[] getCubitPositions(int numLayers)
+  float[][] getCubitPositions(int numLayers)
     {
     int numCubitsPerCorner = numCubitsPerCorner(numLayers);
     int numCubitsPerEdge   = numCubitsPerEdge(numLayers);
     int numCubits = NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge + NUM_CENTERS;
     int index=0;
 
-    final Static3D[] CENTERS = new Static3D[numCubits];
+    final float[][] CENTERS = new float[numCubits][];
 
     for(int corner=0; corner<NUM_CORNERS; corner++)
       {
@@ -333,8 +335,7 @@ public class TwistyMegaminx extends TwistyMinx
 
       for(int part=0; part<numCubitsPerCorner; part++, index++)
         {
-        CENTERS[index] = new Static3D(0,0,0);
-        computeCorner(CENTERS[index],numCubitsPerCorner,numLayers,corner,part);
+        CENTERS[index] = computeCorner(numCubitsPerCorner,numLayers,corner,part);
         }
       }
 
@@ -342,15 +343,13 @@ public class TwistyMegaminx extends TwistyMinx
       {
       for(int part=0; part<numCubitsPerEdge; part++, index++)
         {
-        CENTERS[index] = new Static3D(0,0,0);
-        computeEdge(CENTERS[index], numLayers, edge, part );
+        CENTERS[index] = computeEdge(numLayers, edge, part );
         }
       }
 
     for(int center=0; center<NUM_CENTERS; center++, index++)
       {
-      CENTERS[index] = new Static3D(0,0,0);
-      computeCenter(CENTERS[index], center, numLayers);
+      CENTERS[index] = computeCenter(center, numLayers);
       }
 
     return CENTERS;
diff --git a/src/main/java/org/distorted/objects/TwistyMinx.java b/src/main/java/org/distorted/objects/TwistyMinx.java
index 8e8944b2..3b23c30e 100644
--- a/src/main/java/org/distorted/objects/TwistyMinx.java
+++ b/src/main/java/org/distorted/objects/TwistyMinx.java
@@ -144,28 +144,28 @@ abstract class TwistyMinx extends TwistyObject
          };
 
   // Coordinates of all 20 corners of a Minx
-  static final Static3D[] CORNERS = new Static3D[]
+  static final float[][] CORNERS = new float[][]
          {
-           new Static3D( 0.0f, 0.5f,   C2),
-           new Static3D( 0.0f, 0.5f,  -C2),
-           new Static3D( 0.0f,-0.5f,   C2),
-           new Static3D( 0.0f,-0.5f,  -C2),
-           new Static3D(   C2, 0.0f, 0.5f),
-           new Static3D(   C2, 0.0f,-0.5f),
-           new Static3D(  -C2, 0.0f, 0.5f),
-           new Static3D(  -C2, 0.0f,-0.5f),
-           new Static3D( 0.5f,   C2, 0.0f),
-           new Static3D( 0.5f,  -C2, 0.0f),
-           new Static3D(-0.5f,   C2, 0.0f),
-           new Static3D(-0.5f,  -C2, 0.0f),
-           new Static3D(   C1,   C1,   C1),
-           new Static3D(   C1,   C1,  -C1),
-           new Static3D(   C1,  -C1,   C1),
-           new Static3D(   C1,  -C1,  -C1),
-           new Static3D(  -C1,   C1,   C1),
-           new Static3D(  -C1,   C1,  -C1),
-           new Static3D(  -C1,  -C1,   C1),
-           new Static3D(  -C1,  -C1,  -C1),
+             { 0.0f, 0.5f,   C2},
+             { 0.0f, 0.5f,  -C2},
+             { 0.0f,-0.5f,   C2},
+             { 0.0f,-0.5f,  -C2},
+             {   C2, 0.0f, 0.5f},
+             {   C2, 0.0f,-0.5f},
+             {  -C2, 0.0f, 0.5f},
+             {  -C2, 0.0f,-0.5f},
+             { 0.5f,   C2, 0.0f},
+             { 0.5f,  -C2, 0.0f},
+             {-0.5f,   C2, 0.0f},
+             {-0.5f,  -C2, 0.0f},
+             {   C1,   C1,   C1},
+             {   C1,   C1,  -C1},
+             {   C1,  -C1,   C1},
+             {   C1,  -C1,  -C1},
+             {  -C1,   C1,   C1},
+             {  -C1,   C1,  -C1},
+             {  -C1,  -C1,   C1},
+             {  -C1,  -C1,  -C1},
          };
 
   static final int[][] mCornerFaceMap =
diff --git a/src/main/java/org/distorted/objects/TwistyObject.java b/src/main/java/org/distorted/objects/TwistyObject.java
index b4209584..a1631017 100644
--- a/src/main/java/org/distorted/objects/TwistyObject.java
+++ b/src/main/java/org/distorted/objects/TwistyObject.java
@@ -98,9 +98,11 @@ public abstract class TwistyObject extends DistortedNode
 
   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 mNodeSize;
-  private final Static3D[] mOrigPos;
+  private final float[][] mOrigPos;
   private final Static3D mNodeScale;
   private final Static4D mQuat;
   private final int mNumLayers, mRealSize;
@@ -214,6 +216,29 @@ public abstract class TwistyObject extends DistortedNode
     setProjection( fov, 0.1f);
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private Static3D getPos(float[] origPos)
+    {
+    int len = origPos.length/3;
+    float sumX = 0.0f;
+    float sumY = 0.0f;
+    float sumZ = 0.0f;
+
+    for(int i=0; i<len; i++)
+      {
+      sumX += origPos[3*i  ];
+      sumY += origPos[3*i+1];
+      sumZ += origPos[3*i+2];
+      }
+
+    sumX /= len;
+    sumY /= len;
+    sumZ /= len;
+
+    return new Static3D(sumX,sumY,sumZ);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   private void createMeshAndCubits(ObjectList list, Resources res)
@@ -252,7 +277,8 @@ public abstract class TwistyObject extends DistortedNode
         {
         CUBITS[i] = new Cubit(this,mOrigPos[i]);
         cubitMesh[i] = createCubitMesh(i,mNumLayers);
-        cubitMesh[i].apply(new MatrixEffectMove(mOrigPos[i]),1,0);
+        Static3D pos = getPos(mOrigPos[i]);
+        cubitMesh[i].apply(new MatrixEffectMove(pos),1,0);
         cubitMesh[i].setEffectAssociation(0, CUBITS[i].computeAssociation(), 0);
         }
 
@@ -283,14 +309,30 @@ public abstract class TwistyObject extends DistortedNode
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int computeRow(float x, float y, float z, int rotIndex)
+  int computeRow(float[] pos, int rotIndex)
     {
+    int ret=0;
+    int len = pos.length / 3;
     Static3D axis = ROTATION_AXIS[rotIndex];
-    float tmp = x*axis.get0() + y*axis.get1() + z*axis.get2();
+    float axisX = axis.get0();
+    float axisY = axis.get1();
+    float axisZ = axis.get2();
+
+    for(int i=0; i<len; i++)
+      {
+      ret |= computeRow(pos[3*i]*axisX + pos[3*i+1]*axisY + pos[3*i+2]*axisZ);
+      }
+
+    return ret;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+  private int computeRow(float casted)
+    {
     for(int i=0; i<NUM_CUTS; i++)
       {
-      if( tmp<CUTS[i] ) return (1<<i);
+      if( casted<CUTS[i] ) return (1<<i);
       }
 
     return (1<<NUM_CUTS);
@@ -369,31 +411,42 @@ public abstract class TwistyObject extends DistortedNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Clamp all rotated positions to one of those original ones to avoid accumulating errors.
 
-  void clampPos(Static3D pos)
+  void clampPos(float[] pos, int offset)
     {
     float currError, minError = Float.MAX_VALUE;
-    int minErrorIndex= -1;
-    float x = pos.get0();
-    float y = pos.get1();
-    float z = pos.get2();
+    int minErrorIndex1 = -1;
+    int minErrorIndex2 = -1;
+
+    float x = pos[offset  ];
+    float y = pos[offset+1];
+    float z = pos[offset+2];
+
     float xo,yo,zo;
 
     for(int i=0; i<NUM_CUBITS; i++)
       {
-      xo = mOrigPos[i].get0();
-      yo = mOrigPos[i].get1();
-      zo = mOrigPos[i].get2();
+      int len = mOrigPos[i].length / 3;
 
-      currError = (xo-x)*(xo-x) + (yo-y)*(yo-y) + (zo-z)*(zo-z);
-
-      if( currError<minError )
+      for(int j=0; j<len; j++)
         {
-        minError = currError;
-        minErrorIndex = i;
+        xo = mOrigPos[i][3*j  ];
+        yo = mOrigPos[i][3*j+1];
+        zo = mOrigPos[i][3*j+2];
+
+        currError = (xo-x)*(xo-x) + (yo-y)*(yo-y) + (zo-z)*(zo-z);
+
+        if( currError<minError )
+          {
+          minError = currError;
+          minErrorIndex1 = i;
+          minErrorIndex2 = j;
+          }
         }
       }
 
-    pos.set( mOrigPos[minErrorIndex] );
+    pos[offset  ] = mOrigPos[minErrorIndex1][3*minErrorIndex2  ];
+    pos[offset+1] = mOrigPos[minErrorIndex1][3*minErrorIndex2+1];
+    pos[offset+2] = mOrigPos[minErrorIndex1][3*minErrorIndex2+2];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -422,28 +475,20 @@ public abstract class TwistyObject extends DistortedNode
       {
       case 0 : return false;  // 'inside' cubit that does not lie on any face
       case 1 :                // cubit that lies inside one of the faces
-               Static3D orig = cubit.getOrigPosition();
+               float[] orig   = cubit.getOrigPosition();
                Static4D quat1 = QUATS[quatIndex];
                Static4D quat2 = QUATS[cubit.mQuatIndex];
 
-               Static4D cubitCenter = new Static4D( orig.get0(), orig.get1(), orig.get2(), 0);
-               Static4D rotated1 = RubikSurfaceView.rotateVectorByQuat( cubitCenter, quat1 );
+               Static4D cubitCenter = new Static4D( orig[0], orig[1], orig[2], 0);              // not used for bandaged objects,
+               Static4D rotated1 = RubikSurfaceView.rotateVectorByQuat( cubitCenter, quat1 );   // only check the first position
                Static4D rotated2 = RubikSurfaceView.rotateVectorByQuat( cubitCenter, quat2 );
 
-               int row1, row2;
-               float x1 = rotated1.get0();
-               float y1 = rotated1.get1();
-               float z1 = rotated1.get2();
-               float x2 = rotated2.get0();
-               float y2 = rotated2.get1();
-               float z2 = rotated2.get2();
+               rotated1.get(mTmp1, 0, 0, 0);
+               rotated2.get(mTmp2, 0, 0, 0);
 
                for(int i=0; i<NUM_AXIS; i++)
                  {
-                 row1 = computeRow(x1,y1,z1,i);
-                 row2 = computeRow(x2,y2,z2,i);
-
-                 if( ((row1 & row2) & bitmap) != 0 ) return false;
+                 if( (computeRow(mTmp1,i) & computeRow(mTmp2,i) & bitmap) != 0 ) return false;
                  }
                return true;
 
@@ -843,7 +888,7 @@ public abstract class TwistyObject extends DistortedNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   abstract float getScreenRatio();
-  abstract Static3D[] getCubitPositions(int numLayers);
+  abstract float[][] getCubitPositions(int numLayers);
   abstract Static4D[] getQuats();
   abstract int getNumFaces();
   abstract int getNumStickerTypes(int numLayers);
diff --git a/src/main/java/org/distorted/objects/TwistyPyraminx.java b/src/main/java/org/distorted/objects/TwistyPyraminx.java
index 8ad49d2c..3d30b2d5 100644
--- a/src/main/java/org/distorted/objects/TwistyPyraminx.java
+++ b/src/main/java/org/distorted/objects/TwistyPyraminx.java
@@ -82,7 +82,7 @@ public class TwistyPyraminx extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private void addTetrahedralLattice(int size, int index, Static3D[] pos)
+  private void addTetrahedralLattice(int size, int index, float[][] pos)
     {
     final float DX = 1.0f;
     final float DY = SQ2/2;
@@ -103,7 +103,7 @@ public class TwistyPyraminx extends TwistyObject
 
         for(int z=0; z<size-layer; z++)
           {
-          pos[index] = new Static3D(currX,currY,currZ);
+          pos[index] = new float[] {currX,currY,currZ};
           index++;
           currZ -= DZ;
           }
@@ -120,11 +120,11 @@ public class TwistyPyraminx extends TwistyObject
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // there are (n^3-n)/6 octahedrons and ((n+1)^3 - (n+1))/6 tetrahedrons
 
-  Static3D[] getCubitPositions(int size)
+  float[][] getCubitPositions(int size)
     {
     int numOcta = (size-1)*size*(size+1)/6;
     int numTetra= size*(size+1)*(size+2)/6;
-    Static3D[] ret = new Static3D[numOcta+numTetra];
+    float[][] ret = new float[numOcta+numTetra][];
 
     addTetrahedralLattice(size-1,      0,ret);
     addTetrahedralLattice(size  ,numOcta,ret);
diff --git a/src/main/java/org/distorted/objects/TwistyRedi.java b/src/main/java/org/distorted/objects/TwistyRedi.java
index 25a2a1a9..50e81b35 100644
--- a/src/main/java/org/distorted/objects/TwistyRedi.java
+++ b/src/main/java/org/distorted/objects/TwistyRedi.java
@@ -80,29 +80,29 @@ public class TwistyRedi extends TwistyObject
   private static final float DIST_EDGE   = 1.5f;
 
   // centers of the 8 corners + 12 edges ( i.e. of the all 20 cubits)
-  private static final Static3D[] CENTERS = new Static3D[]
+  private static final float[][] CENTERS = new float[][]
          {
-           new Static3D( DIST_CORNER, DIST_CORNER, DIST_CORNER ),
-           new Static3D( DIST_CORNER, DIST_CORNER,-DIST_CORNER ),
-           new Static3D( DIST_CORNER,-DIST_CORNER, DIST_CORNER ),
-           new Static3D( DIST_CORNER,-DIST_CORNER,-DIST_CORNER ),
-           new Static3D(-DIST_CORNER, DIST_CORNER, DIST_CORNER ),
-           new Static3D(-DIST_CORNER, DIST_CORNER,-DIST_CORNER ),
-           new Static3D(-DIST_CORNER,-DIST_CORNER, DIST_CORNER ),
-           new Static3D(-DIST_CORNER,-DIST_CORNER,-DIST_CORNER ),
-
-           new Static3D(      0.0f, DIST_EDGE, DIST_EDGE ),
-           new Static3D( DIST_EDGE,      0.0f, DIST_EDGE ),
-           new Static3D(      0.0f,-DIST_EDGE, DIST_EDGE ),
-           new Static3D(-DIST_EDGE,      0.0f, DIST_EDGE ),
-           new Static3D( DIST_EDGE, DIST_EDGE,      0.0f ),
-           new Static3D( DIST_EDGE,-DIST_EDGE,      0.0f ),
-           new Static3D(-DIST_EDGE,-DIST_EDGE,      0.0f ),
-           new Static3D(-DIST_EDGE, DIST_EDGE,      0.0f ),
-           new Static3D(      0.0f, DIST_EDGE,-DIST_EDGE ),
-           new Static3D( DIST_EDGE,      0.0f,-DIST_EDGE ),
-           new Static3D(      0.0f,-DIST_EDGE,-DIST_EDGE ),
-           new Static3D(-DIST_EDGE,      0.0f,-DIST_EDGE )
+             { DIST_CORNER, DIST_CORNER, DIST_CORNER },
+             { DIST_CORNER, DIST_CORNER,-DIST_CORNER },
+             { DIST_CORNER,-DIST_CORNER, DIST_CORNER },
+             { DIST_CORNER,-DIST_CORNER,-DIST_CORNER },
+             {-DIST_CORNER, DIST_CORNER, DIST_CORNER },
+             {-DIST_CORNER, DIST_CORNER,-DIST_CORNER },
+             {-DIST_CORNER,-DIST_CORNER, DIST_CORNER },
+             {-DIST_CORNER,-DIST_CORNER,-DIST_CORNER },
+
+             {      0.0f, DIST_EDGE, DIST_EDGE },
+             { DIST_EDGE,      0.0f, DIST_EDGE },
+             {      0.0f,-DIST_EDGE, DIST_EDGE },
+             {-DIST_EDGE,      0.0f, DIST_EDGE },
+             { DIST_EDGE, DIST_EDGE,      0.0f },
+             { DIST_EDGE,-DIST_EDGE,      0.0f },
+             {-DIST_EDGE,-DIST_EDGE,      0.0f },
+             {-DIST_EDGE, DIST_EDGE,      0.0f },
+             {      0.0f, DIST_EDGE,-DIST_EDGE },
+             { DIST_EDGE,      0.0f,-DIST_EDGE },
+             {      0.0f,-DIST_EDGE,-DIST_EDGE },
+             {-DIST_EDGE,      0.0f,-DIST_EDGE }
          };
 
   // Colors of the faces of cubits.
@@ -199,7 +199,7 @@ public class TwistyRedi extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Static3D[] getCubitPositions(int size)
+  float[][] getCubitPositions(int size)
     {
     return CENTERS;
     }
diff --git a/src/main/java/org/distorted/objects/TwistyRex.java b/src/main/java/org/distorted/objects/TwistyRex.java
index 1f61ade9..5749a339 100644
--- a/src/main/java/org/distorted/objects/TwistyRex.java
+++ b/src/main/java/org/distorted/objects/TwistyRex.java
@@ -189,57 +189,57 @@ public class TwistyRex extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Static3D[] getCubitPositions(int numLayers)
+  float[][] getCubitPositions(int numLayers)
     {
     final float DIST = 0.50f;
     final float DIST2= (1+2*REX_D)/6;
 
-    final Static3D[] CENTERS = new Static3D[42];
-
-    CENTERS[ 0] = new Static3D( +DIST , +DIST2, +DIST2);
-    CENTERS[ 1] = new Static3D( +DIST , +DIST2, -DIST2);
-    CENTERS[ 2] = new Static3D( +DIST , -DIST2, -DIST2);
-    CENTERS[ 3] = new Static3D( +DIST , -DIST2, +DIST2);
-    CENTERS[ 4] = new Static3D( -DIST , +DIST2, +DIST2);
-    CENTERS[ 5] = new Static3D( -DIST , +DIST2, -DIST2);
-    CENTERS[ 6] = new Static3D( -DIST , -DIST2, -DIST2);
-    CENTERS[ 7] = new Static3D( -DIST , -DIST2, +DIST2);
-    CENTERS[ 8] = new Static3D( +DIST2, +DIST , +DIST2);
-    CENTERS[ 9] = new Static3D( +DIST2, +DIST , -DIST2);
-    CENTERS[10] = new Static3D( -DIST2, +DIST , -DIST2);
-    CENTERS[11] = new Static3D( -DIST2, +DIST , +DIST2);
-    CENTERS[12] = new Static3D( +DIST2, -DIST , +DIST2);
-    CENTERS[13] = new Static3D( +DIST2, -DIST , -DIST2);
-    CENTERS[14] = new Static3D( -DIST2, -DIST , -DIST2);
-    CENTERS[15] = new Static3D( -DIST2, -DIST , +DIST2);
-    CENTERS[16] = new Static3D( +DIST2, +DIST2, +DIST );
-    CENTERS[17] = new Static3D( +DIST2, -DIST2, +DIST );
-    CENTERS[18] = new Static3D( -DIST2, -DIST2, +DIST );
-    CENTERS[19] = new Static3D( -DIST2, +DIST2, +DIST );
-    CENTERS[20] = new Static3D( +DIST2, +DIST2, -DIST );
-    CENTERS[21] = new Static3D( +DIST2, -DIST2, -DIST );
-    CENTERS[22] = new Static3D( -DIST2, -DIST2, -DIST );
-    CENTERS[23] = new Static3D( -DIST2, +DIST2, -DIST );
-
-    CENTERS[24] = new Static3D( +DIST , +0.00f, +0.00f);
-    CENTERS[25] = new Static3D( -DIST , +0.00f, +0.00f);
-    CENTERS[26] = new Static3D( +0.00f, +DIST , +0.00f);
-    CENTERS[27] = new Static3D( +0.00f, -DIST , +0.00f);
-    CENTERS[28] = new Static3D( +0.00f, +0.00f, +DIST );
-    CENTERS[29] = new Static3D( +0.00f, +0.00f, -DIST );
-
-    CENTERS[30] = new Static3D( +0.00f, +DIST , +DIST );
-    CENTERS[31] = new Static3D( +DIST , +0.00f, +DIST );
-    CENTERS[32] = new Static3D( +0.00f, -DIST , +DIST );
-    CENTERS[33] = new Static3D( -DIST , +0.00f, +DIST );
-    CENTERS[34] = new Static3D( +DIST , +DIST , +0.00f);
-    CENTERS[35] = new Static3D( +DIST , -DIST , +0.00f);
-    CENTERS[36] = new Static3D( -DIST , -DIST , +0.00f);
-    CENTERS[37] = new Static3D( -DIST , +DIST , +0.00f);
-    CENTERS[38] = new Static3D( +0.00f, +DIST , -DIST );
-    CENTERS[39] = new Static3D( +DIST , +0.00f, -DIST );
-    CENTERS[40] = new Static3D( +0.00f, -DIST , -DIST );
-    CENTERS[41] = new Static3D( -DIST , +0.00f, -DIST );
+    final float[][] CENTERS = new float[42][];
+
+    CENTERS[ 0] = new float[] { +DIST , +DIST2, +DIST2};
+    CENTERS[ 1] = new float[] { +DIST , +DIST2, -DIST2};
+    CENTERS[ 2] = new float[] { +DIST , -DIST2, -DIST2};
+    CENTERS[ 3] = new float[] { +DIST , -DIST2, +DIST2};
+    CENTERS[ 4] = new float[] { -DIST , +DIST2, +DIST2};
+    CENTERS[ 5] = new float[] { -DIST , +DIST2, -DIST2};
+    CENTERS[ 6] = new float[] { -DIST , -DIST2, -DIST2};
+    CENTERS[ 7] = new float[] { -DIST , -DIST2, +DIST2};
+    CENTERS[ 8] = new float[] { +DIST2, +DIST , +DIST2};
+    CENTERS[ 9] = new float[] { +DIST2, +DIST , -DIST2};
+    CENTERS[10] = new float[] { -DIST2, +DIST , -DIST2};
+    CENTERS[11] = new float[] { -DIST2, +DIST , +DIST2};
+    CENTERS[12] = new float[] { +DIST2, -DIST , +DIST2};
+    CENTERS[13] = new float[] { +DIST2, -DIST , -DIST2};
+    CENTERS[14] = new float[] { -DIST2, -DIST , -DIST2};
+    CENTERS[15] = new float[] { -DIST2, -DIST , +DIST2};
+    CENTERS[16] = new float[] { +DIST2, +DIST2, +DIST };
+    CENTERS[17] = new float[] { +DIST2, -DIST2, +DIST };
+    CENTERS[18] = new float[] { -DIST2, -DIST2, +DIST };
+    CENTERS[19] = new float[] { -DIST2, +DIST2, +DIST };
+    CENTERS[20] = new float[] { +DIST2, +DIST2, -DIST };
+    CENTERS[21] = new float[] { +DIST2, -DIST2, -DIST };
+    CENTERS[22] = new float[] { -DIST2, -DIST2, -DIST };
+    CENTERS[23] = new float[] { -DIST2, +DIST2, -DIST };
+
+    CENTERS[24] = new float[] { +DIST , +0.00f, +0.00f};
+    CENTERS[25] = new float[] { -DIST , +0.00f, +0.00f};
+    CENTERS[26] = new float[] { +0.00f, +DIST , +0.00f};
+    CENTERS[27] = new float[] { +0.00f, -DIST , +0.00f};
+    CENTERS[28] = new float[] { +0.00f, +0.00f, +DIST };
+    CENTERS[29] = new float[] { +0.00f, +0.00f, -DIST };
+
+    CENTERS[30] = new float[] { +0.00f, +DIST , +DIST };
+    CENTERS[31] = new float[] { +DIST , +0.00f, +DIST };
+    CENTERS[32] = new float[] { +0.00f, -DIST , +DIST };
+    CENTERS[33] = new float[] { -DIST , +0.00f, +DIST };
+    CENTERS[34] = new float[] { +DIST , +DIST , +0.00f};
+    CENTERS[35] = new float[] { +DIST , -DIST , +0.00f};
+    CENTERS[36] = new float[] { -DIST , -DIST , +0.00f};
+    CENTERS[37] = new float[] { -DIST , +DIST , +0.00f};
+    CENTERS[38] = new float[] { +0.00f, +DIST , -DIST };
+    CENTERS[39] = new float[] { +DIST , +0.00f, -DIST };
+    CENTERS[40] = new float[] { +0.00f, -DIST , -DIST };
+    CENTERS[41] = new float[] { -DIST , +0.00f, -DIST };
 
     return CENTERS;
     }
diff --git a/src/main/java/org/distorted/objects/TwistySkewb.java b/src/main/java/org/distorted/objects/TwistySkewb.java
index faf4472c..b2af4b62 100644
--- a/src/main/java/org/distorted/objects/TwistySkewb.java
+++ b/src/main/java/org/distorted/objects/TwistySkewb.java
@@ -213,7 +213,7 @@ public class TwistySkewb extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Static3D[] getCubitPositions(int numLayers)
+  float[][] getCubitPositions(int numLayers)
     {
     final float DIST_CORNER = (numLayers-1)*0.50f;
     final float DIST_EDGE   = (numLayers-1)*0.50f;
@@ -223,18 +223,18 @@ public class TwistySkewb extends TwistyObject
     final int numEdges   = getNumEdges(numLayers);
     final int numCenters = 6*getNumCentersPerFace(numLayers);
 
-    final Static3D[] CENTERS = new Static3D[numCorners+numEdges+numCenters];
+    final float[][] CENTERS = new float[numCorners+numEdges+numCenters][];
 
     /// CORNERS //////////////////////////////////////////////
 
-    CENTERS[0] = new Static3D( DIST_CORNER, DIST_CORNER, DIST_CORNER );
-    CENTERS[1] = new Static3D( DIST_CORNER, DIST_CORNER,-DIST_CORNER );
-    CENTERS[2] = new Static3D( DIST_CORNER,-DIST_CORNER, DIST_CORNER );
-    CENTERS[3] = new Static3D( DIST_CORNER,-DIST_CORNER,-DIST_CORNER );
-    CENTERS[4] = new Static3D(-DIST_CORNER, DIST_CORNER, DIST_CORNER );
-    CENTERS[5] = new Static3D(-DIST_CORNER, DIST_CORNER,-DIST_CORNER );
-    CENTERS[6] = new Static3D(-DIST_CORNER,-DIST_CORNER, DIST_CORNER );
-    CENTERS[7] = new Static3D(-DIST_CORNER,-DIST_CORNER,-DIST_CORNER );
+    CENTERS[0] = new float[] { DIST_CORNER, DIST_CORNER, DIST_CORNER };
+    CENTERS[1] = new float[] { DIST_CORNER, DIST_CORNER,-DIST_CORNER };
+    CENTERS[2] = new float[] { DIST_CORNER,-DIST_CORNER, DIST_CORNER };
+    CENTERS[3] = new float[] { DIST_CORNER,-DIST_CORNER,-DIST_CORNER };
+    CENTERS[4] = new float[] {-DIST_CORNER, DIST_CORNER, DIST_CORNER };
+    CENTERS[5] = new float[] {-DIST_CORNER, DIST_CORNER,-DIST_CORNER };
+    CENTERS[6] = new float[] {-DIST_CORNER,-DIST_CORNER, DIST_CORNER };
+    CENTERS[7] = new float[] {-DIST_CORNER,-DIST_CORNER,-DIST_CORNER };
 
     /// EDGES ///////////////////////////////////////////////
 
@@ -262,9 +262,9 @@ public class TwistySkewb extends TwistyObject
 
       for (int j=0; j<numLayers-2; j++, c+=1.0f, index++)
         {
-        CENTERS[index] = new Static3D( edges[0]==0 ? c : edges[0] ,
+        CENTERS[index] = new float[] { edges[0]==0 ? c : edges[0] ,
                                        edges[1]==0 ? c : edges[1] ,
-                                       edges[2]==0 ? c : edges[2] );
+                                       edges[2]==0 ? c : edges[2] };
         }
       }
 
@@ -307,7 +307,7 @@ public class TwistySkewb extends TwistyObject
           else if( centers[2]==X ) cen2 = x;
           else                     cen2 = centers[2];
 
-          CENTERS[index] = new Static3D(cen0,cen1,cen2);
+          CENTERS[index] = new float[] {cen0,cen1,cen2};
           }
         }
 
@@ -331,7 +331,7 @@ public class TwistySkewb extends TwistyObject
           else if( centers[2]==X ) cen2 = x;
           else                     cen2 = centers[2];
 
-          CENTERS[index] = new Static3D(cen0,cen1,cen2);
+          CENTERS[index] = new float[] {cen0,cen1,cen2};
           }
         }
       }