commit f10a88a81663c5a6de7723ee0a8b174736ec8b60
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Fri Aug 20 00:39:08 2021 +0200

    Move 1) bandaged 3x3 2) normals cubes 3) octahedrons 4) both dinos to the new cubit creation scheme.

diff --git a/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java b/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java
index a5c81b0d..397eedf2 100644
--- a/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java
+++ b/src/main/java/org/distorted/objects/TwistyBandagedAbstract.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;
@@ -165,124 +166,144 @@ abstract class TwistyBandagedAbstract extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getCubitVariant(int cubit)
+  int getNumCubits()
+    {
+    return getPositions().length;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private float[] getCubitPosition(int cubit)
     {
     float[][] pos = getPositions();
 
-    if( cubit>=0 && cubit<pos.length )
-      {
-      int numPoints = pos[cubit].length/3;
-      return numPoints==8 ? 4 : numPoints-1;
-      }
+    return ( cubit>=0 && cubit< pos.length ) ? pos[cubit] : null;
+    }
 
-    return 1;
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private int getQuatIndex(int cubit)
+    {
+    int[] indices = getQuatIndices();
+    return ( cubit>=0 && cubit< indices.length ) ? indices[cubit] : 0;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getNumCubits()
+  private Static4D getQuat(int cubit, int numLayers)
     {
-    return getPositions().length;
+    return INIT_QUATS[getQuatIndex(cubit)];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private float[] getCubitPosition(int cubit)
+  private int getNumCubitVariants(int numLayers)
+    {
+    return mDimensions.length;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getCubitVariant(int cubit, int numLayers)
     {
     float[][] pos = getPositions();
 
-    return ( cubit>=0 && cubit< pos.length ) ? pos[cubit] : null;
+    if( cubit>=0 && cubit<pos.length )
+      {
+      int numPoints = pos[cubit].length/3;
+      return numPoints==8 ? 4 : numPoints-1;
+      }
+
+    return 1;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private int getQuatIndex(int cubit)
+  ObjectShape getObjectShape(int cubit, int numLayers)
     {
-    int[] indices = getQuatIndices();
+    int variant = getCubitVariant(cubit,numLayers);
 
-    return ( cubit>=0 && cubit< indices.length ) ? indices[cubit] : 0;
+    final int[][] vert_indices =
+      {
+        {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 defHeight = 0.048f;
+    int[] bandIndices = new int[] { 0,0,1,1,2,2 };
+    float[][] corners = new float[][] { {0.04f,0.15f} };
+    int[] cornerIndices = new int[] { 0,0,0,0,0,0,0,0 };
+    int[] centerIndices = new int[] { 0,1,2,3,4,5,6,7 };
+
+    int X = mDimensions[variant][0];
+    int Y = mDimensions[variant][1];
+    int Z = mDimensions[variant][2];
+
+    int maxXY = Math.max(X,Y);
+    int maxXZ = Math.max(X,Z);
+    int maxYZ = Math.max(Y,Z);
+
+    double[][] vertices =
+      {
+        {+0.5f*X,+0.5f*Y,+0.5f*Z},
+        {+0.5f*X,+0.5f*Y,-0.5f*Z},
+        {+0.5f*X,-0.5f*Y,+0.5f*Z},
+        {+0.5f*X,-0.5f*Y,-0.5f*Z},
+        {-0.5f*X,+0.5f*Y,+0.5f*Z},
+        {-0.5f*X,+0.5f*Y,-0.5f*Z},
+        {-0.5f*X,-0.5f*Y,+0.5f*Z},
+        {-0.5f*X,-0.5f*Y,-0.5f*Z}
+      };
+
+    float[][] bands= new float[][]
+      {
+        {defHeight/maxYZ,65,0.25f,0.5f,5,1,2},
+        {defHeight/maxXZ,65,0.25f,0.5f,5,1,2},
+        {defHeight/maxXY,65,0.25f,0.5f,5,1,2}
+      };
+
+    float[][] centers = new float[][]
+      {
+        {+0.5f*(X-1),+0.5f*(Y-1),+0.5f*(Z-1)},
+        {+0.5f*(X-1),+0.5f*(Y-1),-0.5f*(Z-1)},
+        {+0.5f*(X-1),-0.5f*(Y-1),+0.5f*(Z-1)},
+        {+0.5f*(X-1),-0.5f*(Y-1),-0.5f*(Z-1)},
+        {-0.5f*(X-1),+0.5f*(Y-1),+0.5f*(Z-1)},
+        {-0.5f*(X-1),+0.5f*(Y-1),-0.5f*(Z-1)},
+        {-0.5f*(X-1),-0.5f*(Y-1),+0.5f*(Z-1)},
+        {-0.5f*(X-1),-0.5f*(Y-1),-0.5f*(Z-1)}
+      };
+
+    return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   MeshBase createCubitMesh(int cubit, int numLayers)
     {
+    int variant = getCubitVariant(cubit,numLayers);
+
     if( mMeshes==null )
       {
       FactoryCubit factory = FactoryCubit.getInstance();
       factory.clear();
-      int LEN = mDimensions.length;
-      mMeshes = new MeshBase[LEN];
-
-      final int[][] vert_indices =
-          {
-              {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 defHeight = 0.048f;
-      int[] bandIndexes = new int[] { 0,0,1,1,2,2 };
-      float[][] corners = new float[][] { {0.04f,0.15f} };
-      int[] cornerIndexes = new int[] { 0,0,0,0,0,0,0,0 };
-      int[] centerIndexes = new int[] { 0,1,2,3,4,5,6,7 };
-
-      for(int i=0; i<LEN; i++)
-        {
-        int X = mDimensions[i][0];
-        int Y = mDimensions[i][1];
-        int Z = mDimensions[i][2];
-
-        int maxXY = Math.max(X,Y);
-        int maxXZ = Math.max(X,Z);
-        int maxYZ = Math.max(Y,Z);
-
-        double[][] vertices =
-            {
-                {+0.5f*X,+0.5f*Y,+0.5f*Z},
-                {+0.5f*X,+0.5f*Y,-0.5f*Z},
-                {+0.5f*X,-0.5f*Y,+0.5f*Z},
-                {+0.5f*X,-0.5f*Y,-0.5f*Z},
-                {-0.5f*X,+0.5f*Y,+0.5f*Z},
-                {-0.5f*X,+0.5f*Y,-0.5f*Z},
-                {-0.5f*X,-0.5f*Y,+0.5f*Z},
-                {-0.5f*X,-0.5f*Y,-0.5f*Z}
-            };
-
-        float[][] bands= new float[][]
-            {
-                {defHeight/maxYZ,65,0.25f,0.5f,5,1,2},
-                {defHeight/maxXZ,65,0.25f,0.5f,5,1,2},
-                {defHeight/maxXY,65,0.25f,0.5f,5,1,2}
-            };
-
-        float[][] centers = new float[][]
-            {
-                {+0.5f*(X-1),+0.5f*(Y-1),+0.5f*(Z-1)},
-                {+0.5f*(X-1),+0.5f*(Y-1),-0.5f*(Z-1)},
-                {+0.5f*(X-1),-0.5f*(Y-1),+0.5f*(Z-1)},
-                {+0.5f*(X-1),-0.5f*(Y-1),-0.5f*(Z-1)},
-                {-0.5f*(X-1),+0.5f*(Y-1),+0.5f*(Z-1)},
-                {-0.5f*(X-1),+0.5f*(Y-1),-0.5f*(Z-1)},
-                {-0.5f*(X-1),-0.5f*(Y-1),+0.5f*(Z-1)},
-                {-0.5f*(X-1),-0.5f*(Y-1),-0.5f*(Z-1)}
-            };
-
-        factory.createNewFaceTransform(vertices,vert_indices);
-        mMeshes[i] = factory.createRoundedSolid(vertices,vert_indices,
-                                                bands, bandIndexes,
-                                                corners, cornerIndexes,
-                                                centers, centerIndexes,
-                                                getNumCubitFaces(), null );
-        }
+      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 variant = getCubitVariant(cubit);
     MeshBase mesh = mMeshes[variant].copy(true);
-    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( INIT_QUATS[getQuatIndex(cubit)], new Static3D(0,0,0) );
+    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit,numLayers), new Static3D(0,0,0) );
     mesh.apply(quat,0xffffffff,0);
 
     return mesh;
@@ -408,7 +429,7 @@ abstract class TwistyBandagedAbstract extends TwistyObject
 
   int getFaceColor(int cubit, int cubitface, int numLayers)
     {
-    int variant      = getCubitVariant(cubit);
+    int variant      = getCubitVariant(cubit,numLayers);
     int[] dim        = mDimensions[variant];
     float[] pos      = getCubitPosition(cubit);
     int stickerIndex = getStickerIndex(cubitface,dim);
diff --git a/src/main/java/org/distorted/objects/TwistyCube.java b/src/main/java/org/distorted/objects/TwistyCube.java
index 5f8280ed..5f05244b 100644
--- a/src/main/java/org/distorted/objects/TwistyCube.java
+++ b/src/main/java/org/distorted/objects/TwistyCube.java
@@ -22,7 +22,9 @@ 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;
 import org.distorted.library.main.DistortedTexture;
 import org.distorted.library.mesh.MeshBase;
@@ -137,48 +139,78 @@ class TwistyCube extends TwistyObject
     super(size, size, quat, texture, mesh, effects, moves, ObjectList.CUBE, res, scrWidth);
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private Static4D getQuat(int cubit, int numLayers)
+    {
+    return QUATS[0];
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private int getNumCubitVariants(int numLayers)
+    {
+    return 1;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getCubitVariant(int cubit, int numLayers)
+    {
+    return 0;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  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;
+      }
+
+    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_INDEXES,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   MeshBase createCubitMesh(int cubit, int numLayers)
     {
+    int variant = getCubitVariant(cubit,numLayers);
+
     if( mMeshes==null )
       {
       FactoryCubit factory = FactoryCubit.getInstance();
       factory.clear();
-      mMeshes = new MeshBase[1];
+      mMeshes = new MeshBase[getNumCubitVariants(numLayers)];
       }
 
-    if( mMeshes[0]==null )
+    if( mMeshes[variant]==null )
       {
-      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;
-        }
-
-      float[][] bands     = new float[][] { {height,35,0.5f,0.7f,num,extraI,extraV} };
-      int[] bandIndexes   = new int[] { 0,0,0,0,0,0};
-      float[][] corners   = new float[][] { {0.036f,0.12f} };
-      int[] cornerIndexes = new int[] { 0,0,0,0,0,0,0,0 };
-      float[][] centers   = new float[][] { {0.0f, 0.0f, 0.0f} };
-      int[] centerIndexes = new int[] { 0,0,0,0,0,0,0,0 };
-
+      ObjectShape shape = getObjectShape(cubit,numLayers);
       FactoryCubit factory = FactoryCubit.getInstance();
-
-      factory.createNewFaceTransform(VERTICES,VERT_INDEXES);
-      mMeshes[0] = factory.createRoundedSolid(VERTICES, VERT_INDEXES,
-                                              bands, bandIndexes,
-                                              corners, cornerIndexes,
-                                              centers, centerIndexes,
-                                              getNumCubitFaces(), null );
+      factory.createNewFaceTransform(shape);
+      mMeshes[variant] = factory.createRoundedSolid(shape);
       }
 
-    return mMeshes[0].copy(true);
+    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;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -277,9 +309,9 @@ class TwistyCube extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getFaceColor(int cubit, int cubitface, int size)
+  int getFaceColor(int cubit, int cubitface, int numLayers)
     {
-    return CUBITS[cubit].mRotationRow[cubitface/2] == (cubitface%2==0 ? (1<<(size-1)):1) ? cubitface : NUM_FACES;
+    return CUBITS[cubit].mRotationRow[cubitface/2] == (cubitface%2==0 ? (1<<(numLayers-1)):1) ? cubitface : NUM_FACES;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyDiamond.java b/src/main/java/org/distorted/objects/TwistyDiamond.java
index 39989495..e7a260f6 100644
--- a/src/main/java/org/distorted/objects/TwistyDiamond.java
+++ b/src/main/java/org/distorted/objects/TwistyDiamond.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;
@@ -378,8 +379,10 @@ public class TwistyDiamond extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private Static4D getQuat(int cubit, int numLayers, int numO)
+  private Static4D getQuat(int cubit, int numLayers)
     {
+    int numO = getNumOctahedrons(numLayers);
+
     if( cubit<numO ) return QUATS[0];
 
     switch( retFaceTetraBelongsTo(cubit-numO, numLayers) )
@@ -399,67 +402,71 @@ public class TwistyDiamond extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  MeshBase createCubitMesh(int cubit, int numLayers)
+  private int getNumCubitVariants(int numLayers)
     {
-    if( mMeshes==null )
-      {
-      FactoryCubit factory = FactoryCubit.getInstance();
-      factory.clear();
-      mMeshes = new MeshBase[2];
-      }
+    return 2;
+    }
 
-    MeshBase mesh;
-    int numO = getNumOctahedrons(numLayers);
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getCubitVariant(int cubit, int numLayers)
+    {
+    return cubit<getNumOctahedrons(numLayers) ? 0 : 1;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  ObjectShape getObjectShape(int cubit, int numLayers)
+    {
+    int variant = getCubitVariant(cubit,numLayers);
     int N = numLayers>3 ? 5:6;
     int E = numLayers>3 ? 1:2;
 
-    if( cubit<numO )
+    if( variant==0 )
       {
-      if( mMeshes[0]==null )
-        {
-        float[][] bands     = new float[][] { {0.05f,35,0.5f,0.8f,N,E,E} };
-        int[] bandIndexes   = new int[] { 0,0,0,0,0,0,0,0 };
-        float[][] corners   = new float[][] { {0.04f,0.20f} };
-        int[] cornerIndexes = new int[] { 0,0,0,0,0,0 };
-        float[][] centers   = new float[][] { {0.0f, 0.0f, 0.0f} };
-        int[] centerIndexes = new int[] { 0,0,0,0,0,0 };
-
-        FactoryCubit factory = FactoryCubit.getInstance();
-
-        factory.createNewFaceTransform(VERTICES_OCTA,VERT_INDEXES_OCTA);
-        mMeshes[0] = factory.createRoundedSolid(VERTICES_OCTA, VERT_INDEXES_OCTA,
-                                                bands, bandIndexes,
-                                                corners, cornerIndexes,
-                                                centers, centerIndexes,
-                                                getNumCubitFaces(), null );
-        }
-      mesh = mMeshes[0].copy(true);
+      float[][] bands     = new float[][] { {0.05f,35,0.5f,0.8f,N,E,E} };
+      int[] bandIndices   = new int[] { 0,0,0,0,0,0,0,0 };
+      float[][] corners   = new float[][] { {0.04f,0.20f} };
+      int[] cornerIndices = new int[] { 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 };
+      return new ObjectShape(VERTICES_OCTA,VERT_INDEXES_OCTA,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
       }
     else
       {
-      if( mMeshes[1]==null )
-        {
-        float[][] bands     = new float[][] { {0.05f,35,0.5f,0.8f,N,E,E} };
-        int[] bandIndexes   = new int[] { 0,0,0,0 };
-        float[][] corners   = new float[][] { {0.08f,0.15f} };
-        int[] cornerIndexes = new int[] { 0,0,0,0 };
-        float[][] centers   = new float[][] { {0.0f, 0.0f, 0.0f} };
-        int[] centerIndexes = new int[] { 0,0,0,0 };
-
-        FactoryCubit factory = FactoryCubit.getInstance();
-
-        factory.createNewFaceTransform(VERTICES_TETRA,VERT_INDEXES_TETRA);
-        mMeshes[1] = factory.createRoundedSolid(VERTICES_TETRA, VERT_INDEXES_TETRA,
-                                                bands, bandIndexes,
-                                                corners, cornerIndexes,
-                                                centers, centerIndexes,
-                                                getNumCubitFaces(), null );
-        }
-      mesh = mMeshes[1].copy(true);
+      float[][] bands     = new float[][] { {0.05f,35,0.5f,0.8f,N,E,E} };
+      int[] bandIndices   = new int[] { 0,0,0,0 };
+      float[][] corners   = new float[][] { {0.08f,0.15f} };
+      int[] cornerIndices = new int[] { 0,0,0,0 };
+      float[][] centers   = new float[][] { {0.0f, 0.0f, 0.0f} };
+      int[] centerIndices = new int[] { 0,0,0,0 };
+      return new ObjectShape(VERTICES_TETRA,VERT_INDEXES_TETRA,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+      }
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  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);
       }
 
-    Static4D sQ = getQuat(cubit,numLayers,numO);
-    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( sQ, 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/TwistyDino.java b/src/main/java/org/distorted/objects/TwistyDino.java
index a3f76c13..b1f5687c 100644
--- a/src/main/java/org/distorted/objects/TwistyDino.java
+++ b/src/main/java/org/distorted/objects/TwistyDino.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;
@@ -177,42 +178,64 @@ public abstract class TwistyDino extends TwistyObject
     return CENTERS;
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private Static4D getQuat(int cubit, int numLayers)
+    {
+    return QUATS[cubit];
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private int getNumCubitVariants(int numLayers)
+    {
+    return 1;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  int getCubitVariant(int cubit, int numLayers)
+    {
+    return 0;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  ObjectShape getObjectShape(int cubit, int numLayers)
+    {
+    float[][] bands= new float[][] { {0.035f,30,0.16f,0.8f,6,2,2}, {0.010f,30,0.16f,0.2f,6,2,2} };
+    int[] bandIndices   = new int[] { 0,0,1,1 };
+    float[][] corners   = new float[][] { {0.07f,0.40f}, {0.05f,0.30f} };
+    int[] cornerIndices = new int[] { 0,0,1,1 };
+    float[][] centers   = new float[][] { {0.0f, -0.75f, -0.75f} };
+    int[] centerIndices = new int[] { 0,0,0,0 };
+
+    return new ObjectShape(VERTICES,VERT_INDEXES,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   MeshBase createCubitMesh(int cubit, int numLayers)
     {
+    int variant = getCubitVariant(cubit,numLayers);
+
     if( mMeshes==null )
       {
       FactoryCubit factory = FactoryCubit.getInstance();
       factory.clear();
-      mMeshes = new MeshBase[1];
+      mMeshes = new MeshBase[getNumCubitVariants(numLayers)];
       }
 
-    if( mMeshes[0]==null )
+    if( mMeshes[variant]==null )
       {
-      float[][] bands= new float[][]
-          {
-             {0.035f,30,0.16f,0.8f,6,2,2},
-             {0.010f,30,0.16f,0.2f,6,2,2}
-          };
-      int[] bandIndexes   = new int[] { 0,0,1,1 };
-      float[][] corners   = new float[][] { {0.07f,0.40f}, {0.05f,0.30f} };
-      int[] cornerIndexes = new int[] { 0,0,1,1 };
-      float[][] centers   = new float[][] { {0.0f, -0.75f, -0.75f} };
-      int[] centerIndexes = new int[] { 0,0,0,0 };
-
+      ObjectShape shape = getObjectShape(cubit,numLayers);
       FactoryCubit factory = FactoryCubit.getInstance();
-
-      factory.createNewFaceTransform(VERTICES,VERT_INDEXES);
-      mMeshes[0] = factory.createRoundedSolid(VERTICES, VERT_INDEXES,
-                                              bands, bandIndexes,
-                                              corners, cornerIndexes,
-                                              centers, centerIndexes,
-                                              getNumCubitFaces(), null );
+      factory.createNewFaceTransform(shape);
+      mMeshes[variant] = factory.createRoundedSolid(shape);
       }
 
-    MeshBase mesh = mMeshes[0].copy(true);
-    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( QUATS[cubit], 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/TwistyObject.java b/src/main/java/org/distorted/objects/TwistyObject.java
index 515e1d0a..1792a179 100644
--- a/src/main/java/org/distorted/objects/TwistyObject.java
+++ b/src/main/java/org/distorted/objects/TwistyObject.java
@@ -246,7 +246,7 @@ public abstract class TwistyObject extends DistortedNode
     int sizeIndex = ObjectList.getSizeIndex(list.ordinal(),mNumLayers);
     int resourceID= list.getResourceIDs()[sizeIndex];
 
-    if( resourceID!=0 )
+    if( false)//resourceID!=0 )
       {
       InputStream is = res.openRawResource(resourceID);
       DataInputStream dos = new DataInputStream(is);