commit 94a4edcf624506d900f0192c986f2c2a68467dbd
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Fri Aug 20 22:44:31 2021 +0200

    Move 1) Jing 2) Kilominx to the new cubit creation scheme.
    Make the Master Kilominx mesh a bit smaller.

diff --git a/src/main/java/org/distorted/objects/TwistyJing.java b/src/main/java/org/distorted/objects/TwistyJing.java
index 6d817149..56c5baa8 100644
--- a/src/main/java/org/distorted/objects/TwistyJing.java
+++ b/src/main/java/org/distorted/objects/TwistyJing.java
@@ -22,6 +22,7 @@ package org.distorted.objects;
 import android.content.res.Resources;
 
 import org.distorted.helpers.FactoryCubit;
+import org.distorted.helpers.ObjectShape;
 import org.distorted.helpers.ObjectSticker;
 import org.distorted.library.effect.MatrixEffectQuaternion;
 import org.distorted.library.main.DistortedEffects;
@@ -291,91 +292,87 @@ public class TwistyJing extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  MeshBase createCubitMesh(int cubit, int numLayers)
+  ObjectShape getObjectShape(int cubit, int numLayers)
     {
-    if( mMeshes==null )
-      {
-      FactoryCubit factory = FactoryCubit.getInstance();
-      factory.clear();
-      mMeshes = new MeshBase[3];
-      }
-
-    MeshBase mesh;
+    int variant = getCubitVariant(cubit,numLayers);
 
-    if( cubit<4 )
+    if( variant==0 )
       {
-      if( mMeshes[0]==null )
-        {
-        float[][] bands     = new float[][] { {0.015f,35,0.5f*F,F,5,1,1},{0.001f,35,0.5f*F,F,5,1,1} };
-        int[] bandIndexes   = new int[] { 0,0,0,1,1,1 };
-        float[][] corners   = new float[][] { {0.08f,0.20f*F},{0.07f,0.20f*F} };
-        int[] cornerIndexes = new int[] { 0,1,1,-1,1,-1,-1,-1 };
-        float[][] centers   = new float[][] { { 0.0f, F*SQ2/2, -F} };
-        int[] centerIndexes = new int[] { 0,0,0,-1,0,-1,-1,-1 };
-
-        FactoryCubit factory = FactoryCubit.getInstance();
-
-        factory.createNewFaceTransform(VERTICES_CORNER,VERT_INDEXES_CORNER);
-        mMeshes[0] = factory.createRoundedSolid(VERTICES_CORNER, VERT_INDEXES_CORNER,
-                                                bands, bandIndexes,
-                                                corners, cornerIndexes,
-                                                centers, centerIndexes,
-                                                getNumCubitFaces(), null );
-        }
-      mesh = mMeshes[0].copy(true);
+      float[][] bands     = new float[][] { {0.015f,35,0.5f*F,F,5,1,1},{0.001f,35,0.5f*F,F,5,1,1} };
+      int[] bandIndices   = new int[] { 0,0,0,1,1,1 };
+      float[][] corners   = new float[][] { {0.08f,0.20f*F},{0.07f,0.20f*F} };
+      int[] cornerIndices = new int[] { 0,1,1,-1,1,-1,-1,-1 };
+      float[][] centers   = new float[][] { { 0.0f, F*SQ2/2, -F} };
+      int[] centerIndices = new int[] { 0,0,0,-1,0,-1,-1,-1 };
+      return new ObjectShape(VERTICES_CORNER,VERT_INDEXES_CORNER,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
       }
-    else if( cubit<10 )
+    else if( variant==1 )
       {
-      if( mMeshes[1]==null )
-        {
-        float[][] bands     = new float[][] { {0.015f,35,0.5f*F,F,5,1,1},{0.001f,35,0.5f*F,F,5,1,1} };
-        int[] bandIndexes   = new int[] { 0,0,1,1,1,1 };
-        float[][] corners   = new float[][] { {0.07f,0.20f*F} };
-        int[] cornerIndexes = new int[] { 0,0,-1,0,0,0,-1,0 };
-        float[][] centers   = new float[][] { { 0, F*SQ2/2, 0 } };
-        int[] centerIndexes = new int[] { 0,0,-1,0,0,0,-1,0 };
-
-        FactoryCubit factory = FactoryCubit.getInstance();
-
-        factory.createNewFaceTransform(VERTICES_EDGE,VERT_INDEXES_EDGE);
-        mMeshes[1] = factory.createRoundedSolid(VERTICES_EDGE, VERT_INDEXES_EDGE,
-                                                bands, bandIndexes,
-                                                corners, cornerIndexes,
-                                                centers, centerIndexes,
-                                                getNumCubitFaces(), null );
-
-        factory.printStickerCoords();
-        }
-      mesh = mMeshes[1].copy(true);
+      float[][] bands     = new float[][] { {0.015f,35,0.5f*F,F,5,1,1},{0.001f,35,0.5f*F,F,5,1,1} };
+      int[] bandIndices   = new int[] { 0,0,1,1,1,1 };
+      float[][] corners   = new float[][] { {0.07f,0.20f*F} };
+      int[] cornerIndices = new int[] { 0,0,-1,0,0,0,-1,0 };
+      float[][] centers   = new float[][] { { 0, F*SQ2/2, 0 } };
+      int[] centerIndices = new int[] { 0,0,-1,0,0,0,-1,0 };
+      return new ObjectShape(VERTICES_EDGE,VERT_INDEXES_EDGE,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
       }
     else
       {
-      if( mMeshes[2]==null )
-        {
-        float[][] bands     = new float[][] { {0.020f,35,0.20f*(1-3*F),0.6f*(1-3*F),5,1,1},
+      float[][] bands     = new float[][] { {0.020f,35,0.20f*(1-3*F),0.6f*(1-3*F),5,1,1},
                                               {0.001f,35,0.05f*(1-3*F),0.1f*(1-3*F),5,1,1} };
-        int[] bandIndexes   = new int[] { 0,1,1,1,1,1 };
-        float[][] corners   = new float[][] { {0.04f,0.15f} };
-        int[] cornerIndexes = new int[] { 0,0,0,-1,-1,-1 };
-        float[][] centers   = new float[][] { { 0, -2*Y/3, 4*Z/3 } };
-        int[] centerIndexes = new int[] { 0,0,0,-1,-1,-1 };
-
-        FactoryCubit factory = FactoryCubit.getInstance();
-
-        factory.createNewFaceTransform(VERTICES_FACE,VERT_INDEXES_FACE);
-        mMeshes[2] = factory.createRoundedSolid(VERTICES_FACE, VERT_INDEXES_FACE,
-                                                bands, bandIndexes,
-                                                corners, cornerIndexes,
-                                                centers, centerIndexes,
-                                                getNumCubitFaces(), null );
-
-        factory.printStickerCoords();
-        }
-      mesh = mMeshes[2].copy(true);
+      int[] bandIndices   = new int[] { 0,1,1,1,1,1 };
+      float[][] corners   = new float[][] { {0.04f,0.15f} };
+      int[] cornerIndices = new int[] { 0,0,0,-1,-1,-1 };
+      float[][] centers   = new float[][] { { 0, -2*Y/3, 4*Z/3 } };
+      int[] centerIndices = new int[] { 0,0,0,-1,-1,-1 };
+      return new ObjectShape(VERTICES_FACE,VERT_INDEXES_FACE,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+      }
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private Static4D getQuat(int cubit, int numLayers)
+    {
+    return QUATS[ROT_QUAT[cubit]];
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private int getNumCubitVariants(int numLayers)
+    {
+    return 3;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getCubitVariant(int cubit, int numLayers)
+    {
+    return cubit<4 ? 0 : (cubit<10?1:2);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  MeshBase createCubitMesh(int cubit, int numLayers)
+    {
+    int variant = getCubitVariant(cubit,numLayers);
+
+    if( mMeshes==null )
+      {
+      FactoryCubit factory = FactoryCubit.getInstance();
+      factory.clear();
+      mMeshes = new MeshBase[getNumCubitVariants(numLayers)];
+      }
+
+    if( mMeshes[variant]==null )
+      {
+      ObjectShape shape = getObjectShape(cubit,numLayers);
+      FactoryCubit factory = FactoryCubit.getInstance();
+      factory.createNewFaceTransform(shape);
+      mMeshes[variant] = factory.createRoundedSolid(shape);
       }
 
-    int q = ROT_QUAT[cubit];
-    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( QUATS[q], new Static3D(0,0,0) );
+    MeshBase mesh = mMeshes[variant].copy(true);
+    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit,numLayers), new Static3D(0,0,0) );
     mesh.apply(quat,0xffffffff,0);
 
     return mesh;
diff --git a/src/main/java/org/distorted/objects/TwistyKilominx.java b/src/main/java/org/distorted/objects/TwistyKilominx.java
index e480726f..9b628a86 100644
--- a/src/main/java/org/distorted/objects/TwistyKilominx.java
+++ b/src/main/java/org/distorted/objects/TwistyKilominx.java
@@ -22,6 +22,7 @@ package org.distorted.objects;
 import android.content.res.Resources;
 
 import org.distorted.helpers.FactoryCubit;
+import org.distorted.helpers.ObjectShape;
 import org.distorted.helpers.ObjectSticker;
 import org.distorted.helpers.QuatHelper;
 import org.distorted.library.effect.MatrixEffectQuaternion;
@@ -360,73 +361,71 @@ public class TwistyKilominx extends TwistyMinx
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private MeshBase createCenterMesh(float width)
+  ObjectShape getObjectShape(int cubit, int numLayers)
     {
-    double X = width*COS18*SIN_HALFD;
-    double Y = width*SIN18;
-    double Z = width*COS18*COS_HALFD;
-    double H = width*(SIN54/COS54);
-    double H3= H/COS_HALFD;
-    double X3= H*SIN_HALFD;
-    double Z3= H*COS_HALFD;
-    double C = 1/(COS54*Math.sqrt(2-2*SIN18));
-
-    double[][] vertices = new double[][]
+    int variant = getCubitVariant(cubit,numLayers);
+    int numVariants = getNumCubitVariants(numLayers);
+
+    if( variant==0 )
+      {
+      float width = (numLayers/3.0f)/(numLayers-1);
+      float A = (2*SQ3/3)*SIN54;
+      float B = 0.4f;
+      double X = width*COS18*SIN_HALFD;
+      double Y = width*SIN18;
+      double Z = width*COS18*COS_HALFD;
+
+      double[][] vertices = new double[][]
         {
-            { 0.0, 0.0  ,   0.0 },
-            {   X,   Y  ,    -Z },
-            { 0.0,C*2*Y ,-2*C*Z },
-            {  -X,   Y  ,    -Z },
-            { 0.0,-width,   0.0 },
-            {  X3,-width,   -Z3 },
-            { 0.0,-width,   -H3 },
-            { -X3,-width,   -Z3 }
+            { 0.0, 0.0      , 0.0 },
+            {   X,   Y      ,  -Z },
+            { 0.0, 2*Y      ,-2*Z },
+            {  -X,   Y      ,  -Z },
+            { 0.0, 0.0-width, 0.0 },
+            {   X,   Y-width,  -Z },
+            { 0.0, 2*Y-width,-2*Z },
+            {  -X,   Y-width,  -Z },
         };
 
-    int[][] vertIndexes = new int[][]
+      int[][] vertIndexes = new int[][]
         {
             {4,5,1,0},
             {7,4,0,3},
             {0,1,2,3},
-            {7,6,2,3},
+            {4,5,6,7},
             {6,5,1,2},
-            {4,5,6,7}
+            {7,6,2,3}
         };
 
-    float[][] bands = new float[][]
-      {
-         {0.04f,17,0.3f,0.2f,4,1,1},
-         {0.00f,17,0.3f,0.2f,4,1,1}
-      };
-
-    float A = (2*SQ3/3)*SIN54;
-    float B = 0.4f;
-
-    int[] bandIndexes   = new int[] { 0,0,0,1,1,1};
-    float[][] corners   = new float[][] { {0.03f,0.10f} };
-    int[] cornerIndexes = new int[] { 0, 0,-1, 0, 0,-1,-1,-1 };
-    float[][] centers   = new float[][] { {0.0f, -(float)Math.sqrt(1-A*A)*B,-A*B} };
-    int[] centerIndexes = new int[] { 0, 0,-1, 0, 0,-1,-1,-1 };
-
-    FactoryCubit factory = FactoryCubit.getInstance();
-    factory.createNewFaceTransform(vertices,vertIndexes);
-
-    return factory.createRoundedSolid(vertices, vertIndexes,
-                                      bands, bandIndexes,
-                                      corners, cornerIndexes,
-                                      centers, centerIndexes,
-                                      getNumCubitFaces(), null );
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
+      float[][] bands     = new float[][]
+        {
+         {0.04f,34,0.3f,0.2f, 3, 1, 0},
+         {0.00f, 0,0.0f,0.0f, 2, 1, 0}
+        };
 
-  private MeshBase createEdgeMesh(int numLayers, float width, float height, boolean left)
-    {
-    double X = height*SIN_HALFD;
-    double Y = height*SIN18/COS18;
-    double Z = height*COS_HALFD;
+      int[] bandIndices   = new int[] { 0,0,0,1,1,1};
+      float[][] corners   = new float[][] { {0.04f,0.10f} };
+      int[] cornerIndices = new int[] { 0,-1,-1,-1,-1,-1,-1,-1 };
+      float[][] centers   = new float[][] { {0.0f, -(float)Math.sqrt(1-A*A)*B,-A*B} };
+      int[] centerIndices = new int[] { 0,-1,-1,-1,-1,-1,-1,-1 };
 
-    double[][] vertices = new double[][]
+      return new ObjectShape(vertices,vertIndexes,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+      }
+    if( variant<numVariants-1 )
+      {
+      int numCubitsPerCorner = numCubitsPerCorner(numLayers);
+      int numCubitsPerEdge   = numCubitsPerEdge(numLayers);
+      int type = computeEdgeType(cubit,numCubitsPerCorner,numCubitsPerEdge);
+      float tmpVal= (numLayers/3.0f)/(numLayers-1);
+      float height= tmpVal*COS18;
+      float width = tmpVal + (type/2)*tmpVal*SIN18;
+      boolean left = (type%2)==0;
+
+      double X = height*SIN_HALFD;
+      double Y = height*SIN18/COS18;
+      double Z = height*COS_HALFD;
+
+      double[][] vertices = new double[][]
         {
             { 0.0, 0.0   , 0.0 },
             {   X,   Y   ,  -Z },
@@ -438,7 +437,7 @@ public class TwistyKilominx extends TwistyMinx
             {  -X, -width,  -Z },
         };
 
-    int[][] vertIndexes = new int[][]
+      int[][] vertIndexes = new int[][]
         {
             {4,5,1,0},
             {7,4,0,3},
@@ -448,98 +447,163 @@ public class TwistyKilominx extends TwistyMinx
             {4,5,6,7}
         };
 
-    if( !left )
-      {
-      int tmp, len = vertices.length;
-      for(int i=0; i<len; i++) vertices[i][1] = -vertices[i][1];
-
-      len = vertIndexes.length;
-      for(int i=0; i<len; i++)
+      if( !left )
         {
-        tmp = vertIndexes[i][0];
-        vertIndexes[i][0] = vertIndexes[i][3];
-        vertIndexes[i][3] = tmp;
+        int tmp, len = vertices.length;
+        for(int i=0; i<len; i++) vertices[i][1] = -vertices[i][1];
 
-        tmp = vertIndexes[i][1];
-        vertIndexes[i][1] = vertIndexes[i][2];
-        vertIndexes[i][2] = tmp;
+        len = vertIndexes.length;
+        for(int i=0; i<len; i++)
+          {
+          tmp = vertIndexes[i][0];
+          vertIndexes[i][0] = vertIndexes[i][3];
+          vertIndexes[i][3] = tmp;
+          tmp = vertIndexes[i][1];
+          vertIndexes[i][1] = vertIndexes[i][2];
+          vertIndexes[i][2] = tmp;
+          }
         }
-      }
 
-    int numBands0 = numLayers<=5 ? 5 : 3;
-    int numBands1 = numLayers<=5 ? 3 : 2;
+      int numBands0 = numLayers<=5 ? 4 : 3;
+      int numBands1 = numLayers<=5 ? 3 : 2;
 
-    float[][] bands     = new float[][]
-      {
+      float[][] bands     = new float[][]
+        {
          {0.04f,34,0.2f,0.2f,numBands0,1,1},
          {0.00f, 0,0.0f,0.0f,numBands1,0,0}
-      };
-    int[] bandIndexes   = new int[] { 0,0,1,1,1,1};
-    float[][] corners   = new float[][] { {0.04f,0.10f} };
-    int[] cornerIndexes = new int[] { 0,-1,-1,-1, 0,-1,-1,-1 };
-    float[][] centers   = new float[][] { {0.0f, -width/2, (float)(-2*Z)} };
-    int[] centerIndexes = new int[] { 0,-1,-1,-1, 0,-1,-1,-1 };
-
-    FactoryCubit factory = FactoryCubit.getInstance();
-    factory.createNewFaceTransform(vertices,vertIndexes);
-
-    return factory.createRoundedSolid(vertices, vertIndexes,
-                                      bands, bandIndexes,
-                                      corners, cornerIndexes,
-                                      centers, centerIndexes,
-                                      getNumCubitFaces(), null );
+        };
+
+      int[] bandIndices   = new int[] { 0,0,1,1,1,1};
+      float[][] corners   = new float[][] { {0.04f,0.10f} };
+      int[] cornerIndices = new int[] { 0,-1,-1,-1, 0,-1,-1,-1 };
+      float[][] centers   = new float[][] { {0.0f, -width/2, (float)(-2*Z)} };
+      int[] centerIndices = new int[] { 0,-1,-1,-1, 0,-1,-1,-1 };
+
+      return new ObjectShape(vertices,vertIndexes,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+      }
+    else
+      {
+      float width = (1+0.5f*(numLayers-3)*SIN18)*(numLayers/3.0f)/(numLayers-1);
+
+      double X = width*COS18*SIN_HALFD;
+      double Y = width*SIN18;
+      double Z = width*COS18*COS_HALFD;
+      double H = width*(SIN54/COS54);
+      double H3= H/COS_HALFD;
+      double X3= H*SIN_HALFD;
+      double Z3= H*COS_HALFD;
+      double C = 1/(COS54*Math.sqrt(2-2*SIN18));
+      int N = numLayers==3 ? 4 : 3;
+      int E = numLayers==3 ? 1 : 0;
+
+      double[][] vertices = new double[][]
+        {
+            { 0.0, 0.0  ,   0.0 },
+            {   X,   Y  ,    -Z },
+            { 0.0,C*2*Y ,-2*C*Z },
+            {  -X,   Y  ,    -Z },
+            { 0.0,-width,   0.0 },
+            {  X3,-width,   -Z3 },
+            { 0.0,-width,   -H3 },
+            { -X3,-width,   -Z3 }
+        };
+
+      int[][] vertIndexes = new int[][]
+        {
+            {4,5,1,0},
+            {7,4,0,3},
+            {0,1,2,3},
+            {7,6,2,3},
+            {6,5,1,2},
+            {4,5,6,7}
+        };
+
+      float[][] bands = new float[][]
+        {
+         {0.04f,17,0.3f,0.2f,N,1,E},
+         {0.00f,17,0.3f,0.2f,N,1,E}
+        };
+
+      float A = (2*SQ3/3)*SIN54;
+      float B = 0.4f;
+
+      int[] bandIndices   = new int[] { 0,0,0,1,1,1};
+      float[][] corners   = new float[][] { {0.03f,0.10f} };
+      int[] cornerIndices = new int[] { 0, 0,-1, 0, 0,-1,-1,-1 };
+      float[][] centers   = new float[][] { {0.0f, -(float)Math.sqrt(1-A*A)*B,-A*B} };
+      int[] centerIndices = new int[] { 0, 0,-1, 0, 0,-1,-1,-1 };
+
+      return new ObjectShape(vertices,vertIndexes,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  MeshBase createCubitMesh(int cubit, int numLayers)
+  private Static4D getQuat(int cubit, int numLayers)
     {
     int numCubitsPerCorner = numCubitsPerCorner(numLayers);
     int numCubitsPerEdge   = numCubitsPerEdge(numLayers);
+
+    return QUATS[getQuat(cubit,numCubitsPerCorner,numCubitsPerEdge)];
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private int getNumCubitVariants(int numLayers)
+    {
     int[] sizes = ObjectList.KILO.getSizes();
     int variants = sizes.length;
     int highestSize = sizes[variants-1];
-    MeshBase mesh;
 
-    if( mMeshes==null ) mMeshes = new MeshBase[highestSize-1];
+    return highestSize-1;
+    }
 
-    if( cubit < NUM_CORNERS*numCubitsPerCorner )
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getCubitVariant(int cubit, int numLayers)
+    {
+    int numCubitsPerCorner = numCubitsPerCorner(numLayers);
+
+    if( cubit<NUM_CORNERS*numCubitsPerCorner ) return 0;
+
+    int numCubitsPerEdge   = numCubitsPerEdge(numLayers);
+
+    if( cubit<NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge )
       {
-      if( mMeshes[0]==null )
-        {
-        float width = (numLayers/3.0f)/(numLayers-1);
-        mMeshes[0] = createCornerMesh(numLayers,width);
-        }
-      mesh = mMeshes[0].copy(true);
+      int type = computeEdgeType(cubit,numCubitsPerCorner,numCubitsPerEdge);
+      return type+1;
       }
-    else if( cubit<NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge )
-      {
-      int type = computeEdgeType(cubit,numCubitsPerCorner,numCubitsPerEdge);  // left-top, right-top, left-second, right-second, left-third...
 
-      if( mMeshes[1+type]==null )
-        {
-        float tmp   = (numLayers/3.0f)/(numLayers-1);
-        float height= tmp*COS18;
-        float width = tmp + (type/2)*tmp*SIN18;
+    int[] sizes = ObjectList.KILO.getSizes();
+    int variants = sizes.length;
+    int highestSize = sizes[variants-1];
 
-        mMeshes[1+type] = createEdgeMesh(numLayers,width,height, (type%2)==0 );
-        }
+    return highestSize-2;
+    }
 
-      mesh = mMeshes[1+type].copy(true);
-      }
-    else
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  MeshBase createCubitMesh(int cubit, int numLayers)
+    {
+    int variant = getCubitVariant(cubit,numLayers);
+
+    if( mMeshes==null )
       {
-      if( mMeshes[highestSize-2]==null )
-        {
-        float width = (1+0.5f*(numLayers-3)*SIN18)*(numLayers/3.0f)/(numLayers-1);
-        mMeshes[highestSize-2] = createCenterMesh(width);
-        }
+      FactoryCubit factory = FactoryCubit.getInstance();
+      factory.clear();
+      mMeshes = new MeshBase[getNumCubitVariants(numLayers)];
+      }
 
-      mesh = mMeshes[highestSize-2].copy(true);
+    if( mMeshes[variant]==null )
+      {
+      ObjectShape shape = getObjectShape(cubit,numLayers);
+      FactoryCubit factory = FactoryCubit.getInstance();
+      factory.createNewFaceTransform(shape);
+      mMeshes[variant] = factory.createRoundedSolid(shape);
       }
 
-    Static4D q = QUATS[getQuat(cubit,numCubitsPerCorner,numCubitsPerEdge)];
-    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( q, new Static3D(0,0,0) );
+    MeshBase mesh = mMeshes[variant].copy(true);
+    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit,numLayers), new Static3D(0,0,0) );
     mesh.apply(quat,0xffffffff,0);
 
     return mesh;