/ - Diff - TwistyPuzzleLib - Distorted Android

« Previous | Next »

Revision c8f3a765

Added by Leszek Koltunski about 2 years ago

ID c8f3a7659d8714845b9b9b6f0332950947bf3e26
Parent 0d9a2083
Child 94c50a70

fix the 'band' problem in the TwistyBandagedMegaminx.

       private ArrayList<float[]> mTmpArray;
       private ArrayList<float[][]> mVertexArray;
       private BandagedElement[] mElements;
       private Static3D[] mNormals;
       private Static3D[] mPuzzleNormals;
       private float[] mDist3D;
       private int[][] mFaceBelongsBitmap;
       private float[][] mDiaAxis;
-...
       private int[] mNumLayers;
       private float[] mTmp;
       private float[][][] mAllPositions;
       private boolean mCalledFromBandagedObject; // true if this class is being called from the
                                                  // one of the 'BandagedObject*' classes; false if
                                                  // called from one of the 'TwistyBandaged*' classes.
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       abstract float[][] getVertices(int[] numLayers, int variant);
       abstract int[][] getIndices(int[] numLayers, int variant);
       abstract int getNumVariants(int[] numLayers);
       abstract float sizeCorrection(int[] numLayers); // again workaround for the Megaminx
                                                       // '2-3-4-5' vs. '3-3-5-5' problem.
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int[] computeFaceBelongsBitmap(float[][] vertices, float[] move)
       private int[] computeFaceBelongsBitmap(float[][] vertices, float[] move, float corr)
