commit d99f3a48c3a570685a8b61e5d4f613cf920aa7c1
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Fri Oct 16 09:32:39 2020 +0100

    Spearate the concept of number of layers of an object and its size.
    In case of the Skewb family, this is no longer the same (Master Skewb has 3 layers but it's twice bigger than the 2-layered Skewb)

diff --git a/src/main/java/org/distorted/main/RubikActivity.java b/src/main/java/org/distorted/main/RubikActivity.java
index f81067d0..e34265d7 100644
--- a/src/main/java/org/distorted/main/RubikActivity.java
+++ b/src/main/java/org/distorted/main/RubikActivity.java
@@ -391,13 +391,13 @@ public class RubikActivity extends AppCompatActivity
         {
         TwistyObject oldObject = pre.getObject();
         ObjectList oldList = oldObject.getObjectList();
-        int oldSize = oldObject.getSize();
+        int oldNum = oldObject.getNumLayers();
         float fps = view.getRenderer().getFPS();
         fps = (int)(fps+0.5f);
         StringBuilder name = new StringBuilder();
         name.append(oldList.name());
         name.append('_');
-        name.append(oldSize);
+        name.append(oldNum);
         name.append(' ');
         name.append(fps);
         name.append(" --> ");
diff --git a/src/main/java/org/distorted/main/RubikPreRender.java b/src/main/java/org/distorted/main/RubikPreRender.java
index 430e8420..1c1cd1b0 100644
--- a/src/main/java/org/distorted/main/RubikPreRender.java
+++ b/src/main/java/org/distorted/main/RubikPreRender.java
@@ -255,7 +255,7 @@ public class RubikPreRender implements EffectListener
     {
     mChangeObject = false;
 
-    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject || mNewObject.getSize()!=mNextSize)
+    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject || mNewObject.getNumLayers()!=mNextSize)
       {
       mCanRotate= false;
       mCanPlay  = false;
@@ -270,7 +270,7 @@ public class RubikPreRender implements EffectListener
     {
     mSetupObject = false;
 
-    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject || mNewObject.getSize()!=mNextSize)
+    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject || mNewObject.getNumLayers()!=mNextSize)
       {
       mCanRotate= false;
       mCanPlay  = false;
diff --git a/src/main/java/org/distorted/main/RubikSurfaceView.java b/src/main/java/org/distorted/main/RubikSurfaceView.java
index d91f3bca..27d17032 100644
--- a/src/main/java/org/distorted/main/RubikSurfaceView.java
+++ b/src/main/java/org/distorted/main/RubikSurfaceView.java
@@ -305,11 +305,11 @@ public class RubikSurfaceView extends GLSurfaceView
         }
       else
         {
-        Static4D touchPoint1 = new Static4D(x, y, 0, 0);
-        Static4D rotatedTouchPoint1= rotateVectorByInvertedQuat(touchPoint1, mQuat);
+        Static4D touchPoint = new Static4D(x, y, 0, 0);
+        Static4D rotatedTouchPoint= rotateVectorByInvertedQuat(touchPoint, mQuat);
         Static4D rotatedCamera= rotateVectorByInvertedQuat(CAMERA_POINT, mQuat);
 
-        if( mMovement!=null && mMovement.faceTouched(rotatedTouchPoint1,rotatedCamera) )
+        if( mMovement!=null && mMovement.faceTouched(rotatedTouchPoint,rotatedCamera) )
           {
           mDragging           = false;
           mContinuingRotation = false;
@@ -331,7 +331,7 @@ public class RubikSurfaceView extends GLSurfaceView
               TwistyObject object = mPreRender.getObject();
               mLastCubit = object.getCubit(point);
               mPreRender.setTextureMap( mLastCubit, mLastCubitFace, color );
-              mLastCubitColor = SolverMain.cubitIsLocked(object.getObjectList(), object.getSize(), mLastCubit);
+              mLastCubitColor = SolverMain.cubitIsLocked(object.getObjectList(), object.getNumLayers(), mLastCubit);
               }
             }
           }
@@ -461,17 +461,17 @@ public class RubikSurfaceView extends GLSurfaceView
       mStartRotY = y;
 
       TwistyObject object = mPreRender.getObject();
-      int size = object.getSize();
+      int numLayers = object.getNumLayers();
 
       Static4D touchPoint2 = new Static4D(x, y, 0, 0);
       Static4D rotatedTouchPoint2= rotateVectorByInvertedQuat(touchPoint2, mQuat);
