commit 0919eba7214afd2a2e622ebac62521c38b6f45e6
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Thu Apr 15 17:29:02 2021 +0200

    Correct still one bug with collapsing stickers in teh new Cubit engine.
    Convert the Helicopter corner 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 033dba7a..74f1a287 100644
--- a/src/main/java/org/distorted/helpers/FactoryCubit.java
+++ b/src/main/java/org/distorted/helpers/FactoryCubit.java
@@ -238,37 +238,6 @@ public class FactoryCubit
       }
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  MeshBase createFacesHelicopterCorner()
-    {
-    MeshBase[] meshes = new MeshBase[6];
-
-    float E = 0.5f;
-    float F = SQ2/4;
-    float G = 1.0f/12;
-    float[] vertices0 = { -E+E/4,E/4, E/4,-E+E/4, E/4,E/4};
-    float[] bands0 = computeBands(0.028f,35,E/4,0.7f,7);
-
-    meshes[0] = new MeshPolygon(vertices0, bands0, 3, 3);
-    meshes[0].setEffectAssociation(0,1,0);
-    meshes[1] = meshes[0].copy(true);
-    meshes[1].setEffectAssociation(0,2,0);
-    meshes[2] = meshes[0].copy(true);
-    meshes[2].setEffectAssociation(0,4,0);
-
-    float[] vertices1 = { -F,-G, 0,-G, +F,-G, 0,2*G };
-    float[] bands1 = computeBands(0.00f,0,0,0.0f,3);
-    meshes[3] = new MeshPolygon(vertices1,bands1,1,5);
-    meshes[3].setEffectAssociation(0,8,0);
-    meshes[4] = meshes[3].copy(true);
-    meshes[4].setEffectAssociation(0,16,0);
-    meshes[5] = meshes[3].copy(true);
-    meshes[5].setEffectAssociation(0,32,0);
-
-    return new MeshJoined(meshes);
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   MeshBase createFacesHelicopterFace()
@@ -753,54 +722,6 @@ public class FactoryCubit
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // EFFECTS
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  VertexEffect[] createVertexEffectsHelicopterCorner()
-    {
-    float E = 0.5f;
-
-    Static3D axisX  = new Static3D(1,0,0);
-    Static3D axisY  = new Static3D(0,1,0);
-    Static3D axis0  = new Static3D(-SQ2/2,0,SQ2/2);
-    Static3D axis1  = new Static3D(+SQ3/3,+SQ3/3,+SQ3/3);
-    Static1D angle1 = new Static1D(+90);
-    Static1D angle2 = new Static1D(-90);
-    Static1D angle3 = new Static1D(-135);
-    Static1D angle4 = new Static1D(90);
-    Static1D angle5 = new Static1D(120);
-    Static1D angle6 = new Static1D(240);
-    Static3D center1= new Static3D(0,0,0);
-    Static3D center2= new Static3D(-0.25f,-0.25f,-0.25f);
-    Static3D move1  = new Static3D(-E/4,-E/4,0);
-    Static3D move2  = new Static3D(-0.25f,(-1.0f/6)-0.25f,-0.25f);
-
-    VertexEffect[] effect = new VertexEffect[10];
-
-    effect[0] = new VertexEffectMove(move1);
-    effect[1] = new VertexEffectScale(new Static3D(1,1,-1));
-    effect[2] = new VertexEffectRotate(angle1,axisX,center1);
-    effect[3] = new VertexEffectRotate(angle2,axisY,center1);
-    effect[4] = new VertexEffectMove(move2);
-    effect[5] = new VertexEffectRotate(angle1,axisX,center2);
-    effect[6] = new VertexEffectRotate(angle3,axisY,center2);
-    effect[7] = new VertexEffectRotate(angle4,axis0,center2);
-    effect[8] = new VertexEffectRotate(angle5,axis1,center2);
-    effect[9] = new VertexEffectRotate(angle6,axis1,center2);
-
-    effect[0].setMeshAssociation( 7,-1);  // meshes 0,1,2
-    effect[1].setMeshAssociation( 6,-1);  // meshes 1,2
-    effect[2].setMeshAssociation( 2,-1);  // mesh 1
-    effect[3].setMeshAssociation( 4,-1);  // mesh 2
-    effect[4].setMeshAssociation(56,-1);  // meshes 3,4,5
-    effect[5].setMeshAssociation(56,-1);  // meshes 3,4,5
-    effect[6].setMeshAssociation(56,-1);  // meshes 3,4,5
-    effect[7].setMeshAssociation(56,-1);  // meshes 3,4,5
-    effect[8].setMeshAssociation(16,-1);  // mesh 4
-    effect[9].setMeshAssociation(32,-1);  // mesh 5
-
-    return effect;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   VertexEffect[] createVertexEffectsHelicopterFace()
@@ -1329,36 +1250,6 @@ public class FactoryCubit
 // OBJECTS
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Helicopter
-
-  public MeshBase createHelicopterCornerMesh()
-    {
-    MeshBase mesh = createFacesHelicopterCorner();
-    VertexEffect[] effects = createVertexEffectsHelicopterCorner();
-    for( VertexEffect effect : effects ) mesh.apply(effect);
-
-    float E = 0.5f;
-    Static3D roundingCenter = new Static3D(-E/2,-E/2,-E/2);
-
-    Static3D[] verticesType1 = new Static3D[1];
-    verticesType1[0] = new Static3D(0.0f,0.0f,0.0f);
-    roundCorners(mesh,roundingCenter,verticesType1,0.08f,0.15f);
-
-    Static3D[] verticesType2 = new Static3D[3];
-    verticesType2[0] = new Static3D(-E, 0, 0);
-    verticesType2[1] = new Static3D( 0,-E, 0);
-    verticesType2[2] = new Static3D( 0, 0,-E);
-    roundCorners(mesh,roundingCenter,verticesType2,0.08f,0.20f);
-
-    mesh.mergeEffComponents();
-
-    return mesh;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
   public MeshBase createHelicopterFaceMesh()
     {
     MeshBase mesh = createFacesHelicopterFace();
@@ -1965,10 +1856,15 @@ public class FactoryCubit
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private double computeScale(double[] v1, double[] v2)
+  private double computeScale(double[] v1, double[] v2, int v1i, int v2i)
     {
-    double lenSq1 = v1[0]*v1[0] + v1[1]*v1[1];
-    double lenSq2 = v2[0]*v2[0] + v2[1]*v2[1];
+    double v1x = v1[2*v1i];
+    double v1y = v1[2*v1i+1];
+    double v2x = v2[2*v2i];
+    double v2y = v2[2*v2i+1];
+
+    double lenSq1 = v1x*v1x + v1y*v1y;
+    double lenSq2 = v2x*v2x + v2y*v2y;
 
     return Math.sqrt(lenSq2/lenSq1);
     }
@@ -2005,8 +1901,9 @@ public class FactoryCubit
 
   private boolean isScaledVersionOf(double[] newVert, double[] oldVert, int len, int vertex, boolean inverted)
     {
+    int newZeroIndex = computeRotatedIndex(0,len,vertex,inverted);
     double EPSILON = 0.001;
-    double scale = computeScale(newVert,oldVert);
+    double scale = computeScale(newVert,oldVert,newZeroIndex,0);
 
     for(int i=1; i<len; i++)
       {
@@ -2112,7 +2009,8 @@ public class FactoryCubit
 
       if( isScaledVersionOf(buffer,oldVert,len,vertex,inverted) )
         {
-        double scale = computeScale(oldVert,newVert);
+        int newZeroIndex = computeRotatedIndex(0,len,vertex,inverted);
+        double scale = computeScale(oldVert,newVert,0,newZeroIndex);
         correctInfo(info,scale,sin,cos,oldSticker,inverted);
         return true;
         }
diff --git a/src/main/java/org/distorted/objects/TwistyHelicopter.java b/src/main/java/org/distorted/objects/TwistyHelicopter.java
index c02a9445..d7d37499 100644
--- a/src/main/java/org/distorted/objects/TwistyHelicopter.java
+++ b/src/main/java/org/distorted/objects/TwistyHelicopter.java
@@ -33,7 +33,6 @@ import org.distorted.library.mesh.MeshSquare;
 import org.distorted.library.type.Static3D;
 import org.distorted.library.type.Static4D;
 import org.distorted.main.R;
-import org.distorted.main.RubikSurfaceView;
 
 import java.util.Random;
 
@@ -185,27 +184,49 @@ public class TwistyHelicopter extends TwistyObject
   private static final int[] QUAT_INDICES =
       { 0,13,14,1,12,2,3,7,20,6,13,17,7,23,18,12,22,10,8,16,11,21,19,9,3,15,14,0,5,2,1,4 };
 
-  private final double[][] VERTICES_CORNER = new double[][]
+  private static final double[][] VERTICES_CORNER = new double[][]
           {
-            // TODO
+            {-0.50f, 0.00f, 0.00f},
+            { 0.00f,-0.50f, 0.00f},
+            { 0.00f, 0.00f,-0.50f},
+            {-0.25f,-0.25f,-0.25f},
+            { 0.00f, 0.00f, 0.00f}
           };
 
-  private final int[][] VERT_INDEXES_CORNER = new int[][]
+  private static final int[][] VERT_INDEXES_CORNER = new int[][]
           {
-            // TODO
+            {0,1,4},
+            {2,0,4},
+            {1,2,4},
+            {3,1,0},
+            {3,2,1},
+            {3,0,2}
           };
 
-  private final double[][] VERTICES_FACE = new double[][]
+  private static final float E = 0.1666666f;
+
+  private static final double[][] VERTICES_FACE = new double[][]
+          {
+            { 0.00f +E, 0.00f +E, 0.00f },
+            { 0.50f +E, 0.00f +E, 0.00f },
+            { 0.00f +E, 0.50f +E, 0.00f },
+            { 0.25f +E, 0.25f +E,-0.25f },
+          };
+
+  private static final int[][] VERT_INDEXES_FACE = new int[][]
           {
-            // TODO
+            { 0,1,2 },
+            { 2,1,3 },
+            { 0,1,3 },
+            { 2,0,3 }
           };
 
-  private final int[][] VERT_INDEXES_FACE = new int[][]
+  private static final float[][] STICKERS = new float[][]
           {
-            // TODO
+            { -0.5f, 0.25f, 0.25f, -0.5f, 0.25f, 0.25f }
           };
 
-  private static MeshBase mCornerMesh, mFaceMesh;
+  private static MeshBase[] mMeshes;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -219,15 +240,8 @@ public class TwistyHelicopter extends TwistyObject
 
   double[][] getVertices(int cubitType)
     {
-     if( cubitType==0 )  // Corner
-      {
-      return VERTICES_CORNER;
-      }
-    if( cubitType==1 )  // Face
-      {
-      return VERTICES_FACE;
-      }
-
+    if( cubitType==0 ) return VERTICES_CORNER;
+    if( cubitType==1 ) return VERTICES_FACE;
     return null;
     }
 
@@ -235,15 +249,8 @@ public class TwistyHelicopter extends TwistyObject
 
   int[][] getVertIndexes(int cubitType)
     {
-    if( cubitType==0 )  // Corner
-      {
-      return VERT_INDEXES_CORNER;
-      }
-    if( cubitType==1 )  // Face
-      {
-      return VERT_INDEXES_FACE;
-      }
-
+    if( cubitType==0 ) return VERT_INDEXES_CORNER;
+    if( cubitType==1 ) return VERT_INDEXES_FACE;
     return null;
     }
 
@@ -251,7 +258,7 @@ public class TwistyHelicopter extends TwistyObject
 
   int getNumCubitTypes(int numLayers)
     {
-    return 1;
+    return 2;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -319,17 +326,67 @@ public class TwistyHelicopter extends TwistyObject
 
   MeshBase createCubitMesh(int cubit, int numLayers)
     {
+    if( mMeshes==null )
+      {
+      FactoryCubit factory = FactoryCubit.getInstance();
+      factory.clear();
+      mMeshes = new MeshBase[2];
+      }
+
     MeshBase mesh;
 
     if( cubit<8 )
       {
-      if( mCornerMesh==null ) mCornerMesh = FactoryCubit.getInstance().createHelicopterCornerMesh();
-      mesh = mCornerMesh.copy(true);
+      if( mMeshes[0]==null )
+        {
+        float[][] bands= new float[][]
+          {
+             {0.028f,35,0.16f,0.7f,7,3,3},
+             {0.000f, 0,1.00f,0.0f,3,1,5}
+          };
+        int[] bandIndexes   = new int[] { 0,0,0,1,1,1 };
+        float[][] corners   = new float[][] { {0.08f,0.15f}, {0.08f,0.20f} };
+        int[] cornerIndexes = new int[] { 1,1,1,0,0 };
+        float[][] centers   = new float[][] { {-0.25f, -0.25f, -0.25f} };
+        int[] centerIndexes = new int[] { 0,0,0,-1,0 };
+
+        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() );
+        }
+      mesh = mMeshes[0].copy(true);
       }
     else
       {
-      if( mFaceMesh==null ) mFaceMesh = FactoryCubit.getInstance().createHelicopterFaceMesh();
-      mesh = mFaceMesh.copy(true);
+      if( mMeshes[1]==null ) mMeshes[1] = FactoryCubit.getInstance().createHelicopterFaceMesh();
+        /*
+        {
+        float[][] bands= new float[][]
+          {
+             {0.028f,35,0.16f,0.7f,7,3,3},
+             {0.000f, 0,1.00f,0.0f,3,1,3}
+          };
+        int[] bandIndexes   = new int[] { 0,1,1,1 };
+        float[][] corners   = new float[][] { {0.06f,0.15f}, {0.06f,0.20f} };
+        int[] cornerIndexes = new int[] { 0,1,1,-1 };
+        float[][] centers   = new float[][] { {-1.0f/12, -1.0f/12, -1.0f/4} };
+        int[] centerIndexes = new int[] { 0,0,0,-1 };
+
+        FactoryCubit factory = FactoryCubit.getInstance();
+        factory.createNewFaceTransform(VERTICES_FACE,VERT_INDEXES_FACE);
+        mMeshes[1] = factory.createRoundedSolid(VERTICES_FACE, VERT_INDEXES_FACE,
+                                                bands, bandIndexes,
+                                                corners, cornerIndexes,
+                                                centers, centerIndexes,
+                                                getNumCubitFaces() );
+        }
+
+         */
+      mesh = mMeshes[1].copy(true);
       }
 
     int index = QUAT_INDICES[cubit];
diff --git a/src/main/java/org/distorted/objects/TwistySkewb.java b/src/main/java/org/distorted/objects/TwistySkewb.java
index 9e8a1f1f..259a444b 100644
--- a/src/main/java/org/distorted/objects/TwistySkewb.java
+++ b/src/main/java/org/distorted/objects/TwistySkewb.java
@@ -521,7 +521,6 @@ public class TwistySkewb extends TwistyObject
                                                 corners, cornerIndexes,
                                                 centers, centerIndexes,
                                                 getNumCubitFaces() );
-        //mMeshes[0] = FactoryCubit.getInstance().createSkewbCornerMesh();
         }
       mesh = mMeshes[0].copy(true);
       }