commit abf369862ef111a68813ac5a8c3e1596f5c56fa9
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Mon Sep 13 03:15:39 2021 +0200

    Add Mirror Cube 2x2 and 3x3.

diff --git a/src/main/java/org/distorted/objects/ObjectList.java b/src/main/java/org/distorted/objects/ObjectList.java
index c65bdd60..73bb81fa 100644
--- a/src/main/java/org/distorted/objects/ObjectList.java
+++ b/src/main/java/org/distorted/objects/ObjectList.java
@@ -246,6 +246,16 @@ public enum ObjectList
          60
        ),
 
+  MIRR (
+         new int[][] {
+                       {2 , 12, 12, 0, R.drawable.ui_small_cube2, R.drawable.ui_medium_cube2, R.drawable.ui_big_cube2, R.drawable.ui_huge_cube2} ,
+                       {3 , 16, 17, 0, R.drawable.ui_small_cube3, R.drawable.ui_medium_cube3, R.drawable.ui_big_cube3, R.drawable.ui_huge_cube3} ,
+                     },
+         TwistyMirror.class,
+         new MovementCube(),
+         7,
+         60
+       ),
   ;
 
   public static final int NUM_OBJECTS = values().length;
@@ -673,6 +683,7 @@ public enum ObjectList
       case 17: return new TwistyBandagedEvil  (size, quat, texture, mesh, effects, moves, res, scrWidth);
       case 18: return new TwistySquare1       (size, quat, texture, mesh, effects, moves, res, scrWidth);
       case 19: return new TwistySquare2       (size, quat, texture, mesh, effects, moves, res, scrWidth);
+      case 20: return new TwistyMirror        (size, quat, texture, mesh, effects, moves, res, scrWidth);
       }
 
     return null;
diff --git a/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java b/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java
index 5551b2ce..7364dda3 100644
--- a/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java
+++ b/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java
@@ -296,7 +296,7 @@ abstract class TwistyBandagedAbstract extends TwistyObject
         }
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -331,7 +331,7 @@ abstract class TwistyBandagedAbstract extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
@@ -450,7 +450,7 @@ abstract class TwistyBandagedAbstract extends TwistyObject
 
     boolean reaches  = multiplier*position + dim[dimIndex]*0.5f > (numLayers-1)*0.5f;
 
-    return reaches ? stickerIndex*NUM_FACES + face : NUM_TEXTURES;
+    return reaches ? stickerIndex*NUM_FACE_COLORS + face : NUM_TEXTURES;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyCube.java b/src/main/java/org/distorted/objects/TwistyCube.java
index a8b38fa0..93934c0e 100644
--- a/src/main/java/org/distorted/objects/TwistyCube.java
+++ b/src/main/java/org/distorted/objects/TwistyCube.java
@@ -252,7 +252,7 @@ class TwistyCube extends TwistyObject
       mStickers[0] = new ObjectSticker(STICKERS[0],null,radii,stroke );
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -293,7 +293,7 @@ class TwistyCube extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
diff --git a/src/main/java/org/distorted/objects/TwistyDiamond.java b/src/main/java/org/distorted/objects/TwistyDiamond.java
index eb1fb177..7ed7efab 100644
--- a/src/main/java/org/distorted/objects/TwistyDiamond.java
+++ b/src/main/java/org/distorted/objects/TwistyDiamond.java
@@ -144,7 +144,7 @@ public class TwistyDiamond extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
@@ -502,7 +502,7 @@ public class TwistyDiamond extends TwistyObject
       mStickers[0]  = new ObjectSticker(STICKERS[0],null,radii,stroke);
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyDino.java b/src/main/java/org/distorted/objects/TwistyDino.java
index a54f7007..94795f53 100644
--- a/src/main/java/org/distorted/objects/TwistyDino.java
+++ b/src/main/java/org/distorted/objects/TwistyDino.java
@@ -102,7 +102,7 @@ public abstract class TwistyDino extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
@@ -213,7 +213,7 @@ public abstract class TwistyDino extends TwistyObject
       mStickers[0]  = new ObjectSticker(STICKERS[0],null,radii,stroke);
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyHelicopter.java b/src/main/java/org/distorted/objects/TwistyHelicopter.java
index 9ab67662..f45f4be6 100644
--- a/src/main/java/org/distorted/objects/TwistyHelicopter.java
+++ b/src/main/java/org/distorted/objects/TwistyHelicopter.java
@@ -166,7 +166,7 @@ public class TwistyHelicopter extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
@@ -417,7 +417,7 @@ public class TwistyHelicopter extends TwistyObject
       mStickers[0] = new ObjectSticker(STICKERS[0],null,radii,stroke);
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyIvy.java b/src/main/java/org/distorted/objects/TwistyIvy.java
index 6f8a1f07..a38cf5f9 100644
--- a/src/main/java/org/distorted/objects/TwistyIvy.java
+++ b/src/main/java/org/distorted/objects/TwistyIvy.java
@@ -142,7 +142,7 @@ public class TwistyIvy extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
@@ -448,7 +448,7 @@ public class TwistyIvy extends TwistyObject
       for(int s=0; s<NUM_STICKERS; s++) mStickers[s] = new ObjectSticker(STICKERS[s], angles[s],radii[s],strokes[s]);
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyJing.java b/src/main/java/org/distorted/objects/TwistyJing.java
index f1202c0a..bc5ec9f7 100644
--- a/src/main/java/org/distorted/objects/TwistyJing.java
+++ b/src/main/java/org/distorted/objects/TwistyJing.java
@@ -156,7 +156,7 @@ public class TwistyJing extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
@@ -401,7 +401,7 @@ public class TwistyJing extends TwistyObject
         }
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyKilominx.java b/src/main/java/org/distorted/objects/TwistyKilominx.java
index f5284132..f645b816 100644
--- a/src/main/java/org/distorted/objects/TwistyKilominx.java
+++ b/src/main/java/org/distorted/objects/TwistyKilominx.java
@@ -617,7 +617,7 @@ public class TwistyKilominx extends TwistyMinx
 
     part /=2;
 
