commit 596d62a49d1c47131bfc066ab50c1df6da529f74
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Wed Apr 14 23:16:43 2021 +0200

    Convert the Dino and one of the Skewb's cubits to the new engine.

diff --git a/src/main/java/org/distorted/helpers/FactoryCubit.java b/src/main/java/org/distorted/helpers/FactoryCubit.java
index bf46d529..1a47e827 100644
--- a/src/main/java/org/distorted/helpers/FactoryCubit.java
+++ b/src/main/java/org/distorted/helpers/FactoryCubit.java
@@ -298,33 +298,6 @@ public class FactoryCubit
     return new MeshJoined(meshes);
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  MeshBase createFacesDino()
-    {
-    MeshBase[] meshes = new MeshPolygon[4];
-
-    float E = 0.5f*SQ2;
-    float F = 0.5f;
-    float[] vertices0 = { -F,F/3, 0,-2*F/3, +F,F/3 };
-    float[] bands0 = computeBands(0.028f,30,F/3,0.8f,7);
-
-    meshes[0] = new MeshPolygon(vertices0, bands0, 2, 5);
-    meshes[0].setEffectAssociation(0,1,0);
-    meshes[1] = meshes[0].copy(true);
-    meshes[1].setEffectAssociation(0,2,0);
-
-    float[] vertices1 = { -E/2,-E*(SQ3/6), E/2,-E*(SQ3/6), 0,E*(SQ3/3) };
-    float[] bands1 = computeBands(0.02f,45,F/3,0.2f,3);
-
-    meshes[2] = new MeshPolygon(vertices1, bands1, 1, 2);
-    meshes[2].setEffectAssociation(0,4,0);
-    meshes[3] = meshes[2].copy(true);
-    meshes[3].setEffectAssociation(0,8,0);
-
-    return new MeshJoined(meshes);
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   MeshBase createFacesHelicopterCorner()
@@ -918,49 +891,6 @@ public class FactoryCubit
     return effect;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  VertexEffect[] createVertexEffectsDino()
-    {
-    float E = 0.5f*SQ2;
-    float F = 0.5f;
-    final float ANGLE = (float)((180/Math.PI)*(Math.atan(SQ2)));
-
-    Static1D angle1 = new Static1D(-ANGLE);
-    Static1D angle2 = new Static1D(+ANGLE);
-    Static3D axisX  = new Static3D(1,0,0);
-    Static3D axisY  = new Static3D(0,1,0);
-    Static3D axisZ  = new Static3D(0,-1,1);
-    Static3D center0= new Static3D(0,0,0);
-    Static3D center1= new Static3D(0,-3*F,0);
-
-    VertexEffect[] effect = new VertexEffect[10];
-
-    effect[0] = new VertexEffectScale ( new Static3D(3,3,3) );
-    effect[1] = new VertexEffectMove  ( new Static3D(0,-F,0) );
-    effect[2] = new VertexEffectRotate( new Static1D(90), axisX, center0 );
-    effect[3] = new VertexEffectScale ( new Static3D(1,-1,1) );
-    effect[4] = new VertexEffectMove  ( new Static3D(3*E/2,E*(SQ3/2)-3*F,0) );
-    effect[5] = new VertexEffectRotate( new Static1D(+90), axisY, center1 );
-    effect[6] = new VertexEffectScale ( new Static3D(-1,1,1) );
-    effect[7] = new VertexEffectRotate( new Static1D( 45), axisX, center1 );
-    effect[8] = new VertexEffectRotate( angle1           , axisZ, center1 );
-    effect[9] = new VertexEffectRotate( angle2           , axisZ, center1 );
-
-    effect[0].setMeshAssociation(15,-1);  // apply to meshes 0,1,2,3
-    effect[1].setMeshAssociation( 3,-1);  // apply to meshes 0,1
-    effect[2].setMeshAssociation( 2,-1);  // apply to mesh 1
-    effect[3].setMeshAssociation( 2,-1);  // apply to mesh 1
-    effect[4].setMeshAssociation(12,-1);  // apply to meshes 2,3
-    effect[5].setMeshAssociation(12,-1);  // apply to meshes 2,3
-    effect[6].setMeshAssociation( 8,-1);  // apply to mesh 3
-    effect[7].setMeshAssociation(12,-1);  // apply to meshes 2,3
-    effect[8].setMeshAssociation( 4,-1);  // apply to mesh 2
-    effect[9].setMeshAssociation( 8,-1);  // apply to mesh 3
-
-    return effect;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   VertexEffect[] createVertexEffectsHelicopterCorner()
@@ -1588,29 +1518,6 @@ public class FactoryCubit
     return mesh;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// DINO
-
-  public MeshBase createDinoMesh()
-    {
-    MeshBase mesh = createFacesDino();
-    VertexEffect[] effects = createVertexEffectsDino();
-    for( VertexEffect effect : effects ) mesh.apply(effect);
-
-    float F = 0.5f;
-    Static3D roundingCenter = new Static3D(0.0f, -1.5f*F, -1.5f*F);
-    Static3D[] verticesRound = new Static3D[4];
-    verticesRound[0] = new Static3D(     0,-3*F,    0 );
-    verticesRound[1] = new Static3D(     0,   0, -3*F );
-    verticesRound[2] = new Static3D(  -3*F,   0,    0 );
-    verticesRound[3] = new Static3D(  +3*F,   0,    0 );
-    roundCorners(mesh,roundingCenter,verticesRound,0.10f,0.40f);
-
-    mesh.mergeEffComponents();
-
-    return mesh;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Helicopter
 
diff --git a/src/main/java/org/distorted/objects/TwistyDino.java b/src/main/java/org/distorted/objects/TwistyDino.java
index 4d2c0216..8e7b8134 100644
--- a/src/main/java/org/distorted/objects/TwistyDino.java
+++ b/src/main/java/org/distorted/objects/TwistyDino.java
@@ -88,23 +88,28 @@ public abstract class TwistyDino extends TwistyObject
              {-1.5f, 0.0f,-1.5f }
          };
 
-  private final double[][] VERTICES = new double[][]
+  private static final double[][] VERTICES = new double[][]
           {
-             {-0.5, 0.0, 0.0},
-             { 0.5, 0.0, 0.0},
-             { 0.0,-0.5, 0.0},
-             { 0.0, 0.0,-0.5}
+             {-1.5, 0.0, 0.0},
+             { 1.5, 0.0, 0.0},
+             { 0.0,-1.5, 0.0},
+             { 0.0, 0.0,-1.5}
           };
 
-  private final int[][] VERT_INDEXES = new int[][]
+  private static final int[][] VERT_INDEXES = new int[][]
           {
              {2,1,0},   // counterclockwise!
+             {3,0,1},
              {2,3,1},
              {3,2,0},
-             {3,0,1}
           };
 
-  private static MeshBase mMesh;
+  private static final float[][] STICKERS = new float[][]
+          {
+             { 0.0f, -1.0f/3, 0.5f, 1.0f/6, -0.5f, 1.0f/6 }
+          };
+
+  private static MeshBase[] mMeshes;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -207,7 +212,7 @@ public abstract class TwistyDino extends TwistyObject
 
   int getNumStickerTypes(int numLayers)
     {
-    return 1;
+    return STICKERS.length;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -228,9 +233,34 @@ public abstract class TwistyDino extends TwistyObject
 
   MeshBase createCubitMesh(int cubit, int numLayers)
     {
-    if( mMesh==null ) mMesh = FactoryCubit.getInstance().createDinoMesh();
+    if( mMeshes==null )
+      {
+      FactoryCubit factory = FactoryCubit.getInstance();
+      factory.clear();
+      mMeshes = new MeshBase[1];
+      }
+
+    if( mMeshes[0]==null )
+      {
+      float[][] bands= new float[][]
+          {
+             {0.035f,30,0.16f,0.8f,7,2,5},
+             {0.020f,45,0.16f,0.2f,3,1,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 };
+
+      FactoryCubit factory = FactoryCubit.getInstance();
+
+      factory.createNewFaceTransform(VERTICES,VERT_INDEXES);
+      mMeshes[0] = factory.createRoundedSolid(VERTICES, VERT_INDEXES,
+                                              bands, bandIndexes,
+                                              corners, cornerIndexes,
+                                              getNumCubitFaces() );
+      }
 
-    MeshBase mesh = mMesh.copy(true);
+    MeshBase mesh = mMeshes[0].copy(true);
     MatrixEffectQuaternion quat = new MatrixEffectQuaternion( QUATS[cubit], new Static3D(0,0,0) );
     mesh.apply(quat,0xffffffff,0);
 
@@ -241,13 +271,11 @@ public abstract class TwistyDino extends TwistyObject
 
   void createFaceTexture(Canvas canvas, Paint paint, int face, int left, int top)
     {
-    float F = 0.5f;
     float R = 0.025f;
     float S = 0.05f;
-    float[] vertices = { -F,F/3, 0,-2*F/3, +F,F/3 };
 
     FactorySticker factory = FactorySticker.getInstance();
-    factory.drawRoundedPolygon(canvas, paint, left, top, vertices, S, FACE_COLORS[face], R);
+    factory.drawRoundedPolygon(canvas, paint, left, top, STICKERS[0], S, FACE_COLORS[face], R);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistySkewb.java b/src/main/java/org/distorted/objects/TwistySkewb.java
index 78e79866..e5e84020 100644
--- a/src/main/java/org/distorted/objects/TwistySkewb.java
+++ b/src/main/java/org/distorted/objects/TwistySkewb.java
@@ -25,9 +25,7 @@ import android.graphics.Paint;
 
 import org.distorted.helpers.FactoryCubit;
 import org.distorted.helpers.FactorySticker;
-import org.distorted.library.effect.MatrixEffect;
 import org.distorted.library.effect.MatrixEffectQuaternion;
-import org.distorted.library.effect.MatrixEffectScale;
 import org.distorted.library.main.DistortedEffects;
 import org.distorted.library.main.DistortedTexture;
 import org.distorted.library.mesh.MeshBase;
@@ -117,7 +115,43 @@ public class TwistySkewb extends TwistyObject
            { 17, 18,18,18,18,18 },
          };
 
-  private static MeshBase mCornerMesh, mFaceMesh, mEdgeMesh;
+  private static final double[][] VERTICES_CORNER = new double[][]
+          {
+             // TODO
+          };
+
+  private static final int[][] VERT_INDEXES_CORNER = new int[][]
+          {
+             // TODO
+          };
+
+  private static final double[][] VERTICES_EDGE = new double[][]
+          {
+             {-0.5, 0.0, 0.0},
+             { 0.5, 0.0, 0.0},
+             { 0.0,-0.5, 0.0},
+             { 0.0, 0.0,-0.5}
+          };
+
+  private static final int[][] VERT_INDEXES_EDGE = new int[][]
+          {
+             {2,1,0},   // counterclockwise!
+             {3,0,1},
+             {2,3,1},
+             {3,2,0},
+          };
+
+  private static final double[][] VERTICES_FACE = new double[][]
+          {
+             // TODO
+          };
+
+  private static final int[][] VERT_INDEXES_FACE = new int[][]
+          {
+             // TODO
+          };
+
+  private static MeshBase[] mMeshes;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -128,18 +162,22 @@ public class TwistySkewb extends TwistyObject
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// TODO
 
   double[][] getVertices(int cubitType)
     {
+    if( cubitType==0 ) return VERTICES_CORNER;
+    if( cubitType==1 ) return VERTICES_EDGE;
+    if( cubitType==2 ) return VERTICES_FACE;
     return null;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// TODO
 
   int[][] getVertIndexes(int cubitType)
     {
+    if( cubitType==0 ) return VERT_INDEXES_CORNER;
+    if( cubitType==1 ) return VERT_INDEXES_EDGE;
+    if( cubitType==2 ) return VERT_INDEXES_FACE;
     return null;
     }
 
@@ -425,6 +463,13 @@ public class TwistySkewb extends TwistyObject
 
   MeshBase createCubitMesh(int cubit, int numLayers)
     {
+    if( mMeshes==null )
+      {
+      FactoryCubit factory = FactoryCubit.getInstance();
+      factory.clear();
+      mMeshes = new MeshBase[3];
+      }
+
     MeshBase mesh;
 
     int numCorners = getNumCorners();
@@ -432,25 +477,42 @@ public class TwistySkewb extends TwistyObject
 
     if( cubit<numCorners )
       {
-      if( mCornerMesh==null ) mCornerMesh = FactoryCubit.getInstance().createSkewbCornerMesh();
-      mesh = mCornerMesh.copy(true);
+      if( mMeshes[0]==null )
+        {
+        mMeshes[0] = FactoryCubit.getInstance().createSkewbCornerMesh();
+        }
+      mesh = mMeshes[0].copy(true);
       }
     else if( cubit<numCorners+numEdges )
       {
-      if( mEdgeMesh==null )
+      if( mMeshes[1]==null )
         {
-        mEdgeMesh = FactoryCubit.getInstance().createDinoMesh();
-        MatrixEffect effect = new MatrixEffectScale(1.0f/3);
-        mEdgeMesh.apply(effect,-1,0);
-        mEdgeMesh.addEmptyTexComponent();
-        mEdgeMesh.addEmptyTexComponent();
+        float[][] bands= new float[][]
+          {
+             {0.035f,30,0.16f,0.8f,7,2,5},
+             {0.020f,45,0.16f,0.2f,3,1,2}
+          };
+        int[] bandIndexes   = new int[] { 0,0,1,1 };
+        float[][] corners   = new float[][] { {0.07f,0.20f}, {0.02f,0.30f} };
+        int[] cornerIndexes = new int[] { 0,0,1,1 };
+
+        FactoryCubit factory = FactoryCubit.getInstance();
+
+        factory.createNewFaceTransform(VERTICES_EDGE,VERT_INDEXES_EDGE);
+        mMeshes[1] = factory.createRoundedSolid(VERTICES_EDGE, VERT_INDEXES_EDGE,
+                                                bands, bandIndexes,
+                                                corners, cornerIndexes,
+                                                getNumCubitFaces() );
         }
-      mesh = mEdgeMesh.copy(true);
+      mesh = mMeshes[1].copy(true);
       }
     else
       {
-      if( mFaceMesh==null ) mFaceMesh = FactoryCubit.getInstance().createSkewbFaceMesh();
-      mesh = mFaceMesh.copy(true);
+      if( mMeshes[2]==null )
+        {
+        mMeshes[2] = FactoryCubit.getInstance().createSkewbFaceMesh();
+        }
+      mesh = mMeshes[2].copy(true);
       }
 
     MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit,numLayers), new Static3D(0,0,0) );
