/src/main/java/org/distorted/objectlib/helpers/FactoryCubit.java - Annotate - TwistyPuzzleLib - Distorted Android

distorted-objectlib / src / main / java / org / distorted / objectlib / helpers / FactoryCubit.java @ 9cd63ba8

-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
 // Copyright 2020 Leszek Koltunski                                                               //
 //                                                                                               //
 // This file is part of Magic Cube.                                                              //
 //                                                                                               //
-            a7a40b3c
+// Magic Cube is proprietary software licensed under an EULA which you should have received      //
 // along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //
-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
-c5bf0
+package org.distorted.objectlib.helpers;
-b82486
+            Leszek Koltunski
-a17011
+import org.distorted.library.effect.EffectName;
-b82486
+import org.distorted.library.effect.MatrixEffectMove;
 import org.distorted.library.effect.MatrixEffectQuaternion;
 import org.distorted.library.effect.MatrixEffectScale;
 import org.distorted.library.effect.VertexEffect;
-            aacf5e27
+import org.distorted.library.helpers.QuatHelper;
-b82486
+import org.distorted.library.mesh.MeshBase;
 import org.distorted.library.mesh.MeshJoined;
-            fe3dec09
+import org.distorted.library.mesh.MeshMultigon;
-b82486
+import org.distorted.library.mesh.MeshPolygon;
 import org.distorted.library.type.Static3D;
 import org.distorted.library.type.Static4D;
 import java.util.ArrayList;
-            c3a033e9
+import static org.distorted.objectlib.main.TwistyObject.MESH_FAST;
 import static org.distorted.objectlib.main.TwistyObject.MESH_NICE;
-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
 public class FactoryCubit