-    return (part==0 || cubitface==((part+1)%2)) ? mEdgeMap[variant][cubitface+2] + ((part+3)/2)*NUM_FACES : NUM_TEXTURES;
+    return (part==0 || cubitface==((part+1)%2)) ? mEdgeMap[variant][cubitface+2] + ((part+3)/2)*NUM_FACE_COLORS : NUM_TEXTURES;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -632,7 +632,7 @@ public class TwistyKilominx extends TwistyMinx
       return cubitface>=0 && cubitface<3 ? mCornerFaceMap[center][cubitface] : NUM_TEXTURES;
       }
 
-    return cubitface==mCenterFaceMap[center] ? center/5 + NUM_FACES*(numLayers-1)/2 : NUM_TEXTURES;
+    return cubitface==mCenterFaceMap[center] ? center/5 + NUM_FACE_COLORS*(numLayers-1)/2 : NUM_TEXTURES;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -712,7 +712,7 @@ public class TwistyKilominx extends TwistyMinx
 
   private int getStickerIndex(int face)
     {
-    int variant = face/NUM_FACES;
+    int variant = face/NUM_FACE_COLORS;
     int numLayers = getNumLayers();
 
     if( variant == (numLayers-1)/2 || numLayers==3 ) return 0;
diff --git a/src/main/java/org/distorted/objects/TwistyMegaminx.java b/src/main/java/org/distorted/objects/TwistyMegaminx.java
index 5f248e40..81f0ca82 100644
--- a/src/main/java/org/distorted/objects/TwistyMegaminx.java
+++ b/src/main/java/org/distorted/objects/TwistyMegaminx.java
@@ -529,14 +529,14 @@ public class TwistyMegaminx extends TwistyMinx
     int variant = edge / numCubitsPerEdge;
     if( mEdgeMap==null ) initializeEdgeMap();
 
-    return (part==0 || cubitface==((part+1)%2)) ? mEdgeMap[variant][cubitface+2] + ((part+3)/2)*NUM_FACES : NUM_TEXTURES;
+    return (part==0 || cubitface==((part+1)%2)) ? mEdgeMap[variant][cubitface+2] + ((part+3)/2)*NUM_FACE_COLORS : NUM_TEXTURES;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   int getCenterColor(int center, int cubitface, int numLayers)
     {
-    return cubitface>0 ? NUM_TEXTURES : center + NUM_FACES*(numLayers+1)/2;
+    return cubitface>0 ? NUM_TEXTURES : center + NUM_FACE_COLORS*(numLayers+1)/2;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -607,7 +607,7 @@ public class TwistyMegaminx extends TwistyMinx
 
   private int getStickerIndex(int face)
     {
-    int variant = face/NUM_FACES;
+    int variant = face/NUM_FACE_COLORS;
 
     if( variant==0 ) return 0;
 
diff --git a/src/main/java/org/distorted/objects/TwistyMinx.java b/src/main/java/org/distorted/objects/TwistyMinx.java
index d904e1b8..bb626cc3 100644
--- a/src/main/java/org/distorted/objects/TwistyMinx.java
+++ b/src/main/java/org/distorted/objects/TwistyMinx.java
@@ -524,7 +524,7 @@ abstract class TwistyMinx extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
diff --git a/src/main/java/org/distorted/objects/TwistyMirror.java b/src/main/java/org/distorted/objects/TwistyMirror.java
new file mode 100644
index 00000000..8071dbaf
--- /dev/null
+++ b/src/main/java/org/distorted/objects/TwistyMirror.java
@@ -0,0 +1,692 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright 2019 Leszek Koltunski                                                               //
+//                                                                                               //
+// This file is part of Magic Cube.                                                              //
+//                                                                                               //
+// Magic Cube is free software: you can redistribute it and/or modify                            //
+// it under the terms of the GNU General Public License as published by                          //
+// the Free Software Foundation, either version 2 of the License, or                             //
+// (at your option) any later version.                                                           //
+//                                                                                               //
+// Magic Cube is distributed in the hope that it will be useful,                                 //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //
+// GNU General Public License for more details.                                                  //
+//                                                                                               //
+// You should have received a copy of the GNU General Public License                             //
+// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+package org.distorted.objects;
+
+import android.content.res.Resources;
+
+import org.distorted.helpers.ObjectShape;
+import org.distorted.helpers.ObjectSticker;
+import org.distorted.helpers.ScrambleState;
+import org.distorted.library.main.DistortedEffects;
+import org.distorted.library.main.DistortedTexture;
+import org.distorted.library.mesh.MeshSquare;
+import org.distorted.library.type.Static3D;
+import org.distorted.library.type.Static4D;
+import org.distorted.main.R;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+class TwistyMirror extends TwistyObject
+{
+  static final Static3D[] ROT_AXIS = new Static3D[]
+         {
+           new Static3D(1,0,0),
+           new Static3D(0,1,0),
+           new Static3D(0,0,1)
+         };
+
+  private static final int[] FACE_COLORS = new int[] { COLOR_WHITE };
+  private static final float DX = 0.10f;
+  private static final float DY = 0.16f;
+  private static final float DZ = 0.22f;
+
+  private ScrambleState[] mStates;
+  private Static4D[] mQuats;
+  private int[] mBasicAngle;
+  private ObjectSticker[] mStickers;
+  private float[][] mPositions;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  TwistyMirror(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.MIRR, res, scrWidth);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  ScrambleState[] getScrambleStates()
+    {
+    if( mStates==null )
+      {
+      int size = getNumLayers();
+      int[][] m = new int[16][];
+      for(int i=1; i<16; i++) m[i] = createEdges(size,i);
+
+      mStates = new ScrambleState[]
+        {
+        new ScrambleState( new int[][] { m[ 1], m[ 2], m[ 3] } ),  // 0
+        new ScrambleState( new int[][] {  null, m[ 4], m[ 5] } ),  // x
+        new ScrambleState( new int[][] { m[ 6],  null, m[ 7] } ),  // y
+        new ScrambleState( new int[][] { m[ 8], m[ 8],  null } ),  // z
+        new ScrambleState( new int[][] { m[10],  null, m[ 7] } ),  // xy
+        new ScrambleState( new int[][] { m[11], m[ 9],  null } ),  // xz
+        new ScrambleState( new int[][] {  null, m[12], m[ 5] } ),  // yx
+        new ScrambleState( new int[][] { m[ 8], m[13],  null } ),  // yz
+        new ScrambleState( new int[][] {  null, m[ 4], m[14] } ),  // zx
+        new ScrambleState( new int[][] { m[ 6],  null, m[15] } ),  // zy
+        new ScrambleState( new int[][] {  null,  null, m[ 5] } ),  // xyx
+        new ScrambleState( new int[][] {  null, m[ 4],  null } ),  // xzx
+        new ScrambleState( new int[][] {  null,  null, m[ 7] } ),  // yxy
+        new ScrambleState( new int[][] { m[ 6],  null,  null } ),  // yzy
+        new ScrambleState( new int[][] {  null, m[ 9],  null } ),  // zxz
+        new ScrambleState( new int[][] { m[ 8],  null,  null } ),  // zyz
+        };
+      }
+
+    return mStates;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private int[] createEdges(int size, int vertex)
+    {
+    int[] ret = new int[9*size];
+
+    for(int l=0; l<size; l++)
+      {
+      ret[9*l  ] = l;
+      ret[9*l+1] =-1;
+      ret[9*l+2] = vertex;
+      ret[9*l+3] = l;
+      ret[9*l+4] = 1;
+      ret[9*l+5] = vertex;
+      ret[9*l+6] = l;
+      ret[9*l+7] = 2;
+      ret[9*l+8] = vertex;
+      }
+
+    return ret;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private void initializeQuats()
+    {
+    mQuats = new Static4D[]
+         {
+         new Static4D(  0.0f,   0.0f,   0.0f,   1.0f),
+         new Static4D(  1.0f,   0.0f,   0.0f,   0.0f),
+         new Static4D(  0.0f,   1.0f,   0.0f,   0.0f),
+         new Static4D(  0.0f,   0.0f,   1.0f,   0.0f),
+
+         new Static4D( SQ2/2,  SQ2/2,  0.0f ,   0.0f),
+         new Static4D( SQ2/2, -SQ2/2,  0.0f ,   0.0f),
+         new Static4D( SQ2/2,   0.0f,  SQ2/2,   0.0f),
+         new Static4D(-SQ2/2,   0.0f,  SQ2/2,   0.0f),
+         new Static4D( SQ2/2,   0.0f,   0.0f,  SQ2/2),
+         new Static4D( SQ2/2,   0.0f,   0.0f, -SQ2/2),
+         new Static4D(  0.0f,  SQ2/2,  SQ2/2,   0.0f),
+         new Static4D(  0.0f,  SQ2/2, -SQ2/2,   0.0f),
+         new Static4D(  0.0f,  SQ2/2,   0.0f,  SQ2/2),
+         new Static4D(  0.0f,  SQ2/2,   0.0f, -SQ2/2),
+         new Static4D(  0.0f,   0.0f,  SQ2/2,  SQ2/2),
+         new Static4D(  0.0f,   0.0f,  SQ2/2, -SQ2/2),
+
+         new Static4D(  0.5f,   0.5f,   0.5f,   0.5f),
+         new Static4D(  0.5f,   0.5f,  -0.5f,   0.5f),
+         new Static4D(  0.5f,   0.5f,  -0.5f,  -0.5f),
+         new Static4D(  0.5f,  -0.5f,   0.5f,  -0.5f),
+         new Static4D( -0.5f,  -0.5f,  -0.5f,   0.5f),
+         new Static4D( -0.5f,   0.5f,  -0.5f,  -0.5f),
+         new Static4D( -0.5f,   0.5f,   0.5f,  -0.5f),
+         new Static4D( -0.5f,   0.5f,   0.5f,   0.5f)
+         };
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// we cannot do this the standard, automatic way because there's only 1 color in the FACE_COLORS
+// table and retCubitSolvedStatus() always returns -1,-1 or 0.
+
+  int[] getSolvedQuats(int cubit, int numLayers)
+    {
+    if( numLayers==3 )
+      {
+      switch(cubit)
+        {
+        case  4:
+        case 21: return new int[] {1,8,9};
+        case 10:
+        case 15: return new int[] {2,12,13};
+        case 12:
+        case 13: return new int[] {3,14,15};
+        }
+      }
+
+    return null;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getFaceColor(int cubit, int cubitface, int numLayers)
+    {
+    if( numLayers==2 )
+      {
+      switch(cubitface)
+        {
+        case 0: if( cubit==4 ) return 11;
+                if( cubit==5 ) return 10;
+                if( cubit==6 ) return  9;
+                if( cubit==7 ) return  8;
+                return NUM_TEXTURES;
+        case 1: if( cubit==0 ) return 11;
+                if( cubit==1 ) return 10;
+                if( cubit==2 ) return  9;
+                if( cubit==3 ) return  8;
+                return NUM_TEXTURES;
+        case 2: if( cubit==3 ) return  4;
+                if( cubit==7 ) return  5;
+                if( cubit==2 ) return  6;
+                if( cubit==6 ) return  7;
+                return NUM_TEXTURES;
+        case 3: if( cubit==1 ) return  4;
+                if( cubit==5 ) return  5;
+                if( cubit==0 ) return  6;
+                if( cubit==4 ) return  7;
+                return NUM_TEXTURES;
+        case 4: if( cubit==3 ) return  0;
+                if( cubit==7 ) return  1;
+                if( cubit==1 ) return  2;
+                if( cubit==5 ) return  3;
+                return NUM_TEXTURES;
+        case 5: if( cubit==2 ) return  0;
+                if( cubit==6 ) return  1;
+                if( cubit==0 ) return  2;
+                if( cubit==4 ) return  3;
+                return NUM_TEXTURES;
+        }
+      }
+    if( numLayers==3 )
+      {
+      switch(cubitface)
+        {
+        case 0: if( cubit==17 ) return 24;
+                if( cubit==18 ) return 23;
+                if( cubit==19 ) return 22;
+                if( cubit==20 ) return 21;
+                if( cubit==21 ) return  0;
+                if( cubit==22 ) return 20;
+                if( cubit==23 ) return 19;
+                if( cubit==24 ) return 18;
+                if( cubit==25 ) return 17;
+                return NUM_TEXTURES;
+        case 1: if( cubit== 0 ) return 24;
+                if( cubit== 1 ) return 23;
+                if( cubit== 2 ) return 22;
+                if( cubit== 3 ) return 21;
+                if( cubit== 4 ) return  0;
+                if( cubit== 5 ) return 20;
+                if( cubit== 6 ) return 19;
+                if( cubit== 7 ) return 18;
+                if( cubit== 8 ) return 17;
+                return NUM_TEXTURES;
+        case 2: if( cubit== 6 ) return 14;
+                if( cubit==14 ) return  2; // theoretically should have been 15, but this must have gotten collapsed in the Factory
+                if( cubit==23 ) return 16;
+                if( cubit== 7 ) return 12;
+                if( cubit==15 ) return  0;
+                if( cubit==24 ) return 13;
+                if( cubit== 8 ) return  9;
+                if( cubit==16 ) return  6; // ditto, theoretically 10
+                if( cubit==25 ) return 11;
+                return NUM_TEXTURES;
+        case 3: if( cubit== 0 ) return 14;
+                if( cubit== 9 ) return  2; // ditto, theoretically 15
+                if( cubit==17 ) return 16;
+                if( cubit== 1 ) return 12;
+                if( cubit==10 ) return  0;
+                if( cubit==18 ) return 13;
+                if( cubit== 2 ) return  9;
+                if( cubit==11 ) return  6; // ditto, theoretically 10
+                if( cubit==19 ) return 11;
+                return NUM_TEXTURES;
+        case 4: if( cubit== 8 ) return  1;
+                if( cubit==16 ) return  2;
+                if( cubit==25 ) return  3;
+                if( cubit== 5 ) return  4;
+                if( cubit==13 ) return  0;
+                if( cubit==22 ) return  5;
+                if( cubit== 2 ) return  6;
+                if( cubit==11 ) return  7;
+                if( cubit==19 ) return  8;
+                return NUM_TEXTURES;
+        case 5: if( cubit== 6 ) return  1;
+                if( cubit==14 ) return  2;
+                if( cubit==23 ) return  3;
+                if( cubit== 3 ) return  4;
+                if( cubit==12 ) return  0;
+                if( cubit==20 ) return  5;
+                if( cubit== 0 ) return  6;
+                if( cubit== 9 ) return  7;
+                if( cubit==17 ) return  8;
+                return NUM_TEXTURES;
+        }
+      }
+
+    return 0;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private float returnStroke(float x, float y)
+    {
+    return 0.08f/(Math.max(x,y));
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private float[] generateStrokes()
+    {
+    int num = getNumLayers();
+    final float A = 0.08f;
+
+    if( num==2 )
+      {
+      return new float[] {
+                           returnStroke(1-DX,1-DY),
+                           returnStroke(1+DX,1-DY),
+                           returnStroke(1-DX,1+DY),
+                           returnStroke(1+DX,1+DY),
+                           returnStroke(1-DX,1-DZ),
+                           returnStroke(1+DX,1-DZ),
+                           returnStroke(1-DX,1+DZ),
+                           returnStroke(1+DX,1+DZ),
+                           returnStroke(1-DZ,1-DY),
+                           returnStroke(1+DZ,1-DY),
+                           returnStroke(1-DZ,1+DY),
+                           returnStroke(1+DZ,1+DY),
+
+                           A/(1-DX), A/(1+DX), A/(1+DY), A/(1+DY),
+                           A/(1-DX), A/(1+DX), A/(1+DZ), A/(1+DZ),
+                           A/(1-DY), A/(1+DY), A/(1+DZ), A/(1+DZ),
+                         };
+      }
+    else
+      {
+      return new float[] {
+                           returnStroke(1   ,1   ),
+
+                           returnStroke(1-DX,1-DY),
+                           returnStroke(1   ,1-DY),
+                           returnStroke(1+DX,1-DY),
+                           returnStroke(1-DX,1   ),
+                           returnStroke(1+DX,1   ),
+                           returnStroke(1-DX,1+DY),
+                           returnStroke(1   ,1+DY),
+                           returnStroke(1+DX,1+DY),
+
+                           returnStroke(1-DX,1-DZ),
+                           returnStroke(1   ,1-DZ),
+                           returnStroke(1+DX,1-DZ),
+                           returnStroke(1-DX,1   ),
+                           returnStroke(1+DX,1   ),
+                           returnStroke(1-DX,1+DZ),
+                           returnStroke(1   ,1+DZ),
+                           returnStroke(1+DX,1+DZ),
+
+                           returnStroke(1-DZ,1-DY),
+                           returnStroke(1   ,1-DY),
+                           returnStroke(1+DZ,1-DY),
+                           returnStroke(1-DZ,1   ),
+                           returnStroke(1+DZ,1   ),
+                           returnStroke(1-DZ,1+DY),
+                           returnStroke(1   ,1+DY),
+                           returnStroke(1+DZ,1+DY),
+                         };
+      }
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private float[] returnSticker(float x, float y)
+    {
+      float H = 0.5f;
+
+      if( x<y ) { float D=H*x/y; return new float[] {-D,-H,+D,-H,+D,+H,-D,+H}; }
+      else      { float D=H*y/x; return new float[] {-H,-D,+H,-D,+H,+D,-H,+D}; }
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private float[][] generateStickers()
+    {
+    int num = getNumLayers();
+
+    if( num==2 )
+      {
+      return new float[][]
+          {
+              returnSticker(1-DX,1-DY),
+              returnSticker(1+DX,1-DY),
+              returnSticker(1-DX,1+DY),
+              returnSticker(1+DX,1+DY),
+              returnSticker(1-DX,1-DZ),
+              returnSticker(1+DX,1-DZ),
+              returnSticker(1-DX,1+DZ),
+              returnSticker(1+DX,1+DZ),
+              returnSticker(1-DZ,1-DY),
+              returnSticker(1+DZ,1-DY),
+              returnSticker(1-DZ,1+DY),
+              returnSticker(1+DZ,1+DY),
+          };
+      }
+    else
+      {
+      return new float[][]
+          {
+              returnSticker(1   ,1   ),
+
+              returnSticker(1-DX,1-DY),
+              returnSticker(1   ,1-DY),
+              returnSticker(1+DX,1-DY),
+              returnSticker(1-DX,1   ),
+              returnSticker(1+DX,1   ),
+              returnSticker(1-DX,1+DY),
+              returnSticker(1   ,1+DY),
+              returnSticker(1+DX,1+DY),
+
+              returnSticker(1-DX,1-DZ),
+              returnSticker(1   ,1-DZ),
+              returnSticker(1+DX,1-DZ),
+              returnSticker(1-DX,1   ),
+              returnSticker(1+DX,1   ),
+              returnSticker(1-DX,1+DZ),
+              returnSticker(1   ,1+DZ),
+              returnSticker(1+DX,1+DZ),
+
+              returnSticker(1-DZ,1-DY),
+              returnSticker(1   ,1-DY),
+              returnSticker(1+DZ,1-DY),
+              returnSticker(1-DZ,1   ),
+              returnSticker(1+DZ,1   ),
+              returnSticker(1-DZ,1+DY),
+              returnSticker(1   ,1+DY),
+              returnSticker(1+DZ,1+DY),
+          };
+      }
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  ObjectSticker retSticker(int face)
+    {
+    if( mStickers==null )
+      {
+      final float[][] STICKERS = generateStickers();
+      final float[] STROKES = generateStrokes();
+      final int NUM_STICKERS = STICKERS.length;
+      final float radius = 0.10f;
+      final float[] radii = {radius,radius,radius,radius};
+      mStickers = new ObjectSticker[NUM_STICKERS];
+
+      for(int i=0; i<NUM_STICKERS; i++)
+        {
+        mStickers[i] = new ObjectSticker(STICKERS[i],null,radii,STROKES[i]);
+        }
+      }
+
+    return mStickers[face/NUM_FACE_COLORS];
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getNumStickerTypes(int numLayers)
+    {
+    return numLayers==2 ? 12 : 25;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private int getRow(int cubit, int numLayers, int dim)
+    {
+    return (int)(mPositions[cubit][dim] + 0.5f*(numLayers-1));
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  ObjectShape getObjectShape(int cubit, int numLayers)
+    {
+    int extraI, extraV, num;
+    float height;
+
+    switch(numLayers)
+      {
+      case 2 : num = 6; extraI = 2; extraV = 2; height = 0.045f; break;
+      case 3 : num = 5; extraI = 2; extraV = 2; height = 0.045f; break;
+      case 4 : num = 5; extraI = 1; extraV = 1; height = 0.045f; break;
+      default: num = 5; extraI = 0; extraV = 0; height = 0.045f; break;
+      }
+
+    int xrow = getRow(cubit,numLayers,0);
+    int yrow = getRow(cubit,numLayers,1);
+    int zrow = getRow(cubit,numLayers,2);
+
+    float XL = -0.5f + (xrow==          0 ? DX : 0);
+    float XR = +0.5f + (xrow==numLayers-1 ? DX : 0);
+    float YL = -0.5f - (yrow==          0 ? DY : 0);
+    float YR = +0.5f - (yrow==numLayers-1 ? DY : 0);
+    float ZL = -0.5f - (zrow==          0 ? DZ : 0);
+    float ZR = +0.5f - (zrow==numLayers-1 ? DZ : 0);
+
+    double[][] vertices = new double[][]
+          {
+              { XR, YR, ZR },
+              { XR, YR, ZL },
+              { XR, YL, ZR },
+              { XR, YL, ZL },
+              { XL, YR, ZR },
+              { XL, YR, ZL },
+              { XL, YL, ZR },
+              { XL, YL, ZL },
+          };
+
+    int[][] vert_indices = new int[][]
+          {
+              {2,3,1,0},
+              {7,6,4,5},
+              {4,0,1,5},
+              {7,3,2,6},
+              {6,2,0,4},
+              {3,7,5,1}
+          };
+
+    float[][] bands     = new float[][] { {height,35,0.5f,0.7f,num,extraI,extraV} };
+    int[] bandIndices   = new int[] { 0,0,0,0,0,0};
+    float[][] corners   = new float[][] { {0.036f,0.12f} };
+    int[] cornerIndices = new int[] { 0,0,0,0,0,0,0,0 };
+    float[][] centers   = new float[][] { {0.0f, 0.0f, 0.0f} };
+    int[] centerIndices = new int[] { 0,0,0,0,0,0,0,0 };
+
+    return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  Static4D getQuat(int cubit, int numLayers)
+    {
+    if( mQuats ==null ) initializeQuats();
+    return mQuats[0];
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getNumCubitVariants(int numLayers)
+    {
+    return 6*numLayers*numLayers - 12*numLayers + 8;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getCubitVariant(int cubit, int numLayers)
+    {
+    return cubit;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getColor(int face)
+    {
+    return FACE_COLORS[face];
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  float[][] getCubitPositions(int numLayers)
+    {
+    if( mPositions==null )
+      {
+      int numCubits = numLayers>1 ? 6*numLayers*numLayers - 12*numLayers + 8 : 1;
+      mPositions = new float[numCubits][];
+
+      float diff = 0.5f*(numLayers-1);
+      int currentPosition = 0;
+
+      for(int x = 0; x<numLayers; x++)
+        for(int y = 0; y<numLayers; y++)
+          for(int z = 0; z<numLayers; z++)
+            if( x==0 || x==numLayers-1 || y==0 || y==numLayers-1 || z==0 || z==numLayers-1 )
+              {
+              mPositions[currentPosition++] = new float[] {x-diff,y-diff,z-diff};
+              }
+      }
+
+    return mPositions;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  Static4D[] getQuats()
+    {
+    if( mQuats ==null ) initializeQuats();
+    return mQuats;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  boolean shouldResetTextureMaps()
+    {
+    return false;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getNumFaceColors()
+    {
+    return FACE_COLORS.length;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  float[][] getCuts(int numLayers)
+    {
+    float[][] cuts = new float[3][numLayers-1];
+
+    for(int i=0; i<numLayers-1; i++)
+      {
+      float cut = (2-numLayers)*0.5f + i;
+      cuts[0][i] = cut;
+      cuts[1][i] = cut;
+      cuts[2][i] = cut;
+      }
+
+    return cuts;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getSolvedFunctionIndex()
+    {
+    return 0;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getNumCubitFaces()
+    {
+    return 6;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  float getScreenRatio()
+    {
+    return 0.5f;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  float returnMultiplier()
+    {
+    return getNumLayers();
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// PUBLIC API
+
+  public Static3D[] getRotationAxis()
+    {
+    return ROT_AXIS;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public int[] getBasicAngle()
+    {
+    if( mBasicAngle==null ) mBasicAngle = new int[] { 4,4,4 };
+    return mBasicAngle;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public int getObjectName(int numLayers)
+    {
+    switch(numLayers)
+      {
+      case 2: return R.string.mirr2;
+      case 3: return R.string.mirr3;
+      }
+    return R.string.mirr3;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public int getInventor(int numLayers)
+    {
+    switch(numLayers)
+      {
+      case 2: return R.string.mirr2_inventor;
+      case 3: return R.string.mirr3_inventor;
+      }
+    return R.string.mirr3_inventor;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public int getComplexity(int numLayers)
+    {
+    switch(numLayers)
+      {
+      case 2: return 5;
+      case 3: return 7;
+      }
+    return 7;
+    }
+}
diff --git a/src/main/java/org/distorted/objects/TwistyObject.java b/src/main/java/org/distorted/objects/TwistyObject.java
index f9d6c23e..76ed2c8c 100644
--- a/src/main/java/org/distorted/objects/TwistyObject.java
+++ b/src/main/java/org/distorted/objects/TwistyObject.java
@@ -91,7 +91,7 @@ public abstract class TwistyObject extends DistortedNode
   MeshBase[] mMeshes;
   final Static4D[] OBJECT_QUATS;
   final Cubit[] CUBITS;
-  final int NUM_FACES;
+  final int NUM_FACE_COLORS;
   final int NUM_TEXTURES;
   final int NUM_CUBITS;
   final int NUM_AXIS;
@@ -163,8 +163,8 @@ public abstract class TwistyObject extends DistortedNode
 
     OBJECT_QUATS = getQuats();
     NUM_CUBITS  = mOrigPos.length;
-    NUM_FACES = getNumFaces();
-    NUM_TEXTURES = getNumStickerTypes(mNumLayers)*NUM_FACES;
+    NUM_FACE_COLORS = getNumFaceColors();
+    NUM_TEXTURES = getNumStickerTypes(mNumLayers)*NUM_FACE_COLORS;
     NUM_AXIS = mAxis.length;
     NUM_QUATS = OBJECT_QUATS.length;
 
@@ -378,7 +378,7 @@ public abstract class TwistyObject extends DistortedNode
       if( color<NUM_TEXTURES )
         {
         numNonBlack++;
-        nonBlackIndex = color%NUM_FACES;
+        nonBlackIndex = color%NUM_FACE_COLORS;
         }
       }
 
@@ -872,7 +872,7 @@ public abstract class TwistyObject extends DistortedNode
 
   public int getCubitFaceColorIndex(int cubit, int face)
     {
-    Static4D texMap = mMesh.getTextureMap(NUM_FACES*cubit + face);
+    Static4D texMap = mMesh.getTextureMap(NUM_FACE_COLORS*cubit + face);
 
     int x = (int)(texMap.get0()/texMap.get2());
     int y = (int)(texMap.get1()/texMap.get3());
@@ -906,7 +906,7 @@ public abstract class TwistyObject extends DistortedNode
         {
         if( face>=NUM_TEXTURES ) break;
         ObjectSticker sticker = retSticker(face);
-        factory.drawRoundedPolygon(canvas, paint, col*TEXTURE_HEIGHT, row*TEXTURE_HEIGHT, getColor(face%NUM_FACES), sticker);
+        factory.drawRoundedPolygon(canvas, paint, col*TEXTURE_HEIGHT, row*TEXTURE_HEIGHT, getColor(face%NUM_FACE_COLORS), sticker);
         face++;
         }
 
@@ -1285,7 +1285,7 @@ public abstract class TwistyObject extends DistortedNode
   abstract float getScreenRatio();
   abstract float[][] getCubitPositions(int numLayers);
   abstract Static4D[] getQuats();
-  abstract int getNumFaces();
+  abstract int getNumFaceColors();
   abstract int getNumStickerTypes(int numLayers);
   abstract int getNumCubitFaces();
   abstract ObjectSticker retSticker(int face);
diff --git a/src/main/java/org/distorted/objects/TwistyPyraminx.java b/src/main/java/org/distorted/objects/TwistyPyraminx.java
index 883651ea..520f754e 100644
--- a/src/main/java/org/distorted/objects/TwistyPyraminx.java
+++ b/src/main/java/org/distorted/objects/TwistyPyraminx.java
@@ -203,7 +203,7 @@ public class TwistyPyraminx extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
@@ -272,7 +272,7 @@ public class TwistyPyraminx extends TwistyObject
 
   private int faceColor(int cubit, int axis)
     {
-    return CUBITS[cubit].mRotationRow[axis] == 1 ? axis : NUM_FACES;
+    return CUBITS[cubit].mRotationRow[axis] == 1 ? axis : NUM_TEXTURES;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -287,12 +287,12 @@ public class TwistyPyraminx extends TwistyObject
         case 2: return faceColor(cubit,1);
         case 5: return faceColor(cubit,3);
         case 7: return faceColor(cubit,2);
-        default:return NUM_FACES;
+        default:return NUM_TEXTURES;
         }
       }
     else
       {
-      return cubitface<NUM_FACES ? faceColor(cubit,cubitface) : NUM_FACES;
+      return cubitface<NUM_TEXTURES ? faceColor(cubit,cubitface) : NUM_TEXTURES;
       }
     }
 
@@ -375,7 +375,7 @@ public class TwistyPyraminx extends TwistyObject
       mStickers[0] = new ObjectSticker(STICKERS[0],null,radii,stroke);
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyRedi.java b/src/main/java/org/distorted/objects/TwistyRedi.java
index 24031a6f..057c9a4a 100644
--- a/src/main/java/org/distorted/objects/TwistyRedi.java
+++ b/src/main/java/org/distorted/objects/TwistyRedi.java
@@ -139,7 +139,7 @@ public class TwistyRedi extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
@@ -413,7 +413,7 @@ public class TwistyRedi extends TwistyObject
         }
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyRex.java b/src/main/java/org/distorted/objects/TwistyRex.java
index ccecde9f..b1fda998 100644
--- a/src/main/java/org/distorted/objects/TwistyRex.java
+++ b/src/main/java/org/distorted/objects/TwistyRex.java
@@ -132,7 +132,7 @@ public class TwistyRex extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
@@ -480,7 +480,7 @@ public class TwistyRex extends TwistyObject
         }
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistySkewb.java b/src/main/java/org/distorted/objects/TwistySkewb.java
index 3721087d..1d07a0fc 100644
--- a/src/main/java/org/distorted/objects/TwistySkewb.java
+++ b/src/main/java/org/distorted/objects/TwistySkewb.java
@@ -152,7 +152,7 @@ public class TwistySkewb extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
@@ -553,7 +553,7 @@ public class TwistySkewb extends TwistyObject
         }
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistySquare.java b/src/main/java/org/distorted/objects/TwistySquare.java
index 5adbe5e7..4428b962 100644
--- a/src/main/java/org/distorted/objects/TwistySquare.java
+++ b/src/main/java/org/distorted/objects/TwistySquare.java
@@ -122,7 +122,7 @@ abstract class TwistySquare extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
diff --git a/src/main/java/org/distorted/objects/TwistySquare1.java b/src/main/java/org/distorted/objects/TwistySquare1.java
index d0026b9a..e46cd9f9 100644
--- a/src/main/java/org/distorted/objects/TwistySquare1.java
+++ b/src/main/java/org/distorted/objects/TwistySquare1.java
@@ -241,7 +241,7 @@ class TwistySquare1 extends TwistySquare
         }
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistySquare2.java b/src/main/java/org/distorted/objects/TwistySquare2.java
index ea2cd46d..9e96175e 100644
--- a/src/main/java/org/distorted/objects/TwistySquare2.java
+++ b/src/main/java/org/distorted/objects/TwistySquare2.java
@@ -247,7 +247,7 @@ class TwistySquare2 extends TwistySquare
         }
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyUltimate.java b/src/main/java/org/distorted/objects/TwistyUltimate.java
index 44cd2b73..b8ac82bd 100644
--- a/src/main/java/org/distorted/objects/TwistyUltimate.java
+++ b/src/main/java/org/distorted/objects/TwistyUltimate.java
@@ -357,7 +357,7 @@ class TwistyUltimate extends TwistyObject
         }
       }
 
-    return mStickers[face/NUM_FACES];
+    return mStickers[face/NUM_FACE_COLORS];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -391,7 +391,7 @@ class TwistyUltimate extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumFaces()
+  int getNumFaceColors()
     {
     return FACE_COLORS.length;
     }
diff --git a/src/main/java/org/distorted/screens/RubikScreenSolver.java b/src/main/java/org/distorted/screens/RubikScreenSolver.java
index c656b1fe..1dc8956e 100644
--- a/src/main/java/org/distorted/screens/RubikScreenSolver.java
+++ b/src/main/java/org/distorted/screens/RubikScreenSolver.java
@@ -55,10 +55,6 @@ public class RubikScreenSolver extends RubikScreenAbstract
   private int[] mFaceColors;
   private int mNumFaces;
   private float mBitmapSize;
-
-  private ObjectList mCurrentObject;
-  private int mCurrentObjectSize;
-
   private WeakReference<RubikActivity> mWeakAct;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -79,19 +75,17 @@ public class RubikScreenSolver extends RubikScreenAbstract
     int sizeH = (int)(width*RubikActivity.SOLVER_BMP_H_SIZE);
 
     mBitmapSize = Math.min(sizeV,sizeH);
-
     mWeakAct = new WeakReference<>(act);
-
     mSolving = false;
 
-    mCurrentObject     = ImplementedSolversList.getObject(0);
-    mCurrentObjectSize = ImplementedSolversList.getObjectSize(0);
+    ObjectList currentObject= ImplementedSolversList.getObject(0);
+    int currentObjectSize   = ImplementedSolversList.getObjectSize(0);
 
-    act.setupObject(mCurrentObject, mCurrentObjectSize, null);
+    act.setupObject(currentObject, currentObjectSize, null);
     RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();
-    play.setObjectAndSize(act, mCurrentObject, mCurrentObjectSize);
+    play.setObjectAndSize(act, currentObject, currentObjectSize);
 
-    mFaceColors = ObjectList.retFaceColors(mCurrentObject);
+    mFaceColors = ObjectList.retFaceColors(currentObject);
     mNumFaces   = mFaceColors!=null ? mFaceColors.length : 0;
 
     // TOP ////////////////////////////
diff --git a/src/main/res/values/strings.xml b/src/main/res/values/strings.xml
index 6643d0cd..d61b6007 100644
--- a/src/main/res/values/strings.xml
+++ b/src/main/res/values/strings.xml
@@ -100,6 +100,8 @@
     <string name="squa1" translatable="false">Square-1</string>
     <string name="squa2" translatable="false">Square-2</string>
     <string name="jing"  translatable="false">Jing Pyraminx</string>
+    <string name="mirr2"  translatable="false">Mirror Cube</string>
+    <string name="mirr3"  translatable="false">Pocket Mirror</string>
 
     <string name="bandaged_fused"  translatable="false">Fused Cube</string>
     <string name="bandaged_2bar"   translatable="false">2Bar Cube</string>
@@ -132,6 +134,8 @@
     <string name="squa1_inventor" translatable="false">Vojtech Kopsky, Harel Hrsel, 1999</string>
     <string name="squa2_inventor" translatable="false">David Litwin, 1995</string>
     <string name="jing_inventor"  translatable="false">Tony Fisher, 1991</string>
+    <string name="mirr2_inventor" translatable="false">Thomas de Bruin, 2007</string>
+    <string name="mirr3_inventor" translatable="false">Hidetoshi Takeji, 2006</string>
 
     <string name="bandaged_fused_inventor"  translatable="false">who knows</string>
     <string name="bandaged_2bar_inventor"   translatable="false">who knows</string>