-      Static2D res = mMovement.newRotation(size,rotatedTouchPoint2);
+      Static2D res = mMovement.newRotation(numLayers,rotatedTouchPoint2);
 
       mCurrentAxis = (int)res.get0();
       mCurrentRow  = (int)res.get1();
 
       computeCurrentAxis( mMovement.getCastedRotAxis(mCurrentAxis) );
-      mRotationFactor = mMovement.returnRotationFactor(size,mCurrentRow);
+      mRotationFactor = mMovement.returnRotationFactor(numLayers,mCurrentRow);
 
       object.beginNewRotation( mCurrentAxis, mCurrentRow );
 
diff --git a/src/main/java/org/distorted/objects/TwistyCube.java b/src/main/java/org/distorted/objects/TwistyCube.java
index d4c0b7c0..60386b41 100644
--- a/src/main/java/org/distorted/objects/TwistyCube.java
+++ b/src/main/java/org/distorted/objects/TwistyCube.java
@@ -98,7 +98,7 @@ class TwistyCube extends TwistyObject
   TwistyCube(int size, Static4D quat, DistortedTexture texture,
              MeshSquare mesh, DistortedEffects effects, int[][] moves, Resources res, int scrWidth)
     {
-    super(size, 60, quat, texture, mesh, effects, moves, ObjectList.CUBE, res, scrWidth);
+    super(size, size, 60, quat, texture, mesh, effects, moves, ObjectList.CUBE, res, scrWidth);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -111,7 +111,7 @@ class TwistyCube extends TwistyObject
       }
 
     int ordinal= ObjectList.CUBE.ordinal();
