/ - Diff - TwistyPuzzleLib - Distorted Android

     abstract public class FactoryBandaged
+      {
       private ArrayList<float[]> mTmpArray;
       private float mNX, mNY, mNZ;
       private float[] mDist3D;
       private int[][] mFaceBelongsBitmap;
       private float[][] mCuts;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void computeVectorFace(float[] prev, float[] curr, float[] next)
       private void computeVectorFace(float[] prev, float[] curr, float[] next, float[] output)
+        {
         float ax = prev[0]-curr[0];
         float ay = prev[1]-curr[1];
-...
         by /= lenb;
         bz /= lenb;
         mNX = ax + bx + ay*bz-az*by;
         mNY = ay + by + az*bx-ax*bz;
         mNZ = az + bz + ax*by-ay*bx;
         output[0] = ay*bz - az*by;
         output[1] = az*bx - ax*bz;
         output[2] = ax*by - ay*bx;
         output[3] = ax;
         output[4] = ay;
         output[5] = az;
         output[6] = bx;
         output[7] = by;
         output[8] = bz;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // 'concave' vertices do not get pushed!
       private boolean vertexIsConcave(float[][] vecs, int numVecs)
+        {
         for(int i=0; i<numVecs; i++)
+          {
           float[] v1 = vecs[i];
           for(int j=0; j<numVecs; j++)
+            {
             if( i==j ) continue;
             float[] v2 = vecs[j];
             float scalar1 = v1[0]*v2[3] + v1[1]*v2[4] + v1[2]*v2[5];
             float scalar2 = v1[0]*v2[6] + v1[1]*v2[7] + v1[2]*v2[8];
             if( scalar1<0 || scalar2<0 ) return true;
+            }
+          }
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         int numBordering = 0;
         float x=0, y=0, z=0;
         float[][] vecs = new float[numFaces][9];
         int vecIndex = 0;
         for(int f=0; f<numFaces; f++)
+          {
           int numComponentsInFace = indices[f].length;
-...
                 int currIndex=ind[v];
                 int nextIndex=ind[next];
                 computeVectorFace(vertices[prevIndex], vertices[currIndex], vertices[nextIndex]);
                 float[] vec = vecs[vecIndex++];
                 computeVectorFace(vertices[prevIndex], vertices[currIndex], vertices[nextIndex], vec);
                 band|=bandIndices[f];
                 v = numVertsInComponent;
                 c = numComponentsInFace;
                 numBordering++;
                 x += mNX;
                 y += mNY;
                 z += mNZ;
                 x += vec[0];
                 y += vec[1];
                 z += vec[2];
+                }
+              }
+            }
+          }
         return ( band==0 || numBordering<3 ) ? null : new float[] { x/numBordering, y/numBordering, z/numBordering};
         boolean concave = vertexIsConcave(vecs,vecIndex);
         return ( concave || band==0 || numBordering<3 ) ? null : new float[] { x/numBordering, y/numBordering, z/numBordering};
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static FactoryBandagedCuboid getInstance()
+         {
          if( mThis==null ) mThis = new FactoryBandagedCuboid();
          return mThis;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float[] elementVertices(int ax, boolean left, int element)
-...
         return diffX>diffY ? Math.max(diffX,diffZ) : Math.max(diffY,diffZ);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
       public static FactoryBandagedCuboid getInstance()
+        {
         if( mThis==null ) mThis = new FactoryBandagedCuboid();
         return mThis;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float[][] getCuts(int[] numLayers)

     import static org.distorted.objectlib.main.TwistyObject.SQ6;
     import org.distorted.library.type.Static3D;
     import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static FactoryBandagedPyraminx getInstance()
+        {
         if( mThis==null ) mThis = new FactoryBandagedPyraminx();
         return mThis;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TODO
-...
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
       public static FactoryBandagedPyraminx getInstance()
+        {
         if( mThis==null ) mThis = new FactoryBandagedPyraminx();
         return mThis;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float[][] getCuts(int[] numLayers)
-...
       public Static3D[] getNormals()
+        {
         return TouchControlTetrahedron.FACE_AXIS;
         return new Static3D[]
+                {
                         new Static3D(     0, SQ3/3, SQ6/3),
                         new Static3D(     0, SQ3/3,-SQ6/3),
                         new Static3D(-SQ6/3,-SQ3/3,     0),
                         new Static3D( SQ6/3,-SQ3/3,     0),
                 };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public float[] getDist3D()
+        {
         return TouchControlTetrahedron.D3D;
         final float d = (SQ6/12)*mNumLayers[0];
         return new float[] {d,d,d,d};
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        {
         float height= iconMode ? 0.001f : 0.048f;
         int[] angle = {60,50,40,32,28,23};
         float R     = 0.2f;
         float R     = 0.3f;
         float S     = 0.5f;
         int extraI  = 0;
         int extraV  = 0;

Project

General

Profile

TwistyPuzzleLib

Revision 17a55777

Added by Leszek Koltunski about 2 years ago