+        {
         int numVerts = vertices.length;
         int[] ret = new int[numVerts];
         for(int i=0; i<numVerts; i++)
         for(int v=0; v<numVerts; v++)
+          {
           int vertBelongsBitmap=0x00000000;
           float[] vert=vertices[i];
           float[] vert=vertices[v];
           for(int j=0; j<mNumFaces; j++)
             if( vertInFace(vert, move, mNormals[j], mDist3D[j]) ) vertBelongsBitmap |= (1<<j);
           for(int f=0; f<mNumFaces; f++)
             if( vertInFace(vert, move, mPuzzleNormals[f], mDist3D[f], corr) )
+              {
               vertBelongsBitmap |= (1<<f);
+              }
           ret[i]=vertBelongsBitmap;
           ret[v]=vertBelongsBitmap;
+          }
         return ret;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static boolean vertInFace(float[] vertex, float[] move, Static3D faceAxis, float dist)
       static boolean vertInFace(float[] vertex, float[] move, Static3D faceAxis, float dist, float corr)
+        {
         final float MAX_ERROR = 0.01f;
-...
         float y= faceAxis.get1();
         float z= faceAxis.get2();
         float a = (vertex[0]+move[0])*x + (vertex[1]+move[1])*y + (vertex[2]+move[2])*z;
         float vx = vertex[0]*corr;
         float vy = vertex[1]*corr;
         float vz = vertex[2]*corr;
         float a = (vx+move[0])*x + (vy+move[1])*y + (vz+move[2])*z;
         float diff = a - dist;
         return diff>-MAX_ERROR && diff<MAX_ERROR;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void computeVectorFace(float[] prev, float[] curr, float[] next, float[] output)
       private float[] computeVector(int index, float[][] vertices, int[][][] indices, int[] bandIndices, float[][] normals)
+        {
         float ax = prev[0]-curr[0];
         float ay = prev[1]-curr[1];
         float az = prev[2]-curr[2];
         int numFaces = indices.length;
         int numBordering=0, numExternal=0;
         float x=0, y=0, z=0;
         float bx = next[0]-curr[0];
         float by = next[1]-curr[1];
         float bz = next[2]-curr[2];
         for(int f=0; f<numFaces; f++)
+          {
           int numComponentsInFace = indices[f].length;
         float lena = (float)Math.sqrt(ax*ax + ay*ay + az*az);
         float lenb = (float)Math.sqrt(bx*bx + by*by + bz*bz);
           for(int c=0; c<numComponentsInFace; c++)
+            {
             int[] ind = indices[f][c];
             int numVertsInComponent = ind.length;
         ax /= lena;
         ay /= lena;
         az /= lena;
             for(int v=0; v<numVertsInComponent; v++)
+              {
               if( ind[v]==index )
+                {
                 float[] nor = normals[f];
         bx /= lenb;
         by /= lenb;
         bz /= lenb;
                 x += nor[0];
                 y += nor[1];
                 z += nor[2];
         output[0] = ay*bz - az*by;
         output[1] = az*bx - ax*bz;
         output[2] = ax*by - ay*bx;
                 numBordering++;
                 if( bandIndices[f]>0 ) numExternal++;
         output[3] = ax;
         output[4] = ay;
         output[5] = az;
                 v = numVertsInComponent;
                 c = numComponentsInFace;
+                }
+              }
+            }
+          }
         output[6] = bx;
         output[7] = by;
         output[8] = bz;
         return ( numExternal<2 || numBordering<3 ) ? null : new float[] { x/numBordering, y/numBordering, z/numBordering};
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // 'concave' vertices do not get pushed!
       private boolean vertexIsConcave(float[][] vecs, int numVecs)
       private void createCubitFaceNormal(float[] output, float[] v0, float[] v1, float[] v2)
+        {
         for(int i=0; i<numVecs; i++)
+          {
           float[] v1 = vecs[i];
         float ax = v0[0]-v1[0];
         float ay = v0[1]-v1[1];
         float az = v0[2]-v1[2];
           for(int j=0; j<numVecs; j++)
+            {
             if( i==j ) continue;
         float bx = v2[0]-v1[0];
         float by = v2[1]-v1[1];
         float bz = v2[2]-v1[2];
             float[] v2 = vecs[j];
         output[0] = ay*bz - az*by;
         output[1] = az*bx - ax*bz;
         output[2] = ax*by - ay*bx;
             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];
         float len = (float)Math.sqrt(output[0]*output[0] + output[1]*output[1] + output[2]*output[2]);
             if( scalar1<0 || scalar2<0 ) return true;
+            }
         if( len!=0 )
+          {
           output[0] /= len;
           output[1] /= len;
           output[2] /= len;
+          }
         else
+          {
           android.util.Log.e("D", "ERROR in createCubitFaceNormal!");
+          }
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float[] computeVector(int index, float[][] vertices, int[][][] indices, int[] bandIndices)
       private float[][] generateCubitFaceNormals(float[][] vertices, int[][][] indices)
+        {
         int band=0;
         int numFaces = indices.length;
         int numBordering = 0;
         float x=0, y=0, z=0;
         float[][] vecs = new float[numFaces][9];
         int vecIndex = 0;
         float[][] ret = new float[numFaces][3];
         for(int f=0; f<numFaces; f++)
+          {
           int numComponentsInFace = indices[f].length;
           int[] verts = indices[f][0];
           int numVerts = verts.length;
           for(int c=0; c<numComponentsInFace; c++)
           for(int v=0; v<numVerts; v++)
+            {
             int[] ind = indices[f][c];
             int numVertsInComponent = ind.length;
             int i0 = verts[0];
             int i1 = verts[1];
             int i2 = verts[2];
             for(int v=0; v<numVertsInComponent; v++)
+              {
               if(ind[v]==index)
+                {
                 int prev=v>0 ? v-1 : numVertsInComponent-1;
                 int next=v<numVertsInComponent-1 ? v+1 : 0;
                 int prevIndex=ind[prev];
                 int currIndex=ind[v];
                 int nextIndex=ind[next];
                 float[] vec = vecs[vecIndex++];
                 computeVectorFace(vertices[prevIndex], vertices[currIndex], vertices[nextIndex], vec);
                 band|=bandIndices[f];
                 v = numVertsInComponent;
                 c = numComponentsInFace;
                 numBordering++;
             float[] v0 = vertices[i0];
             float[] v1 = vertices[i1];
             float[] v2 = vertices[i2];
                 x += vec[0];
                 y += vec[1];
                 z += vec[2];
+                }
+              }
             createCubitFaceNormal(ret[f], v0,v1,v2);
+            }
+          }
         boolean concave = vertexIsConcave(vecs,vecIndex);
         return ( concave || band==0 || numBordering<3 ) ? null : new float[] { x/numBordering, y/numBordering, z/numBordering};
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        {
         int len = vertices.length;
         float[][] vectors = new float[len][];
         float[][] normals = generateCubitFaceNormals(vertices,indices);
         for(int i=0; i<len; i++)
+          {
           vectors[i] = computeVector(i,vertices,indices,bandIndices);
           vectors[i] = computeVector(i,vertices,indices,bandIndices,normals);
+          }
         return vectors;
-...
       public void prepare(int numVariants, int[] numLayers)
+        {
         if( mVertexArray==null ) mVertexArray = new ArrayList<>();
         mCalledFromBandagedObject = false;
         mVertices= new float[numVariants][][];
         mIndices = new int[numVariants][][][];
         mMove = new float[numVariants][3];
-...
         mNumLayers = new int[num];
         for(int l=0; l<num; l++) mNumLayers[l] = numLayers[l];
         mNormals   = getNormals();
         mNumFaces  = mNormals.length;
         mDist3D    = getDist3D(mNumLayers);
         mDiaAxis   = getDiameterAxis();
         mMinMax    = new float[mDiaAxis.length][2];
         mPuzzleNormals= getNormals();
         mNumFaces     = mPuzzleNormals.length;
         mDist3D       = getDist3D(mNumLayers);
         mDiaAxis      = getDiameterAxis();
         mMinMax       = new float[mDiaAxis.length][2];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public ObjectFaceShape createIrregularFaceShape(int variant, boolean iconMode)
+        {
         float[][] bands = getBands(iconMode, mNumLayers);
         float corr = mCalledFromBandagedObject ? 1.0f : sizeCorrection(mNumLayers);
         if( mBandIndices[variant]==null )
+          {
           mFaceBelongsBitmap[variant] = computeFaceBelongsBitmap(mVertices[variant], mMove[variant]);
           mFaceBelongsBitmap[variant] = computeFaceBelongsBitmap(mVertices[variant], mMove[variant],corr);
           mBandIndices[variant] = generateBandIndices(mVertices[variant], mIndices[variant], mFaceBelongsBitmap[variant]);
+          }
-...
       public MeshBase createMesh(float[] pos, int[] numLayers, boolean iconMode, boolean roundCorners)
+        {
         prepare(1,numLayers);
         mCalledFromBandagedObject = true;
         ObjectShape shape           = createIrregularShape(0,pos);
         ObjectFaceShape face        = createIrregularFaceShape(0,iconMode);
         ObjectVertexEffects effects = createVertexEffects(0,roundCorners);

          return new float[][] { {1,0,0},{0,1,0},{0,0,1} };
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float sizeCorrection(int[] numLayers)
+        {
         return 1.0f;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int diameterMap(float diameter)

                 };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float sizeCorrection(int[] numLayers)
+        {
         switch(numLayers[0])
+          {
           case 2: return 2.0f/3;
           case 3: return 3.0f/3;
           case 4: return 4.0f/5;
           case 5: return 5.0f/5;
+          }
         return 1.0f;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int diameterMap(float diameter)
-...
       public float[][] getBands(boolean iconMode, int[] numLayers)
+        {
         float height= iconMode ? 0.001f : 0.05f;
         int[] angle = {72,55,50,46,42,39,36,34,31,29,27};
         int[] angle = {1,55,50,46,42,39,36,34,31,29,27};
         float R     = 0.5f;
         float S     = 0.5f;
         int extraI  = 0;
-...
         int numVertA= numLayers[0]>=4 ? 4 : 5;
         int numVertI= numLayers[0]>=4 ? 2 : 3;
         return new float[][] { {  0.001f    ,angle[ 0],R,S,numVertI,extraV,extraI},
         return new float[][] { {0.001f      ,angle[ 0],R,S,numVertI,extraV,extraI},
                                {height      ,angle[ 1],R,S,numVertA,extraV,extraI},
                                {height      ,angle[ 1],R,S,numVertA,extraV,extraI},
                                {height/ 1.5f,angle[ 2],R,S,numVertA,extraV,extraI},

                 };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float sizeCorrection(int[] numLayers)
+        {
         return 1.0f;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int diameterMap(float diameter)

Also available in: Unified diff

Project

General

Profile

TwistyPuzzleLib

Revision c8f3a765

Added by Leszek Koltunski about 2 years ago