-    int index  = ObjectList.getSizeIndex(ordinal,getSize());
+    int index  = ObjectList.getSizeIndex(ordinal,getNumLayers());
 
     if( mMeshes[index]==null )
       {
@@ -222,19 +222,19 @@ class TwistyCube extends TwistyObject
 
   float returnMultiplier()
     {
-    return getSize();
+    return getNumLayers();
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   float[] getRowChances()
     {
-    int size = getSize();
-    float[] chances = new float[size];
+    int numLayers = getNumLayers();
+    float[] chances = new float[numLayers];
 
-    for(int i=0; i<size; i++)
+    for(int i=0; i<numLayers; i++)
       {
-      chances[i] = (i+1.0f) / size;
+      chances[i] = (i+1.0f) / numLayers;
       }
 
     return chances;
@@ -315,15 +315,15 @@ class TwistyCube extends TwistyObject
     if ( cubit.mQuatIndex == quatIndex ) return true;
 
     int belongsToHowManyFaces = 0;
-    int size = getSize()-1;
+    int lastLayer = getNumLayers()-1;
     float row;
     final float MAX_ERROR = 0.01f;
 
     for(int i=0; i<NUM_AXIS; i++)
       {
       row = cubit.mRotationRow[i];
-      if( (row     <MAX_ERROR && row     >-MAX_ERROR) ||
-          (row-size<MAX_ERROR && row-size>-MAX_ERROR)  ) belongsToHowManyFaces++;
+      if( (row          <MAX_ERROR && row          >-MAX_ERROR) ||
+          (row-lastLayer<MAX_ERROR && row-lastLayer>-MAX_ERROR)  ) belongsToHowManyFaces++;
       }
 
     switch(belongsToHowManyFaces)
@@ -351,7 +351,7 @@ class TwistyCube extends TwistyObject
                  row1 = computeRow(x1,y1,z1,i);
                  row2 = computeRow(x2,y2,z2,i);
 
-                 if( (row1==0 && row2==0) || (row1==size || row2==size) ) return true;
+                 if( (row1==0 && row2==0) || (row1==lastLayer || row2==lastLayer) ) return true;
                  }
                return false;
 
@@ -385,8 +385,8 @@ class TwistyCube extends TwistyObject
   public String retObjectString()
     {
     StringBuilder objectString = new StringBuilder();
-    int size = getSize();
-    int len = size*size;
+    int layers = getNumLayers();
+    int len = layers*layers;
     int cubitIndex, row, col, color,face;
 
     final int RIGHT= 0;
@@ -403,10 +403,10 @@ class TwistyCube extends TwistyObject
 
     for(int i=0; i<len; i++)
       {
-      row = i/size;
-      col = i%size;
+      row = i/layers;
+      col = i%layers;
 
-      cubitIndex = col<size-1 ? (size-1)*(size+4*col) + row : 6*size*size - 13*size + 8 + row;
+      cubitIndex = col<layers-1 ? (layers-1)*(layers+4*col) + row : 6*layers*layers - 13*layers + 8 + row;
       color = getCubitFaceColorIndex(cubitIndex,face);
       objectString.append(FACE_NAMES[color]);
       }
@@ -415,7 +415,7 @@ class TwistyCube extends TwistyObject
 
     for(int i=0; i<len; i++)
       {
-      cubitIndex = 6*size*size - 12*size +7 - i;
+      cubitIndex = 6*layers*layers - 12*layers +7 - i;
       color = getCubitFaceColorIndex(cubitIndex,face);
       objectString.append(FACE_NAMES[color]);
       }
@@ -424,15 +424,15 @@ class TwistyCube extends TwistyObject
 
     for(int i=0; i<len; i++)
       {
-      row = i/size;
-      col = i%size;
+      row = i/layers;
+      col = i%layers;
 
-      if( col==size-1 ) cubitIndex = 6*size*size - 11*size + 6 -i;
-      else if( col==0 ) cubitIndex = size*size - 1 - i;
+      if( col==layers-1 ) cubitIndex = 6*layers*layers - 11*layers + 6 -i;
+      else if(   col==0 ) cubitIndex = layers*layers - 1 - i;
       else
         {
-        if( row==0 ) cubitIndex = size*size + size-1 + 4*(col-1)*(size-1) + 2*(size-2) + size;
-        else         cubitIndex = size*size + size-1 + 4*(col-1)*(size-1) + 2*(size-1-row);
+        if( row==0 ) cubitIndex = layers*layers + layers-1 + 4*(col-1)*(layers-1) + 2*(layers-2) + layers;
+        else         cubitIndex = layers*layers + layers-1 + 4*(col-1)*(layers-1) + 2*(layers-1-row);
         }
 
       color = getCubitFaceColorIndex(cubitIndex,face);
@@ -443,10 +443,10 @@ class TwistyCube extends TwistyObject
 
     for(int i=0; i<len; i++)
       {
-      row = i/size;
-      col = i%size;
+      row = i/layers;
+      col = i%layers;
 
-      cubitIndex = col==0 ? size-1-row : size*size + size-1 + 4*(col-1)*(size-1) - row;
+      cubitIndex = col==0 ? layers-1-row : layers*layers + layers-1 + 4*(col-1)*(layers-1) - row;
       color = getCubitFaceColorIndex(cubitIndex,face);
       objectString.append(FACE_NAMES[color]);
       }
@@ -455,10 +455,10 @@ class TwistyCube extends TwistyObject
 
     for(int i=0; i<len; i++)
       {
-      row = i/size;
-      col = i%size;
+      row = i/layers;
+      col = i%layers;
 
-      cubitIndex = (size-1-row)*size + col;
+      cubitIndex = (layers-1-row)*layers + col;
       color = getCubitFaceColorIndex(cubitIndex,face);
       objectString.append(FACE_NAMES[color]);
       }
@@ -467,15 +467,15 @@ class TwistyCube extends TwistyObject
 
     for(int i=0; i<len; i++)
       {
-      row = i/size;
-      col = i%size;
+      row = i/layers;
+      col = i%layers;
 
-      if( col==size-1 ) cubitIndex = size*(size-1-row);
-      else if( col==0 ) cubitIndex = 5*size*size - 12*size + 8 + (size-1-row)*size;
+      if( col==layers-1 ) cubitIndex = layers*(layers-1-row);
+      else if(   col==0 ) cubitIndex = 5*layers*layers - 12*layers + 8 + (layers-1-row)*layers;
       else
         {
-        if( row==size-1 ) cubitIndex = size*size + 4*(size-2-col)*(size-1);
-        else              cubitIndex = size*size + 4*(size-2-col)*(size-1) + size + 2*(size-2-row);
+        if( row==layers-1 ) cubitIndex = layers*layers + 4*(layers-2-col)*(layers-1);
+        else                cubitIndex = layers*layers + 4*(layers-2-col)*(layers-1) + layers + 2*(layers-2-row);
         }
 
       color = getCubitFaceColorIndex(cubitIndex,face);
diff --git a/src/main/java/org/distorted/objects/TwistyDiamond.java b/src/main/java/org/distorted/objects/TwistyDiamond.java
index 752d125e..6ca98877 100644
--- a/src/main/java/org/distorted/objects/TwistyDiamond.java
+++ b/src/main/java/org/distorted/objects/TwistyDiamond.java
@@ -126,7 +126,7 @@ public class TwistyDiamond extends TwistyObject
   TwistyDiamond(int size, Static4D quat, DistortedTexture texture,
                 MeshSquare mesh, DistortedEffects effects, int[][] moves, Resources res, int scrWidth)
     {
-    super(size, 60, quat, texture, mesh, effects, moves, ObjectList.DIAM, res, scrWidth);
+    super(size, size, 60, quat, texture, mesh, effects, moves, ObjectList.DIAM, res, scrWidth);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyDino.java b/src/main/java/org/distorted/objects/TwistyDino.java
index d043dbbe..73990bbb 100644
--- a/src/main/java/org/distorted/objects/TwistyDino.java
+++ b/src/main/java/org/distorted/objects/TwistyDino.java
@@ -97,7 +97,7 @@ public abstract class TwistyDino extends TwistyObject
   TwistyDino(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh,
              DistortedEffects effects, int[][] moves, ObjectList obj, Resources res, int scrWidth)
     {
-    super(size, 60, quat, texture, mesh, effects, moves, obj, res, scrWidth);
+    super(size, size, 60, quat, texture, mesh, effects, moves, obj, res, scrWidth);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyHelicopter.java b/src/main/java/org/distorted/objects/TwistyHelicopter.java
index fea3eada..ec99b775 100644
--- a/src/main/java/org/distorted/objects/TwistyHelicopter.java
+++ b/src/main/java/org/distorted/objects/TwistyHelicopter.java
@@ -191,7 +191,7 @@ public class TwistyHelicopter extends TwistyObject
   TwistyHelicopter(int size, Static4D quat, DistortedTexture texture,
                    MeshSquare mesh, DistortedEffects effects, int[][] moves, Resources res, int scrWidth)
     {
-    super(size, 60, quat, texture, mesh, effects, moves, ObjectList.HELI, res, scrWidth);
+    super(size, size, 60, quat, texture, mesh, effects, moves, ObjectList.HELI, res, scrWidth);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyObject.java b/src/main/java/org/distorted/objects/TwistyObject.java
index 7e0dd4be..fa5d4703 100644
--- a/src/main/java/org/distorted/objects/TwistyObject.java
+++ b/src/main/java/org/distorted/objects/TwistyObject.java
@@ -99,7 +99,7 @@ public abstract class TwistyObject extends DistortedNode
   private Static3D[] mOrigPos;
   private Static3D mNodeScale;
   private Static4D mQuat;
-  private int mSize;
+  private int mNumLayers, mRealSize;
   private ObjectList mList;
   private MeshBase mMesh;
   private DistortedEffects mEffects;
@@ -116,7 +116,7 @@ public abstract class TwistyObject extends DistortedNode
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  TwistyObject(int size, int fov, Static4D quat, DistortedTexture nodeTexture, MeshSquare nodeMesh,
+  TwistyObject(int numLayers, int realSize, int fov, Static4D quat, DistortedTexture nodeTexture, MeshSquare nodeMesh,
                DistortedEffects nodeEffects, int[][] moves, ObjectList list, Resources res, int screenWidth)
     {
     super(nodeTexture,nodeEffects,nodeMesh);
@@ -125,9 +125,10 @@ public abstract class TwistyObject extends DistortedNode
 
     resizeFBO(mNodeSize, (int)(NODE_RATIO*mNodeSize));
 
-    mSize = size;
+    mNumLayers = numLayers;
+    mRealSize = realSize;
     mList = list;
-    mOrigPos = getCubitPositions(size);
+    mOrigPos = getCubitPositions(mNumLayers);
 
     QUATS = getQuats();
     NUM_CUBITS  = mOrigPos.length;
@@ -137,7 +138,7 @@ public abstract class TwistyObject extends DistortedNode
     NUM_FACES = getNumFaces();
     NUM_CUBIT_FACES = getNumCubitFaces();
     NUM_TEXTURES = getNumStickerTypes()*NUM_FACES;
-    CUTS = getCuts(mSize);
+    CUTS = getCuts(mNumLayers);
     NUM_CUTS = CUTS.length;
 
     if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE;
@@ -156,7 +157,7 @@ public abstract class TwistyObject extends DistortedNode
     mRotationAngleMiddle = new Static1D(0);
     mRotationAngleFinal  = new Static1D(0);
 
-    float scale  = mObjectScreenRatio*mInitScreenRatio*mNodeSize/mSize;
+    float scale  = mObjectScreenRatio*mInitScreenRatio*mNodeSize/mRealSize;
     mObjectScale = new Static3D(scale,scale,scale);
     mScaleEffect = new MatrixEffectScale(mObjectScale);
     mQuatEffect  = new MatrixEffectQuaternion(quat, CENTER);
@@ -199,7 +200,7 @@ public abstract class TwistyObject extends DistortedNode
     {
     if( mCreateFromDMesh )
       {
-      int sizeIndex = ObjectList.getSizeIndex(list.ordinal(),mSize);
+      int sizeIndex = ObjectList.getSizeIndex(list.ordinal(),mNumLayers);
       int resourceID= list.getResourceIDs()[sizeIndex];
 
       InputStream is = res.openRawResource(resourceID);
@@ -249,7 +250,7 @@ public abstract class TwistyObject extends DistortedNode
     if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE;
     if( mObjectScreenRatio<MIN_SIZE_CHANGE) mObjectScreenRatio = MIN_SIZE_CHANGE;
 
-    float scale = mObjectScreenRatio*mInitScreenRatio*mNodeSize/mSize;
+    float scale = mObjectScreenRatio*mInitScreenRatio*mNodeSize/mRealSize;
     mObjectScale.set(scale,scale,scale);
     }
 
@@ -504,9 +505,9 @@ public abstract class TwistyObject extends DistortedNode
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public int getSize()
+  public int getNumLayers()
     {
-    return mSize;
+    return mNumLayers;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -604,7 +605,7 @@ public abstract class TwistyObject extends DistortedNode
 
       for(int cubitface=0; cubitface<NUM_CUBIT_FACES; cubitface++)
         {
-        color = getFaceColor(cubit,cubitface,mSize);
+        color = getFaceColor(cubit,cubitface,mNumLayers);
         maps[cubitface] = new Static4D( color*ratio, 0.0f, ratio, 1.0f);
         }
 
@@ -632,7 +633,7 @@ public abstract class TwistyObject extends DistortedNode
       android.util.Log.e("object", "invalid rotation axis: "+axis);
       return;
       }
-    if( row<0 || row>=mSize )
+    if( row<0 || row>=mNumLayers )
       {
       android.util.Log.e("object", "invalid rotation row: "+row);
       return;
diff --git a/src/main/java/org/distorted/objects/TwistyPyraminx.java b/src/main/java/org/distorted/objects/TwistyPyraminx.java
index 3ee6179c..0389bd2c 100644
--- a/src/main/java/org/distorted/objects/TwistyPyraminx.java
+++ b/src/main/java/org/distorted/objects/TwistyPyraminx.java
@@ -77,7 +77,7 @@ public class TwistyPyraminx extends TwistyObject
   TwistyPyraminx(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh,
                  DistortedEffects effects, int[][] moves, Resources res, int scrWidth)
     {
-    super(size, 30, quat, texture, mesh, effects, moves, ObjectList.PYRA, res, scrWidth);
+    super(size, size, 30, quat, texture, mesh, effects, moves, ObjectList.PYRA, res, scrWidth);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -221,9 +221,9 @@ public class TwistyPyraminx extends TwistyObject
 
   MeshBase createCubitMesh(int cubit)
     {
-    int size = getSize();
+    int numLayers = getNumLayers();
 
-    if( cubit< (size-1)*size*(size+1)/6 )
+    if( cubit< (numLayers-1)*numLayers*(numLayers+1)/6 )
       {
       if( mOctaMesh==null ) mOctaMesh = CubitFactory.getInstance().createOctaMesh();
       return mOctaMesh.copy(true);
@@ -253,21 +253,21 @@ public class TwistyPyraminx extends TwistyObject
 
   float returnMultiplier()
     {
-    return getSize()/(SQ6/3);
+    return getNumLayers()/(SQ6/3);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   float[] getRowChances()
     {
-    int size = getSize();
-    int total = size*(size+1)/2;
+    int numLayers = getNumLayers();
+    int total = numLayers*(numLayers+1)/2;
     float running=0.0f;
-    float[] chances = new float[size];
+    float[] chances = new float[numLayers];
 
-    for(int i=0; i<size; i++)
+    for(int i=0; i<numLayers; i++)
       {
-      running += (size-i);
+      running += (numLayers-i);
       chances[i] = running / total;
       }
 
@@ -349,15 +349,15 @@ public class TwistyPyraminx extends TwistyObject
     if ( cubit.mQuatIndex == quatIndex ) return true;
 
     int belongsToHowManyFaces = 0;
-    int size = getSize()-1;
+    int numLayers = getNumLayers()-1;
     float row;
     final float MAX_ERROR = 0.01f;
 
     for(int i=0; i<NUM_AXIS; i++)
       {
       row = cubit.mRotationRow[i];
-      if( (row     <MAX_ERROR && row     >-MAX_ERROR) ||
-          (row-size<MAX_ERROR && row-size>-MAX_ERROR)  ) belongsToHowManyFaces++;
+      if( (row          <MAX_ERROR && row          >-MAX_ERROR) ||
+          (row-numLayers<MAX_ERROR && row-numLayers>-MAX_ERROR)  ) belongsToHowManyFaces++;
       }
 
     switch(belongsToHowManyFaces)
@@ -385,7 +385,7 @@ public class TwistyPyraminx extends TwistyObject
                  row1 = computeRow(x1,y1,z1,i);
                  row2 = computeRow(x2,y2,z2,i);
 
-                 if( (row1==0 && row2==0) || (row1==size || row2==size) ) return true;
+                 if( (row1==0 && row2==0) || (row1==numLayers || row2==numLayers) ) return true;
                  }
                return false;
 
diff --git a/src/main/java/org/distorted/objects/TwistyRedi.java b/src/main/java/org/distorted/objects/TwistyRedi.java
index 9031e83f..d478ee70 100644
--- a/src/main/java/org/distorted/objects/TwistyRedi.java
+++ b/src/main/java/org/distorted/objects/TwistyRedi.java
@@ -140,7 +140,7 @@ public class TwistyRedi extends TwistyObject
   TwistyRedi(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh,
              DistortedEffects effects, int[][] moves, Resources res, int scrWidth)
     {
-    super(size, 60, quat, texture, mesh, effects, moves, ObjectList.REDI, res, scrWidth);
+    super(size, size, 60, quat, texture, mesh, effects, moves, ObjectList.REDI, res, scrWidth);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistySkewb.java b/src/main/java/org/distorted/objects/TwistySkewb.java
index 0ac8217a..54d6a971 100644
--- a/src/main/java/org/distorted/objects/TwistySkewb.java
+++ b/src/main/java/org/distorted/objects/TwistySkewb.java
@@ -123,7 +123,7 @@ public class TwistySkewb extends TwistyObject
   TwistySkewb(int size, Static4D quat, DistortedTexture texture,
               MeshSquare mesh, DistortedEffects effects, int[][] moves, Resources res, int scrWidth)
     {
-    super(size, 60, quat, texture, mesh, effects, moves, ObjectList.SKEW, res, scrWidth);
+    super(size, 2*size-2, 60, quat, texture, mesh, effects, moves, ObjectList.SKEW, res, scrWidth);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -151,8 +151,7 @@ public class TwistySkewb extends TwistyObject
 
   float getScreenRatio()
     {
-    int size = getSize();
-    return size/ (2.0f*(size-1));
+    return 1.0f;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -400,9 +399,9 @@ public class TwistySkewb extends TwistyObject
     {
     MeshBase mesh;
 
-    int size = getSize();
-    int numCorners = getNumCorners(size);
-    int numEdges   = getNumEdges(size);
+    int numLayers = getNumLayers();
+    int numCorners = getNumCorners(numLayers);
+    int numEdges   = getNumEdges(numLayers);
 
     if( cubit<numCorners )
       {
@@ -427,7 +426,7 @@ public class TwistySkewb extends TwistyObject
       mesh = mFaceMesh.copy(true);
       }
 
-    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit,size), new Static3D(0,0,0) );
+    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit,numLayers), new Static3D(0,0,0) );
     mesh.apply(quat,0xffffffff,0);
 
     return mesh;
@@ -500,12 +499,12 @@ public class TwistySkewb extends TwistyObject
 
   float[] getRowChances()
     {
-    int size = getSize();
-    float[] chances = new float[size];
+    int numLayers = getNumLayers();
+    float[] chances = new float[numLayers];
 
-    for(int i=0; i<size; i++)
+    for(int i=0; i<numLayers; i++)
       {
-      chances[i] = (float)(i+1)/size;
+      chances[i] = (float)(i+1)/numLayers;
       }
 
     return chances;