+  {
   private static FactoryCubit mThis;
-            d99de43c
+  private static final float MAX_CORE_DIFF = 0.01f;
-ef6378
+  private static final float[] mBuffer = new float[3];
   private static final float[] mQuat1  = new float[4];
   private static final float[] mQuat2  = new float[4];
   private static final float[] mQuat3  = new float[4];
-b82486
+            Leszek Koltunski
-fd07aa
+  public static final String NAME = EffectName.DEFORM.name();
-a17011
+            Leszek Koltunski
-            fe3dec09
+  private static class StickerCoords
-b82486
+            Leszek Koltunski
-ef6378
+    float[] vertices;
-            fe3dec09
+    float[][] fullVertices;
-a74f
+    float scale;
-d26b
+    boolean outer;
-b82486
+            Leszek Koltunski
   private static class FaceTransform
+    {
-af68038
+    int face;
     int numFaces;
-b82486
+    int sticker;
-ef6378
+    float vx,vy,vz;
     float scale;
     float qx,qy,qz,qw;
-b82486
+            Leszek Koltunski
   private static final ArrayList<FaceTransform> mNewFaceTransf = new ArrayList<>();
   private static final ArrayList<FaceTransform> mOldFaceTransf = new ArrayList<>();
   private static final ArrayList<StickerCoords> mStickerCoords = new ArrayList<>();
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private FactoryCubit()
+    {
-bf19410
+            Leszek Koltunski
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // H - height of the band in the middle
 // alpha - angle of the edge  [0,90]
 // dist - often in a polygon the distance from edge to center is not 1, but something else.
 // This is the distance.
 // K - where to begin the second, much more flat part of the band. [0,1]
 // N - number of bands. N>=3
 //
 // theory: two distinct parts to the band:
 // 1) (0,B) - steep
 // 2) (B,1) - flat
 //
 // In first part, we have y = g(x) ; in second - y = g(f(x)) where
 //
 // g(x) = sqrt( R^2 - (x-D)^2 ) - R*cos(alpha)
 // f(x) = ((D-B)/(1-B)*x + B*(1-D)/(1-B)
 // h(x) = R*(sin(alpha) - sin(x))
 // R = H/(1-cos(alpha))
 // D = H*sin(alpha)
 // B = h(K*alpha)
 //
 // The N points are taken at:
 //
 // 1) in the second part, there are K2 = (N-3)/3 such points
 // 2) in the first - K1 = (N-3) - K2
 // 3) also, the 3 points 0,B,1
 //
 // so we have the sequence A[i] of N points
 //
 // 0
 // h((i+1)*(1-K)*alpha/(K1+1)) (i=0,1,...,K1-1)
 // B
 // (1-B)*(i+1)/(K2+1) + B   (i=0,i,...,K2-1)
 // 1
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private float f(float D, float B, float x)
+    {
     return ((D-B)*x + B*(1-D))/(1-B);
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private float g(float R, float D, float x, float cosAlpha)
+    {
     float d = x-D;
     return (float)(Math.sqrt(R*R-d*d)-R*cosAlpha);
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private float h(float R, float sinAlpha, float x)
+    {
     return R*(sinAlpha-(float)Math.sin(x));
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-ef6378
+  private boolean areColinear(float[][] vertices, int index1, int index2, int index3)
-b82486
+            Leszek Koltunski
-ef6378
+    float x1 = vertices[index1][0];
     float y1 = vertices[index1][1];
     float z1 = vertices[index1][2];
     float x2 = vertices[index2][0];
     float y2 = vertices[index2][1];
     float z2 = vertices[index2][2];
     float x3 = vertices[index3][0];
     float y3 = vertices[index3][1];
     float z3 = vertices[index3][2];
-b82486
+            Leszek Koltunski
-ef6378
+    float v1x = x2-x1;
     float v1y = y2-y1;
     float v1z = z2-z1;
     float v2x = x3-x1;
     float v2y = y3-y1;
     float v2z = z3-z1;
-b82486
+            Leszek Koltunski
     double A = Math.sqrt( (v1x*v1x+v1y*v1y+v1z*v1z) / (v2x*v2x+v2y*v2y+v2z*v2z) );
     return (v1x==A*v2x && v1y==A*v2y && v1z==A*v2z);
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-ef6378
+  private void computeNormalVector(float[][] vertices, int index1, int index2, int index3)
-b82486
+            Leszek Koltunski
-ef6378
+    float x1 = vertices[index1][0];
     float y1 = vertices[index1][1];
     float z1 = vertices[index1][2];
     float x2 = vertices[index2][0];
     float y2 = vertices[index2][1];
     float z2 = vertices[index2][2];
     float x3 = vertices[index3][0];
     float y3 = vertices[index3][1];
     float z3 = vertices[index3][2];
-b82486
+            Leszek Koltunski
-ef6378
+    float v1x = x2-x1;
     float v1y = y2-y1;
     float v1z = z2-z1;
     float v2x = x3-x1;
     float v2y = y3-y1;
     float v2z = z3-z1;
-b82486
+            Leszek Koltunski
     mBuffer[0] = v1y*v2z - v2y*v1z;
     mBuffer[1] = v1z*v2x - v2z*v1x;
     mBuffer[2] = v1x*v2y - v2x*v1y;
     double len = mBuffer[0]*mBuffer[0] + mBuffer[1]*mBuffer[1] + mBuffer[2]*mBuffer[2];
     len = Math.sqrt(len);
     mBuffer[0] /= len;
     mBuffer[1] /= len;
     mBuffer[2] /= len;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            fe3dec09
+  private float[] detectFirstOuterVertex(float[][] vertices)
+    {
     float X = -Float.MAX_VALUE;
     int I=0,J=0, len = vertices.length;
     for(int i=0; i<len; i++ )
+      {
       float[] v = vertices[i];
       int num = v.length/2;
       for(int j=0; j<num; j++)
         if(v[2*j]>X)
+          {
           X = v[2*j];
           I = i;
           J = j;
+          }
+      }
     float[] v = vertices[I];
     return new float[] {v[2*J],v[2*J+1]};
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private double computeAngle(float x1,float y1, float x2, float y2)
+    {
     double diff = Math.atan2(y2,x2)-Math.atan2(y1,x1);
     return diff<0 ? diff+(2*Math.PI) : diff;
+    }
-            b394a751
+///////////////////////////////////////////////////////////////////////////////////////////////////
   private boolean pointsTheSame(float dx, float dy)
+    {
     return dx*dx + dy*dy < 0.000001f;
+    }
-            fe3dec09
+///////////////////////////////////////////////////////////////////////////////////////////////////
   private float[] detectNextOuterVertex(float[][] vertices, float[] curr, float[] vect)
+    {
     double minAngle = 2*Math.PI;
     float x=0, y=0;
     for( float[] v : vertices )
+      {
       int num = v.length/2;
       for( int j=0; j<num; j++)
+        {
         float xc = v[2*j];
         float yc = v[2*j+1];
-            b394a751
+        if( pointsTheSame(xc-curr[0],yc-curr[1]) )
-            fe3dec09
+            Leszek Koltunski
           int n = (j==num-1 ? 0 : j+1);
           float xn = v[2*n];
           float yn = v[2*n+1];
           double angle = computeAngle(vect[0], vect[1], xn-xc, yn-yc);
           if (angle < minAngle)
+            {
             minAngle = angle;
             x = xn;
             y = yn;
+            }
           break;
+          }
+        }
+      }
     return new float[] {x,y};
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // same as in MeshMultigon
   private float[] computeOuterEdge(float[][] vertices)
+    {
     ArrayList<float[]> tmp = new ArrayList<>();
     float[] vect = new float[] {1,0};
     float[] first= detectFirstOuterVertex(vertices);
     float[] next = first;
     do
+      {
       float[] prev = next;
       next = detectNextOuterVertex(vertices,next,vect);
       vect[0] = prev[0]-next[0];
       vect[1] = prev[1]-next[1];
       tmp.add(next);
+      }
-            b394a751
+    while( !pointsTheSame(next[0]-first[0],next[1]-first[1]) );
-            fe3dec09
+            Leszek Koltunski
     int num = tmp.size();
     float[] ret = new float[2*num];
     for(int i=0; i<num; i++)
+      {
       float[] t = tmp.remove(0);
       ret[2*i  ] = t[0];
       ret[2*i+1] = t[1];
+      }
     return ret;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // polygon
-d26b
+  private void fitInSquare(FaceTransform info, float[][] vert3D, boolean isOuter)
-b82486
+            Leszek Koltunski
-ef6378
+    float minX = Float.MAX_VALUE;
     float maxX =-Float.MAX_VALUE;
     float minY = Float.MAX_VALUE;
     float maxY =-Float.MAX_VALUE;
-b82486
+            Leszek Koltunski
-ef6378
+    for (float[] vert : vert3D)
-b82486
+            Leszek Koltunski
-ef6378
+      float x = vert[0];
       float y = vert[1];
-b82486
+            Leszek Koltunski
       if (x > maxX) maxX = x;
       if (x < minX) minX = x;
       if (y > maxY) maxY = y;
       if (y < minY) minY = y;
+      }
     minX = minX<0 ? -minX:minX;
     maxX = maxX<0 ? -maxX:maxX;
     minY = minY<0 ? -minY:minY;
     maxY = maxY<0 ? -maxY:maxY;
-ef6378
+    float max1 = Math.max(minX,minY);
     float max2 = Math.max(maxX,maxY);
     float max3 = Math.max(max1,max2);
-b82486
+            Leszek Koltunski
-ef6378
+    info.scale = max3/0.5f;
-b82486
+            Leszek Koltunski
     int len = vert3D.length;
     StickerCoords sInfo = new StickerCoords();
-d26b
+    sInfo.outer = isOuter;
-a74f
+    sInfo.scale = info.scale;
-ef6378
+    sInfo.vertices = new float[2*len];
-            fe3dec09
+    sInfo.fullVertices = null;
-b82486
+            Leszek Koltunski
     for( int vertex=0; vertex<len; vertex++ )
+      {
       sInfo.vertices[2*vertex  ] = vert3D[vertex][0] / info.scale;
       sInfo.vertices[2*vertex+1] = vert3D[vertex][1] / info.scale;
+      }
     mStickerCoords.add(sInfo);
     info.sticker = mStickerCoords.size() -1;
+    }
-            fe3dec09
+            Leszek Koltunski
-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
-            fe3dec09
+// multigon
   private void fitInSquare(FaceTransform info, float[][][] vert3D, boolean isOuter)
+    {
     float minX = Float.MAX_VALUE;
     float maxX =-Float.MAX_VALUE;
     float minY = Float.MAX_VALUE;
     float maxY =-Float.MAX_VALUE;
     for( float[][] vert : vert3D)
       for( float[] v : vert)
+        {
         float x = v[0];
         float y = v[1];
         if (x > maxX) maxX = x;
         if (x < minX) minX = x;
         if (y > maxY) maxY = y;
         if (y < minY) minY = y;
+        }
     minX = minX<0 ? -minX:minX;
     maxX = maxX<0 ? -maxX:maxX;
     minY = minY<0 ? -minY:minY;
     maxY = maxY<0 ? -maxY:maxY;
     float max1 = Math.max(minX,minY);
     float max2 = Math.max(maxX,maxY);
     float max3 = Math.max(max1,max2);
     info.scale = max3/0.5f;
     int len = vert3D.length;
     StickerCoords sInfo = new StickerCoords();
     sInfo.outer = isOuter;
     sInfo.scale = info.scale;
     sInfo.fullVertices = new float[len][];
     for( int comp=0; comp<len; comp++ )
+      {
       float[][] vert = vert3D[comp];
       int num = vert.length;
       sInfo.fullVertices[comp] = new float[2*num];
       float[] t = sInfo.fullVertices[comp];
       for( int vertex=0; vertex<num; vertex++)
+        {
         t[2*vertex  ] = vert[vertex][0] / info.scale;
         t[2*vertex+1] = vert[vertex][1] / info.scale;
+        }
+      }
     sInfo.vertices = computeOuterEdge(sInfo.fullVertices);
     mStickerCoords.add(sInfo);
     info.sticker = mStickerCoords.size() -1;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // polygon
-b82486
+            Leszek Koltunski
-af68038
+  private FaceTransform constructNewTransform(final float[][] vert3D, boolean isOuter, int face, int numFaces)
-b82486
+            Leszek Koltunski
     FaceTransform ft = new FaceTransform();
-af68038
+    ft.face = face;
     ft.numFaces = numFaces;
-b82486
+            Leszek Koltunski
     // compute center of gravity
     ft.vx = 0.0f;
     ft.vy = 0.0f;
     ft.vz = 0.0f;
     int len = vert3D.length;
-ef6378
+    for (float[] vert : vert3D)
-b82486
+            Leszek Koltunski
       ft.vx += vert[0];
       ft.vy += vert[1];
       ft.vz += vert[2];
+      }
     ft.vx /= len;
     ft.vy /= len;
     ft.vz /= len;
     // move all vertices so that their center of gravity is at (0,0,0)
     for (int i=0; i<len; i++)
+      {
       vert3D[i][0] -= ft.vx;
       vert3D[i][1] -= ft.vy;
       vert3D[i][2] -= ft.vz;
+      }
     // find 3 non-colinear vertices
     int foundIndex = -1;
     for(int vertex=2; vertex<len; vertex++)
+      {
       if( !areColinear(vert3D,0,1,vertex) )
+        {
         foundIndex = vertex;
         break;
+        }
+      }
     // compute the normal vector
     if( foundIndex==-1 )
+      {
-dc1
+      StringBuilder sb = new StringBuilder();
-e80135b
+      for (float[] floats : vert3D)
-dc1
+            Leszek Koltunski
         sb.append(' ');
         sb.append("(");
-e80135b
+        sb.append(floats[0]);
-dc1
+        sb.append(" ");
-e80135b
+        sb.append(floats[1]);
-dc1
+        sb.append(" ");
-e80135b
+        sb.append(floats[2]);
-dc1
+        sb.append(")");
+        }
       android.util.Log.e("D", "verts: "+sb);
-b82486
+      throw new RuntimeException("all vertices colinear");
+      }
     computeNormalVector(vert3D,0,1,foundIndex);
     // rotate so that the normal vector becomes (0,0,1)
-ef6378
+    float axisX, axisY, axisZ;
-b82486
+            Leszek Koltunski
     if( mBuffer[0]!=0.0f || mBuffer[1]!=0.0f )
+      {
       axisX = -mBuffer[1];
       axisY =  mBuffer[0];
       axisZ = 0.0f;
-ef6378
+      float axiLen = axisX*axisX + axisY*axisY;
       axiLen = (float)Math.sqrt(axiLen);
-b82486
+      axisX /= axiLen;
       axisY /= axiLen;
       axisZ /= axiLen;
+      }
     else
+      {
       axisX = 0.0f;
       axisY = 1.0f;
       axisZ = 0.0f;
+      }
-ef6378
+    float cosTheta = mBuffer[2];
     float sinTheta = (float)Math.sqrt(1-cosTheta*cosTheta);
     float sinHalfTheta = computeSinHalf(cosTheta);
     float cosHalfTheta = computeCosHalf(sinTheta,cosTheta);
-b82486
+            Leszek Koltunski
     mQuat1[0] = axisX*sinHalfTheta;
     mQuat1[1] = axisY*sinHalfTheta;
     mQuat1[2] = axisZ*sinHalfTheta;
     mQuat1[3] = cosHalfTheta;
     mQuat2[0] =-axisX*sinHalfTheta;
     mQuat2[1] =-axisY*sinHalfTheta;
     mQuat2[2] =-axisZ*sinHalfTheta;
     mQuat2[3] = cosHalfTheta;
-ef6378
+    for (float[] vert : vert3D)
-b82486
+            Leszek Koltunski
-            d809bf6f
+      QuatHelper.quatMultiply(mQuat3, mQuat1, vert  );
       QuatHelper.quatMultiply(  vert, mQuat3, mQuat2);
-b82486
+            Leszek Koltunski
     // fit the whole thing in a square and remember the scale & 2D vertices
-d26b
+    fitInSquare(ft, vert3D, isOuter);
-b82486
+            Leszek Koltunski
     // remember the rotation
     ft.qx =-mQuat1[0];
     ft.qy =-mQuat1[1];
     ft.qz =-mQuat1[2];
     ft.qw = mQuat1[3];
     return ft;
+    }
-            fe3dec09
+///////////////////////////////////////////////////////////////////////////////////////////////////
 // multigon
   private FaceTransform constructNewTransform(final float[][][] vert3D, boolean isOuter, int face, int numFaces)
+    {
     FaceTransform ft = new FaceTransform();
     ft.face = face;
     ft.numFaces = numFaces;
     // compute center of gravity
     ft.vx = 0.0f;
     ft.vy = 0.0f;
     ft.vz = 0.0f;
     int len = 0;
     for( float[][] vert : vert3D )
       for( float[] v : vert )
+        {
         ft.vx += v[0];
         ft.vy += v[1];
         ft.vz += v[2];
         len++;
+        }
     ft.vx /= len;
     ft.vy /= len;
     ft.vz /= len;
     // move all vertices so that their center of gravity is at (0,0,0)
     for( float[][] vert : vert3D )
       for( float[] v : vert )
+        {
         v[0] -= ft.vx;
         v[1] -= ft.vy;
         v[2] -= ft.vz;
+        }
     // find 3 non-colinear vertices
     int foundIndex = -1;
     len = vert3D[0].length;
     for(int vertex=2; vertex<len; vertex++)
+      {
       if( !areColinear(vert3D[0],0,1,vertex) )
+        {
         foundIndex = vertex;
         break;
+        }
+      }
     // compute the normal vector
     if( foundIndex==-1 )
+      {
       StringBuilder sb = new StringBuilder();
       for (float[] v : vert3D[0])
+        {
         sb.append(' ');
         sb.append("(");
         sb.append(v[0]);
         sb.append(" ");
         sb.append(v[1]);
         sb.append(" ");
         sb.append(v[2]);
         sb.append(")");
+        }
       android.util.Log.e("D", "verts: "+sb);
       throw new RuntimeException("all vertices colinear");
+      }
     computeNormalVector(vert3D[0],0,1,foundIndex);
     // rotate so that the normal vector becomes (0,0,1)
     float axisX, axisY, axisZ;
     if( mBuffer[0]!=0.0f || mBuffer[1]!=0.0f )
+      {
       axisX = -mBuffer[1];
       axisY =  mBuffer[0];
       axisZ = 0.0f;
       float axiLen = axisX*axisX + axisY*axisY;
       axiLen = (float)Math.sqrt(axiLen);
       axisX /= axiLen;
       axisY /= axiLen;
       axisZ /= axiLen;
+      }
     else
+      {
       axisX = 0.0f;
       axisY = 1.0f;
       axisZ = 0.0f;
+      }
     float cosTheta = mBuffer[2];
     float sinTheta = (float)Math.sqrt(1-cosTheta*cosTheta);
     float sinHalfTheta = computeSinHalf(cosTheta);
     float cosHalfTheta = computeCosHalf(sinTheta,cosTheta);
     mQuat1[0] = axisX*sinHalfTheta;
     mQuat1[1] = axisY*sinHalfTheta;
     mQuat1[2] = axisZ*sinHalfTheta;
     mQuat1[3] = cosHalfTheta;
     mQuat2[0] =-axisX*sinHalfTheta;
     mQuat2[1] =-axisY*sinHalfTheta;
     mQuat2[2] =-axisZ*sinHalfTheta;
     mQuat2[3] = cosHalfTheta;
     for( float[][] vert : vert3D)
       for( float[] v : vert)
+        {
         QuatHelper.quatMultiply(mQuat3, mQuat1, v  );
         QuatHelper.quatMultiply(  v, mQuat3, mQuat2);
+        }
     // fit the whole thing in a square and remember the scale & 2D vertices
     fitInSquare(ft, vert3D, isOuter);
     // remember the rotation
     ft.qx =-mQuat1[0];
     ft.qy =-mQuat1[1];
     ft.qz =-mQuat1[2];
     ft.qw = mQuat1[3];
     return ft;
+    }
-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
-ef6378
+  private void rotateAllVertices(float[] result, int len, float[] vertices, float sin, float cos)
-b82486
+            Leszek Koltunski
     for(int i=0; i<len; i++)
+      {
-            fe3dec09
+      float x = vertices[2*i];
       float y = vertices[2*i+1];
       result[2*i  ] = x*cos - y*sin;
       result[2*i+1] = x*sin + y*cos;
-b82486
+            Leszek Koltunski
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-ef6378
+  private float computeScale(float[] v1, float[] v2, int v1i, int v2i)
-b82486
+            Leszek Koltunski
-ef6378
+    float v1x = v1[2*v1i];
     float v1y = v1[2*v1i+1];
     float v2x = v2[2*v2i];
     float v2y = v2[2*v2i+1];
-b82486
+            Leszek Koltunski
-ef6378
+    float lenSq1 = v1x*v1x + v1y*v1y;
     float lenSq2 = v2x*v2x + v2y*v2y;
-b82486
+            Leszek Koltunski
-ef6378
+    return (float)Math.sqrt(lenSq2/lenSq1);
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // valid for 0<angle<2*PI
-ef6378
+  private float computeSinHalf(float cos)
-b82486
+            Leszek Koltunski
-ef6378
+    return (float)Math.sqrt((1-cos)/2);
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // valid for 0<angle<2*PI
-ef6378
+  private float computeCosHalf(float sin, float cos)
-b82486
+            Leszek Koltunski
-ef6378
+    float cosHalf = (float)Math.sqrt((1+cos)/2);
-b82486
+    return sin<0 ? -cosHalf : cosHalf;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-b69f3
+  private int computeRotatedIndex(int oldVertex, int len, int rotatedVertex)
-b82486
+            Leszek Koltunski
-b69f3
+    int v = (rotatedVertex + oldVertex);
-b82486
+    if( v>=len ) v-=len;
     if( v< 0   ) v+=len;
     return v;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-b69f3
+  private boolean isScaledVersionOf(float[] newVert, float[] oldVert, int len, int vertex)
-b82486
+            Leszek Koltunski
-b69f3
+    int newZeroIndex = computeRotatedIndex(0,len,vertex);
-ef6378
+    float EPSILON = 0.001f;
     float scale = computeScale(newVert,oldVert,newZeroIndex,0);
-b82486
+            Leszek Koltunski
     for(int i=1; i<len; i++)
+      {
-b69f3
+      int index = computeRotatedIndex(i,len,vertex);
-b82486
+            Leszek Koltunski
-ef6378
+      float horz = oldVert[2*i  ] - scale*newVert[2*index  ];
       float vert = oldVert[2*i+1] - scale*newVert[2*index+1];
-b82486
+            Leszek Koltunski
       if( horz>EPSILON || horz<-EPSILON || vert>EPSILON || vert<-EPSILON ) return false;
+      }
     return true;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-b69f3
+  private void correctInfo(FaceTransform info, float scale, float sin, float cos, int oldSticker)
-b82486
+            Leszek Koltunski
     mStickerCoords.remove(info.sticker);
     info.sticker = oldSticker;
     info.scale  *= scale;
     mQuat1[0] = info.qx;
     mQuat1[1] = info.qy;
     mQuat1[2] = info.qz;
     mQuat1[3] = info.qw;
-ef6378
+    float sinHalf = computeSinHalf(cos);
     float cosHalf = computeCosHalf(sin,cos);
-b82486
+            Leszek Koltunski
-b69f3
+    mQuat2[0] = 0.0f;
     mQuat2[1] = 0.0f;
     mQuat2[2] = sinHalf;
     mQuat2[3] = cosHalf;
-b82486
+            Leszek Koltunski
-            d809bf6f
+    QuatHelper.quatMultiply( mQuat3, mQuat1, mQuat2 );
-b82486
+            Leszek Koltunski
     info.qx = mQuat3[0];
     info.qy = mQuat3[1];
     info.qz = mQuat3[2];
     info.qw = mQuat3[3];
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private void printVert(double[] buffer)
+    {
     int len = buffer.length/2;
     String str = "";
     for(int i=0; i<len; i++)
+      {
       str += (" ("+buffer[2*i]+" , "+buffer[2*i+1]+" ) ");
+      }
     android.util.Log.d("D", str);
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            bf4e7e68
+  private boolean foundVertex(FaceTransform info, float[] buffer, int len, float[] newVert, float[] oldVert, int oldSticker)
-b82486
+            Leszek Koltunski
-            bf4e7e68
+    int lenVertOld = oldVert.length/2;
     float lenOld=0.0f, oldX=0.0f, oldY=0.0f;
     for(int oldV=0; oldV<lenVertOld; oldV++)
+      {
       oldX = oldVert[2*oldV];
       oldY = oldVert[2*oldV+1];
       lenOld = (float)Math.sqrt(oldX*oldX + oldY*oldY);
       if( lenOld!=0 ) break;
+      }
-b82486
+    for(int vertex=0; vertex<len; vertex++)
+      {
-ef6378
+      float newX = newVert[2*vertex  ];
       float newY = newVert[2*vertex+1];
-            bf4e7e68
+      float lenNew = (float)Math.sqrt(newX*newX + newY*newY);
-b82486
+            Leszek Koltunski
-            bf4e7e68
+      if( lenNew!=0 )
-b82486
+            Leszek Koltunski
-            bf4e7e68
+        float cos = (float)QuatHelper.computeCos( oldX, oldY, newX, newY, lenNew, lenOld);
         float sin = (float)QuatHelper.computeSin( oldX, oldY, newX, newY, lenNew, lenOld);
         rotateAllVertices(buffer,len,newVert,sin,cos);
         if( isScaledVersionOf(buffer,oldVert,len,vertex) )
+          {
           int newZeroIndex = computeRotatedIndex(0,len,vertex);
           float scale = computeScale(oldVert,newVert,0,newZeroIndex);
           correctInfo(info,scale,sin,cos,oldSticker);
           return true;
+          }
-b82486
+            Leszek Koltunski
+      }
     return false;
+    }
-            d99de43c
+///////////////////////////////////////////////////////////////////////////////////////////////////
   private float computeCoreDistance(float[] verts)
+    {
     float ret = 0.0f;
     float centerX=0.0f,centerY=0.0f;
     int len = verts.length/2;
     for(int i=0; i<len; i++)
+      {
       centerX += verts[2*i  ];
       centerY += verts[2*i+1];
+      }
     centerX /= (2*len);
     centerY /= (2*len);
     for(int i=0; i<len; i++)
+      {
       float distX = centerX-verts[2*i  ];
       float distY = centerY-verts[2*i+1];
       ret += (float)Math.sqrt(distX*distX + distY*distY);
+      }
     return ret;
+    }
-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
-aceea06
+// even if this is a multigon, then FaceTransform.vertices is the outer edge!
 // (see fitInSquare multigon variant)
-b82486
+            Leszek Koltunski
   private boolean successfullyCollapsedStickers(final FaceTransform newInfo, final FaceTransform oldInfo)
+    {
     StickerCoords sNewInfo = mStickerCoords.get(newInfo.sticker);
     StickerCoords sOldInfo = mStickerCoords.get(oldInfo.sticker);
-            d99de43c
+            Leszek Koltunski
-ef6378
+    float[] newVert = sNewInfo.vertices;
     float[] oldVert = sOldInfo.vertices;
-b82486
+    int oldLen = oldVert.length;
     int newLen = newVert.length;
-            f7d2e0e1
+    if( oldLen==newLen )
-b82486
+            Leszek Koltunski
-            bf4e7e68
+      float coreDistOld = computeCoreDistance(oldVert);                     // the two stickers are at different scales,
-            d99de43c
+      float coreDistNew = computeCoreDistance(newVert);                     // so even if they are in fact the same, do not
       float diff = (coreDistOld*oldInfo.scale)/(coreDistNew*newInfo.scale); // collapse them into one. Example: Master Skewb
       if( diff<1.0-MAX_CORE_DIFF || diff>1.0+MAX_CORE_DIFF ) return false;  // and two triangular stickers of different size.
-b82486
+      int oldSticker = oldInfo.sticker;
-ef6378
+      float[] buffer1 = new float[oldLen];
-            bf4e7e68
+            Leszek Koltunski
       if( foundVertex(newInfo, buffer1, oldLen/2, newVert, oldVert, oldSticker) )
-            f7d2e0e1
+            Leszek Koltunski
-            d99de43c
+        if( sNewInfo.outer ) sOldInfo.outer = true;
-            f7d2e0e1
+        return true;
+        }
-b82486
+            Leszek Koltunski
     return false;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            fe3dec09
+// polygon
-b82486
+            Leszek Koltunski
-ef6378
+  private float[][] constructVert(float[][] vertices, int[] index)
-b82486
+            Leszek Koltunski
     int len = index.length;
-ef6378
+    float[][] ret = new float[len][4];
-b82486
+            Leszek Koltunski
     for(int i=0; i<len; i++)
+      {
-a17011
+      float[] tmp = vertices[index[i]];
       ret[i][0] = tmp[0];
       ret[i][1] = tmp[1];
       ret[i][2] = tmp[2];
-b82486
+      ret[i][3] = 1.0f;
+      }
     return ret;
+    }
-            fe3dec09
+///////////////////////////////////////////////////////////////////////////////////////////////////
 // multigon
   private float[][][] constructVert(float[][] vertices, int[][] index)
+    {
     int len = index.length;
     float[][][] ret = new float[len][][];
     for(int i=0; i<len; i++)
+      {
       int[] ind = index[i];
       int num = ind.length;
       ret[i] = new float[num][4];
       for(int j=0; j<num; j++)
+        {
         float[] r = ret[i][j];
         float[] v = vertices[ind[j]];
         r[0] = v[0];
         r[1] = v[1];
         r[2] = v[2];
         r[3] = 1.0f;
+        }
+      }
     return ret;
+    }
-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
-a17011
+  private void applyVertexEffects(MeshBase mesh, ObjectVertexEffects effects, int meshState)
-b82486
+            Leszek Koltunski
-a17011
+    boolean[] uses      = effects.getUses();
     String[] names      = effects.getNames();
     float[][] variables = effects.getVariables();
     float[][] centers   = effects.getCenters();
     float[][] regions   = effects.getRegions();
     int numEffects = uses.length;
     for(int eff=0; eff<numEffects; eff++)
       if( names[eff]!=null && (meshState==MESH_NICE || uses[eff]) )
-b82486
+            Leszek Koltunski
-a17011
+        VertexEffect effect = VertexEffect.constructEffect(names[eff],variables[eff],centers[eff],regions[eff]);
         if( effect!=null ) mesh.apply(effect);
-b82486
+            Leszek Koltunski
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private void correctComponents(MeshBase mesh, int numComponents)
+    {
     int numTexToBeAdded = numComponents-mesh.getNumTexComponents();
     mesh.mergeEffComponents();
     for(int i=0; i<numTexToBeAdded; i++ ) mesh.addEmptyTexComponent();
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private void printTransform(FaceTransform f)
+    {
-af68038
+    android.util.Log.e("D", "face="+f.face+" q=("+f.qx+", "+f.qy+", "+f.qz+", "+f.qw+") v=("
-b69f3
+                       +f.vx+", "+f.vy+", "+f.vz+") scale="+f.scale+" sticker="+f.sticker);
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            b2c77ec3
+  private float[] computeBands(float H, int alpha, float dist, float K, int N)
-b82486
+            Leszek Koltunski
     float[] bands = new float[2*N];
     bands[0] = 1.0f;
     bands[1] = 0.0f;
     float beta = (float)Math.atan(dist*Math.tan(Math.PI*alpha/180));
     float sinBeta = (float)Math.sin(beta);
     float cosBeta = (float)Math.cos(beta);
     float R = cosBeta<1.0f ? H/(1.0f-cosBeta) : 0.0f;
     float D = R*sinBeta;
     float B = h(R,sinBeta,K*beta);
     if( D>1.0f )
+      {
       for(int i=1; i<N; i++)
+        {
         bands[2*i  ] = (float)(N-1-i)/(N-1);
         bands[2*i+1] = H*(1-bands[2*i]);
+        }
+      }
     else
+      {
       int K2 = (int)((N-3)*K);
       int K1 = (N-3)-K2;
       for(int i=0; i<=K1; i++)
+        {
         float angle = K*beta + (1-K)*beta*(K1-i)/(K1+1);
         float x = h(R,sinBeta,angle);
         bands[2*i+2] = 1.0f - x;
         bands[2*i+3] = g(R,D,x,cosBeta);
+        }
       for(int i=0; i<=K2; i++)
+        {
         float x = (1-B)*(i+1)/(K2+1) + B;
         bands[2*K1+2 + 2*i+2] = 1.0f - x;
         bands[2*K1+2 + 2*i+3] = g(R,D,f(D,B,x),cosBeta);
+        }
+      }
     bands[2*N-2] = 0.0f;
     bands[2*N-1] =    H;
     return bands;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            b2c77ec3
+  private void computeConvexityCenter(float[] out, float[] in, FaceTransform ft)
+    {
     if( in==null )
+      {
       out[0] = out[1] = 0.0f;
+      }
     else
+      {
       out[0] = in[0] - ft.vx;
       out[1] = in[1] - ft.vy;
       out[2] = in[2] - ft.vz;
       out[3] = 1.0f;
       mQuat1[0] =-ft.qx;
       mQuat1[1] =-ft.qy;
       mQuat1[2] =-ft.qz;
       mQuat1[3] = ft.qw;
       mQuat2[0] = -mQuat1[0];
       mQuat2[1] = -mQuat1[1];
       mQuat2[2] = -mQuat1[2];
-a17011
+      mQuat2[3] =  mQuat1[3];
-            b2c77ec3
+            Leszek Koltunski
-            d809bf6f
+      QuatHelper.quatMultiply( mQuat3, mQuat1,    out);
       QuatHelper.quatMultiply(    out, mQuat3, mQuat2);
-            b2c77ec3
+            Leszek Koltunski
       out[0] /= ft.scale;
       out[1] /= ft.scale;
       out[2] /= ft.scale;
+      }
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private void changeStickerPointers(int[][] table, int oldPointer, int newPointer)
+    {
     int len = table.length;
     for(int i=0; i<len; i++)
+      {
       int lenInner = table[i].length;
       for(int j=0; j<lenInner; j++)
         if( table[i][j]==oldPointer ) table[i][j] = newPointer;
+      }
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // INTERNAL API
-            f7d2e0e1
+  public int printStickerCoords()
-b82486
+            Leszek Koltunski
     int stickers = mStickerCoords.size();
-            f7d2e0e1
+    int ret = 0;
-b82486
+            Leszek Koltunski
     android.util.Log.d("D", "---- STICKER COORDS ----");
     for(int s=0; s<stickers; s++)
+      {
       StickerCoords info = mStickerCoords.get(s);
-            f7d2e0e1
+      if( info.outer )  ret++;
-b82486
+            Leszek Koltunski
-a74f
+      String ver = (info.outer?"OUTER":"INNER")+" scale: "+info.scale+" { ";
-            f7d2e0e1
+      int len = info.vertices.length/2;
-d26b
+            Leszek Koltunski
-            f7d2e0e1
+      for(int i =0; i<len; i++)
+        {
         if( i!=0 ) ver += ", ";
         ver += ( info.vertices[2*i]+"f, "+info.vertices[2*i+1]+"f");
-d26b
+            Leszek Koltunski
-            f7d2e0e1
+            Leszek Koltunski
       ver += " }";
       android.util.Log.d("D", ver);
-b82486
+            Leszek Koltunski
     android.util.Log.d("D", "---- END STICKER COORDS ----");
-            f7d2e0e1
+            Leszek Koltunski
     return ret;
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public void printFaceTransform()
+    {
     android.util.Log.d("D", "---- OLD FACE TRANSFORM ---");
     int oldfaces = mOldFaceTransf.size();
     for(int f=0; f<oldfaces; f++)
+      {
       printTransform(mOldFaceTransf.get(f));
+      }
     android.util.Log.d("D", "---- NEW FACE TRANSFORM ---");
     int newfaces = mNewFaceTransf.size();
     for(int f=0; f<newfaces; f++)
+      {
       printTransform(mNewFaceTransf.get(f));
+      }
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            b2c77ec3
+// PUBLIC API
-b82486
+            Leszek Koltunski
-            b2c77ec3
+  public static FactoryCubit getInstance()
-b82486
+            Leszek Koltunski
-            b2c77ec3
+    if( mThis==null ) mThis = new FactoryCubit();
     return mThis;
-b82486
+            Leszek Koltunski
-a17011
+///////////////////////////////////////////////////////////////////////////////////////////////////
   public static ObjectVertexEffects generateVertexEffect( float[][] vertices,
                                                           float[][] corners, int[] cornerIndices,
                                                           float[][] centers, int[] centerIndices )
+    {
     int numVerts = vertices.length;
     String[] names = new String[numVerts];
     float[][] vars = new float[numVerts][];
     float[][] cents= new float[numVerts][];
     float[][] regs = new float[numVerts][];
     boolean[] uses = new boolean[numVerts];
     for(int i=0; i<numVerts; i++)
+      {
       int centerI = centerIndices[i];
       int cornerI = cornerIndices[i];
       if( centerI>=0 && cornerI>=0 )
+        {
         float[] ce = centers[centerI];
         float[] ve = vertices[i];
         float S = corners[cornerI][0];
         float R = corners[cornerI][1];
         float CX = ve[0];
         float CY = ve[1];
         float CZ = ve[2];
         float X = S*(ce[0]-CX);
         float Y = S*(ce[1]-CY);
         float Z = S*(ce[2]-CZ);
         names[i]= NAME;
         vars[i] = new float[] { 0, X,Y,Z, 1 };
         cents[i]= new float[] { CX, CY, CZ };
         regs[i] = new float[] { 0,0,0, R };
         uses[i] = false;
+        }
+      }
     return new ObjectVertexEffects(names,vars,cents,regs,uses);
+    }
-a74f
+///////////////////////////////////////////////////////////////////////////////////////////////////
-d2493ea
+  public float[] getStickerScales()
-a74f
+            Leszek Koltunski
     int index=0,num=0,len = mStickerCoords.size();
-d2493ea
+    for(int i=0; i<len; i++) if( mStickerCoords.get(i).outer ) num++;
-a74f
+            Leszek Koltunski
     if( num>0 )
+      {
-            b2c77ec3
+      float[] scales = new float[num];
-a74f
+            Leszek Koltunski
       for(int i=0; i<len; i++)
+        {
         StickerCoords sticker = mStickerCoords.get(i);
-d2493ea
+        if( sticker.outer ) scales[index++] = sticker.scale;
-a74f
+            Leszek Koltunski
-            b2c77ec3
+      return scales;
-a74f
+            Leszek Koltunski
     return null;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-d2493ea
+  public float[][] getStickerCoords()
-a74f
+            Leszek Koltunski
     int index=0,num=0,len = mStickerCoords.size();
-d2493ea
+    for(int i=0; i<len; i++) if( mStickerCoords.get(i).outer ) num++;
-a74f
+            Leszek Koltunski
     if( num>0 )
+      {
-            b2c77ec3
+      float[][] coords = new float[num][];
-a74f
+            Leszek Koltunski
       for(int i=0; i<len; i++)
+        {
         StickerCoords sticker = mStickerCoords.get(i);
-d2493ea
+        if( sticker.outer ) coords[index++] = sticker.vertices;
-a74f
+            Leszek Koltunski
-            b2c77ec3
+      return coords;
-a74f
+            Leszek Koltunski
     return null;
+    }
-af68038
+///////////////////////////////////////////////////////////////////////////////////////////////////
   public int[][] getStickerVariants()
+    {
     int numvariants = 1; // there's one in the 'new' array
     int oldfaces = mOldFaceTransf.size();
     for(int f=0; f<oldfaces; f++)
+      {
       FaceTransform ft = mOldFaceTransf.get(f);
       if( ft.face==0 ) numvariants++;
+      }
     int[][] ret = new int[numvariants][];
     int inner=0, index=-1;
     for(int f=0; f<oldfaces; f++)
+      {
       FaceTransform ft = mOldFaceTransf.get(f);
       if( ft.face==0 )
+        {
         index++;
         inner=0;
         ret[index] = new int[ft.numFaces];
+        }
       ret[index][inner++] = ft.sticker;
+      }
     int newfaces = mNewFaceTransf.size();
     for(int f=0; f<newfaces; f++)
+      {
       FaceTransform ft = mNewFaceTransf.get(f);
       if( ft.face==0 )
+        {
         index++;
         inner=0;
         ret[index] = new int[ft.numFaces];
+        }
       ret[index][inner++] = ft.sticker;
+      }
     int numStickers = mStickerCoords.size();
     int numOuter=0;
     for(int i=0; i<numStickers; i++)
+      {
       StickerCoords sc = mStickerCoords.get(i);
       if( sc.outer )
+        {
         changeStickerPointers(ret,i,numOuter);
         numOuter++;
+        }
       else
+        {
         changeStickerPointers(ret,i,-1);
+        }
+      }
     return ret;
+    }
-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
-            b2c77ec3
+  public void clear()
-b82486
+            Leszek Koltunski
-            b2c77ec3
+    mStickerCoords.clear();
     mNewFaceTransf.clear();
     mOldFaceTransf.clear();
+    }
-            df781f1d
+///////////////////////////////////////////////////////////////////////////////////////////////////
 // This is for FactoryBandaged3x3Cubit. We need to know which direction each face faces.
 // This assumes the factory has just been cleared and 'createNewFaceTransform' has just
 // been called.
   public Static4D getQuaternion(int face)
+    {
     FaceTransform ft = mNewFaceTransf.get(face);
     return ft!=null ? new Static4D(ft.qx,ft.qy,ft.qz,ft.qw) : null;
+    }
-            b2c77ec3
+///////////////////////////////////////////////////////////////////////////////////////////////////
-a971c1
+  public void createNewFaceTransform(final ObjectShape shape, int[] outer)
-            b2c77ec3
+            Leszek Koltunski
     float[][] vertices = shape.getVertices();
     int[][] indices = shape.getVertIndices();
-            fe3dec09
+    int[][][] fullIndices = shape.getMultigonIndices();
     boolean isMultigon = shape.isMultigon();
-            b2c77ec3
+    FaceTransform ft;
     int numNew = mNewFaceTransf.size();
     for(int i=0; i<numNew; i++)
+      {
       ft = mNewFaceTransf.remove(0);
       mOldFaceTransf.add(ft);
+      }
-            fe3dec09
+    int numFaces = shape.getNumFaces();
-            b2c77ec3
+    int numOld = mOldFaceTransf.size();
     for (int face=0; face<numFaces; face++)
+      {
       boolean collapsed = false;
-a971c1
+      boolean isOuter = (outer!=null && outer[face]>0);
-            fe3dec09
+      FaceTransform newT;
       if( !isMultigon )
+        {
         float[][] vert = constructVert(vertices, indices[face]);
         newT = constructNewTransform(vert,isOuter,face,numFaces);
+        }
       else
+        {
         float[][][] vert = constructVert(vertices, fullIndices[face]);
         newT = constructNewTransform(vert,isOuter,face,numFaces);
+        }
-            b2c77ec3
+            Leszek Koltunski
       for (int old=0; !collapsed && old<numOld; old++)
+        {
         ft = mOldFaceTransf.get(old);
         if (successfullyCollapsedStickers(newT, ft)) collapsed = true;
+        }
       for (int pre=0; !collapsed && pre<face; pre++)
+        {
         ft = mNewFaceTransf.get(pre);
         if (successfullyCollapsedStickers(newT, ft)) collapsed = true;
+        }
       mNewFaceTransf.add(newT);
+      }
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-a17011
+  public MeshBase createRoundedSolid(final ObjectShape shape, final ObjectFaceShape faceShape,
                                      final ObjectVertexEffects effects, int meshState, int numComponents)
-b82486
+            Leszek Koltunski
-            b2c77ec3
+    float[][] bands         = faceShape.getBands();
     int[]   bandIndexes     = faceShape.getBandIndices();
     float[] convexityCenter = faceShape.getConvexityCenter();
-            fe3dec09
+    int numFaces = shape.getNumFaces();
-fb62bf
+    float[] band, bandsComputed;
-b82486
+    MeshBase[] meshes = new MeshBase[numFaces];
     FaceTransform fInfo;
     StickerCoords sInfo;
-ef6378
+    float[] convexXY = new float[4];
-fb62bf
+    int exIndex=0, exVertices=0, alpha=0, N=0;
     float height=0.0f, dist=0.0f, K=0.0f;
-b82486
+            Leszek Koltunski
     for(int face=0; face<numFaces; face++)
+      {
       fInfo = mNewFaceTransf.get(face);
       computeConvexityCenter(convexXY,convexityCenter,fInfo);
-bc272d
+      int index = bandIndexes[face];
       band = bands[index];
-            c3a033e9
+            Leszek Koltunski
       switch(meshState)
+        {
-fb62bf
+        case MESH_NICE: height     = band[0];
                         alpha      = (int)band[1];
                         dist       = band[2];
                         K          = band[3];
                         N          = (int)band[4];
-            c3a033e9
+                        exIndex    = (int)band[5];
                         exVertices = (int)band[6];
                         break;
-fb62bf
+        case MESH_FAST: height     = band[0]<0 ? band[0] : 0;  // the negative heights are of the internal walls, leave that
                                                                // (example: Ivy cube center and edge cubits!)
                         alpha      = 0;
                         dist       = 0;
                         K          = 0;
                         N          = 2;
-            c3a033e9
+                        exIndex    = 0;
                         exVertices = 0;
                         break;
+        }
-fb62bf
+      bandsComputed = computeBands(height,alpha,dist,K,N);
-            fe3dec09
+            Leszek Koltunski
-aceea06
+      sInfo = mStickerCoords.get(fInfo.sticker);
       float[][] vertsF = sInfo.fullVertices;
       // i.e. multigon which hasn't been 'successfully collapsed'
       // with a previously computed polygon sticker!
       if( vertsF!=null )
-            fe3dec09
+            Leszek Koltunski
-aceea06
+        int lenVerts = vertsF.length;
-            fe3dec09
+        float[][] copiedVerts = new float[lenVerts][];
         for(int i=0; i<lenVerts; i++)
+          {
-aceea06
+          float[] v = vertsF[i];
-            fe3dec09
+          int len = v.length;
           copiedVerts[i] = new float[len];
           System.arraycopy(v, 0, copiedVerts[i], 0, len);
+          }
         meshes[face] = new MeshMultigon(copiedVerts,bandsComputed,exIndex,exVertices);
+        }
-aceea06
+      else
+        {
         float[] verts = sInfo.vertices;
         int lenVerts = verts.length;
         float[] copiedVerts = new float[lenVerts];
         System.arraycopy(verts, 0, copiedVerts, 0, lenVerts);
         meshes[face] = new MeshPolygon(copiedVerts,bandsComputed,exIndex,exVertices, convexXY[0], convexXY[1]);
+        }
-            fe3dec09
+            Leszek Koltunski
-b5d4a7b
+      meshes[face].setEffectAssociation(0,0,face);
-b82486
+            Leszek Koltunski
     MeshBase mesh = new MeshJoined(meshes);
     Static3D center = new Static3D(0,0,0);
     for(int face=0; face<numFaces; face++)
+      {
       fInfo = mNewFaceTransf.get(face);
-ef6378
+      float vx = fInfo.vx;
       float vy = fInfo.vy;
       float vz = fInfo.vz;
       float sc = fInfo.scale;
       float qx = fInfo.qx;
       float qy = fInfo.qy;
       float qz = fInfo.qz;
       float qw = fInfo.qw;
-b82486
+            Leszek Koltunski
-b69f3
+      Static3D scale = new Static3D(sc,sc,sc);
-b82486
+      Static3D move3D= new Static3D(vx,vy,vz);
       Static4D quat  = new Static4D(qx,qy,qz,qw);
-b5d4a7b
+      mesh.apply(new MatrixEffectScale(scale)           ,0,face);
       mesh.apply(new MatrixEffectQuaternion(quat,center),0,face);
       mesh.apply(new MatrixEffectMove(move3D)           ,0,face);
-b82486
+            Leszek Koltunski
-d97487
+    correctComponents(mesh,numComponents);
-a17011
+    if( effects!=null ) applyVertexEffects(mesh,effects,meshState);
-b82486
+            Leszek Koltunski
     return mesh;
+    }
+  }

Project

General

Profile

TwistyPuzzleLib

distorted-objectlib / src / main / java / org / distorted / objectlib / helpers / FactoryCubit.java @ 9cd63ba8