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

distorted-objectlib / src / main / java / org / distorted / objectlib / helpers / FactoryCubit.java @ 43668bcc

-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;
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 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
-bf6b98
+    float[][][] outerVertices;
-b9d1df5
+    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));
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-b9d1df5
+  private boolean areNotColinear(float[][] vertices, int index)
-b82486
+            Leszek Koltunski
-b9d1df5
+    float x1 = vertices[0][0];
     float y1 = vertices[0][1];
     float z1 = vertices[0][2];
     float x2 = vertices[1][0];
     float y2 = vertices[1][1];
     float z2 = vertices[1][2];
     float x3 = vertices[index][0];
     float y3 = vertices[index][1];
     float z3 = vertices[index][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) );
-e9a35eb
+    return !(v1x==A*v2x && v1y==A*v2y && v1z==A*v2z);
-b82486
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-b9d1df5
+  private void computeNormalVector(float[][] vertices, int index)
-b82486
+            Leszek Koltunski
-b9d1df5
+    float x1 = vertices[0][0];
     float y1 = vertices[0][1];
     float z1 = vertices[0][2];
     float x2 = vertices[1][0];
     float y2 = vertices[1][1];
     float z2 = vertices[1][2];
     float x3 = vertices[index][0];
     float y3 = vertices[index][1];
     float z3 = vertices[index][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
+///////////////////////////////////////////////////////////////////////////////////////////////////
-bf6b98
+  private float[][][] computeOuterEdge(float[][][] vertices)
-            fe3dec09
+            Leszek Koltunski
-e9a35eb
+    int[][] edgesUp = MeshMultigon.computeEdgesUp(vertices);
-bf6b98
+    return MeshMultigon.computeOuterAndHoleVertices(vertices,edgesUp);
-            fe3dec09
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // 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;
-bf6b98
+    sInfo.outerVertices = new float[1][len][2];
-            fe3dec09
+    sInfo.fullVertices = null;
-b82486
+            Leszek Koltunski
-a9ae
+    float[][] t = sInfo.outerVertices[0];
-b82486
+    for( int vertex=0; vertex<len; vertex++ )
+      {
-a9ae
+      t[vertex][0] = vert3D[vertex][0] / info.scale;
       t[vertex][1] = vert3D[vertex][1] / info.scale;
-b82486
+            Leszek Koltunski
     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;
-b9d1df5
+    sInfo.fullVertices = new float[len][][];
-            fe3dec09
+            Leszek Koltunski
     for( int comp=0; comp<len; comp++ )
+      {
       float[][] vert = vert3D[comp];
       int num = vert.length;
-b9d1df5
+      sInfo.fullVertices[comp] = new float[num][2];
       float[][] t = sInfo.fullVertices[comp];
-            fe3dec09
+            Leszek Koltunski
       for( int vertex=0; vertex<num; vertex++)
+        {
-b9d1df5
+        t[vertex][0] = vert[vertex][0] / info.scale;
         t[vertex][1] = vert[vertex][1] / info.scale;
-            fe3dec09
+            Leszek Koltunski
+      }
-bf6b98
+    sInfo.outerVertices = computeOuterEdge(sInfo.fullVertices);
-            fe3dec09
+            Leszek Koltunski
     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++)
+      {
-b9d1df5
+      if( areNotColinear(vert3D,vertex) )
-b82486
+            Leszek Koltunski
         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");
+      }
-b9d1df5
+    computeNormalVector(vert3D,foundIndex);
-b82486
+            Leszek Koltunski
     // 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++)
+      {
-b9d1df5
+      if( areNotColinear(vert3D[0],vertex) )
-            fe3dec09
+            Leszek Koltunski
         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");
+      }
-b9d1df5
+    computeNormalVector(vert3D[0],foundIndex);
-            fe3dec09
+            Leszek Koltunski
     // 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
+///////////////////////////////////////////////////////////////////////////////////////////////////
-e9a35eb
+  private void rotateAllVertices(float[][] result, int len, float[][] vertices, float sin, float cos)
-b82486
+            Leszek Koltunski
     for(int i=0; i<len; i++)
+      {
-e9a35eb
+      float x = vertices[i][0];
       float y = vertices[i][1];
       result[i][0] = x*cos - y*sin;
       result[i][1] = x*sin + y*cos;
-b82486
+            Leszek Koltunski
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-e9a35eb
+  private float computeScale(float[][] v1, float[][] v2, int v1i, int v2i)
-b82486
+            Leszek Koltunski
-e9a35eb
+    float v1x = v1[v1i][0];
     float v1y = v1[v1i][1];
     float v2x = v2[v2i][0];
     float v2y = v2[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;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-e9a35eb
+  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
-e9a35eb
+      float horz = oldVert[i][0] - scale*newVert[index][0];
       float vert = oldVert[i][1] - scale*newVert[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];
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-e9a35eb
+  private boolean foundVertex(FaceTransform info, float[][] buffer, float[][] newVert, float[][] oldVert, int oldSticker)
-b82486
+            Leszek Koltunski
-            bf4e7e68
+    float lenOld=0.0f, oldX=0.0f, oldY=0.0f;
-e9a35eb
+    int len = newVert.length;
-            bf4e7e68
+            Leszek Koltunski
-e9a35eb
+    for(float[] ov : oldVert)
-            bf4e7e68
+            Leszek Koltunski
-e9a35eb
+      oldX = ov[0];
       oldY = ov[1];
       lenOld = (float) Math.sqrt(oldX*oldX+oldY*oldY);
-            bf4e7e68
+            Leszek Koltunski
-e9a35eb
+      if(lenOld!=0) break;
-            bf4e7e68
+            Leszek Koltunski
-b82486
+    for(int vertex=0; vertex<len; vertex++)
+      {
-e9a35eb
+      float newX = newVert[vertex][0];
       float newY = newVert[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
+///////////////////////////////////////////////////////////////////////////////////////////////////
-e9a35eb
+  private float computeCoreDistance(float[][] verts)
-            d99de43c
+            Leszek Koltunski
     float ret = 0.0f;
     float centerX=0.0f,centerY=0.0f;
-e9a35eb
+    int len = verts.length;
-            d99de43c
+            Leszek Koltunski
-e9a35eb
+    for(float[] vert : verts)
-            d99de43c
+            Leszek Koltunski
-e9a35eb
+      centerX += vert[0];
       centerY += vert[1];
-            d99de43c
+            Leszek Koltunski
-e9a35eb
+    centerX /= len;
     centerY /= len;
-            d99de43c
+            Leszek Koltunski
-e9a35eb
+    for(float[] vert : verts)
-            d99de43c
+            Leszek Koltunski
-e9a35eb
+      float distX = centerX-vert[0];
       float distY = centerY-vert[1];
       ret += (float) Math.sqrt(distX*distX+distY*distY);
-            d99de43c
+            Leszek Koltunski
     return ret;
+    }
-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
-a9ae
+// even if this is a multigon, then StickerCoords.outerVertices is the outer edge!
-aceea06
+// (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
-bf6b98
+    if( sNewInfo.outerVertices.length>1 || sOldInfo.outerVertices.length>1 ) // the 'outer' path is composed of more than
       {                                                                      // one segment, i.e. the sticker has holes.
       return false;                                                          // do not collapse such stickers.
+      }
     float[][] newVert = sNewInfo.outerVertices[0];
     float[][] oldVert = sOldInfo.outerVertices[0];
-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;
-e9a35eb
+      float[][] buffer = new float[oldLen][2];
-            bf4e7e68
+            Leszek Koltunski
-e9a35eb
+      if( foundVertex(newInfo, buffer, 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
+///////////////////////////////////////////////////////////////////////////////////////////////////
-fda81c4
+  private void applyVertexEffects(MeshBase mesh, ObjectVertexEffects effects)
-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++)
-fda81c4
+      if( names[eff]!=null )
-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)
+    {
-a9ae
+    android.util.Log.e("D", "face="+f.face+" sticker="+f.sticker+" scale="+f.scale+
                             " q=("+f.qx+", "+f.qy+", "+f.qz+", "+f.qw+") v=("+f.vx+", "+f.vy+", "+f.vz+")");
-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)
+    {
-d9a2083
+    for(int[] tab : table)
-            b2c77ec3
+            Leszek Koltunski
-d9a2083
+      int len = tab.length;
-            b2c77ec3
+            Leszek Koltunski
-d9a2083
+      for(int j=0; j<len; j++)
         if( tab[j]==oldPointer ) tab[j] = newPointer;
-            b2c77ec3
+            Leszek Koltunski
+    }
-a9ae
+///////////////////////////////////////////////////////////////////////////////////////////////////
   private String printSticker(StickerCoords info)
+    {
     String ret = (info.outer?"OUTER":"INNER")+" scale: "+info.scale+"\n";
     int len = info.outerVertices.length;
     for(int l=0; l<len; l++)
+      {
       float[][] outer = info.outerVertices[l];
       int numV = outer.length;
       ret += "  Loop "+l+" verts: "+numV+" { ";
       for(int v=0; v<numV; v++)
+        {
         if(v!=0) ret += ", ";
         ret += (outer[v][0]+"f, "+outer[v][1]+"f");
+        }
       ret += "}\n";
+      }
     return ret;
+    }
-            b2c77ec3
+///////////////////////////////////////////////////////////////////////////////////////////////////
 // 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++;
-a9ae
+      String str = printSticker(info);
       android.util.Log.d("D", "Sticker "+s+" "+str);
-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));
+      }
+    }
-e9a35eb
+///////////////////////////////////////////////////////////////////////////////////////////////////
   private void printVert(double[][] buffer)
+    {
     StringBuilder str = new StringBuilder();
     for(double[] buf : buffer)
+      {
       str.append(" (");
       str.append(buf[0]);
       str.append(" , ");
       str.append(buf[1]);
       str.append(" ) ");
+      }
     android.util.Log.d("D", str.toString());
+    }
-b82486
+///////////////////////////////////////////////////////////////////////////////////////////////////
-            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;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-            ebe8c08e
+  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 )
+      {
-            ebe8c08e
+      float[][][][] coords = new float[num][][][];
-a74f
+            Leszek Koltunski
       for(int i=0; i<len; i++)
+        {
         StickerCoords sticker = mStickerCoords.get(i);
-            ebe8c08e
+        if( sticker.outer ) coords[index++] = sticker.outerVertices;
-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][];
-d9a2083
+    int face=0, variant=-1;
-af68038
+            Leszek Koltunski
     for(int f=0; f<oldfaces; f++)
+      {
       FaceTransform ft = mOldFaceTransf.get(f);
       if( ft.face==0 )
+        {
-d9a2083
+        variant++;
         face=0;
         ret[variant] = new int[ft.numFaces];
-af68038
+            Leszek Koltunski
-d9a2083
+      ret[variant][face++] = ft.sticker;
-af68038
+            Leszek Koltunski
     int newfaces = mNewFaceTransf.size();
     for(int f=0; f<newfaces; f++)
+      {
       FaceTransform ft = mNewFaceTransf.get(f);
       if( ft.face==0 )
+        {
-d9a2083
+        variant++;
         face=0;
         ret[variant] = new int[ft.numFaces];
-af68038
+            Leszek Koltunski
-d9a2083
+      ret[variant][face++] = ft.sticker;
-af68038
+            Leszek Koltunski
     int numStickers = mStickerCoords.size();
     int numOuter=0;
     for(int i=0; i<numStickers; i++)
+      {
       StickerCoords sc = mStickerCoords.get(i);
       if( sc.outer )
+        {
-d9a2083
+        changeStickerPointers(ret,i, numOuter);
-af68038
+        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,
-fda81c4
+                                     final ObjectVertexEffects effects, int numComponents)
-b82486
+            Leszek Koltunski
-            b2c77ec3
+    float[][] bands         = faceShape.getBands();
     int[]   bandIndexes     = faceShape.getBandIndices();
     float[] convexityCenter = faceShape.getConvexityCenter();
-            fe3dec09
+    int numFaces = shape.getNumFaces();
-fda81c4
+    float[] bandsComputed;
-b82486
+    MeshBase[] meshes = new MeshBase[numFaces];
     FaceTransform fInfo;
     StickerCoords sInfo;
-ef6378
+    float[] convexXY = new float[4];
-b82486
+            Leszek Koltunski
     for(int face=0; face<numFaces; face++)
+      {
       fInfo = mNewFaceTransf.get(face);
       computeConvexityCenter(convexXY,convexityCenter,fInfo);
-fda81c4
+      int index      = bandIndexes[face];
       float[] band   = bands[index];
       float height   = band[0];
       int alpha      = (int)band[1];
       float dist     = band[2];
       float K        = band[3];
       int N          = (int)band[4];
       int exIndex    = (int)band[5];
       int exVertices = (int)band[6];
-            c3a033e9
+            Leszek Koltunski
-fb62bf
+      bandsComputed = computeBands(height,alpha,dist,K,N);
-            fe3dec09
+            Leszek Koltunski
-aceea06
+      sInfo = mStickerCoords.get(fInfo.sticker);
-b9d1df5
+      float[][][] vertsF = sInfo.fullVertices;
-aceea06
+            leszek
       // 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;
-b9d1df5
+        float[][][] copiedVerts = new float[lenVerts][][];
-            fe3dec09
+            Leszek Koltunski
         for(int i=0; i<lenVerts; i++)
+          {
-b9d1df5
+          float[][] v = vertsF[i];
-            fe3dec09
+          int len = v.length;
-b9d1df5
+          copiedVerts[i] = new float[len][2];
           for(int j=0; j<len; j++)
+            {
             copiedVerts[i][j][0] = v[j][0];
             copiedVerts[i][j][1] = v[j][1];
+            }
-            fe3dec09
+            Leszek Koltunski
         meshes[face] = new MeshMultigon(copiedVerts,bandsComputed,exIndex,exVertices);
+        }
-aceea06
+      else
+        {
-bf6b98
+        float[][] verts = sInfo.outerVertices[0];
-aceea06
+        int lenVerts = verts.length;
-e9a35eb
+        float[][] copiedVerts = new float[lenVerts][2];
         for(int v=0; v<lenVerts; v++)
+          {
           float[] ve = verts[v];
           copiedVerts[v][0] = ve[0];
           copiedVerts[v][1] = ve[1];
+          }
-aceea06
+        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);
-fda81c4
+    if( effects!=null ) applyVertexEffects(mesh,effects);
-b82486
+            Leszek Koltunski
     return mesh;
+    }
+  }

Project

General

Profile

TwistyPuzzleLib

distorted-objectlib / src / main / java / org / distorted / objectlib / helpers / FactoryCubit.java @ 43668bcc