/ - Diff - TwistyPuzzleLib - Distorted Android

« Previous | Next »

Revision b76da174

Added by Leszek Koltunski 11 months ago

ID b76da174d29caa48fc41e6c016c2ed1a34086449
Parent efa5bc1e
Child 262d3b6a

First try converting FactoryBandagedCuboid to MeshMultigon (still doesn't work)

           };
       private static FactoryBandagedCuboid mThis;
       private ArrayList<float[]> mVertexArray;
       private BandagedElementCuboid[] mElements;
       private ArrayList<float[][]> mVertexArray;
       private ArrayList<float[]> mTmpArray;
       private float[][][] mVertices;
       private int[][][] mIndices;
       private int[][][][] mIndices;
       private int[][] mBandIndices;
       private float[][] mMove;
       private int mX, mY, mZ, mMax;
       private float dX, dY, dZ;
       private int[][] mWall;
       private int[][] mPoints;
       private float[][] mCuts;
       private float[][] mNormal;
       private BandagedElementCuboid[] mElements;
       private int mNumElements;
       private int[][] mFaceBelongsBitmap;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float[][] getVertices(ArrayList<float[]> list, float[] move, int variant)
       private void computeMove(float[] pos, int variant)
+        {
         int numMoves = move.length/3;
         mMove[variant][0]=0.0f;
         mMove[variant][1]=0.0f;
         mMove[variant][2]=0.0f;
         int numMoves = pos.length/3;
         float[] m = mMove[variant];
         m[0]=0.0f;
         m[1]=0.0f;
         m[2]=0.0f;
         for(int m=0; m<numMoves; m++)
         for(int i=0; i<numMoves; i++)
+          {
           mMove[variant][0] += move[3*m  ];
           mMove[variant][1] += move[3*m+1];
           mMove[variant][2] += move[3*m+2];
           m[0] += pos[3*i  ];
           m[1] += pos[3*i+1];
           m[2] += pos[3*i+2];
+          }
         mMove[variant][0]/=numMoves;
         mMove[variant][1]/=numMoves;
         mMove[variant][2]/=numMoves;
         m[0]/=numMoves;
         m[1]/=numMoves;
         m[2]/=numMoves;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float[][] getVertices(ArrayList<float[][]> list, int variant)
+        {
         int total  = 0;
         int length = list.size();
         float[][] vertices = new float[length][];
         float[][][] vertices = new float[length][][];
         for( int i=0; i<length; i++ )
+          {
           vertices[i] = list.get(i);
           total += vertices[i].length/3;
           int len = vertices[i].length;
           for(int j=0; j<len; j++) total += vertices[i][j].length/3;
+          }
         float[][] verts = new float[total][3];
-...
         for(int i=0; i<length; i++)
+          {
           int len = vertices[i].length/3;
           int len = vertices[i].length;
           for(int j=0; j<len; j++)
+            {
             verts[pointer][0] = vertices[i][3*j  ] - mMove[variant][0];
             verts[pointer][1] = vertices[i][3*j+1] - mMove[variant][1];
             verts[pointer][2] = vertices[i][3*j+2] - mMove[variant][2];
             pointer++;
             float[] v = vertices[i][j];
             int l = v.length/3;
             for(int k=0; k<l; k++)
+              {
               verts[pointer][0] = v[3*k  ] - mMove[variant][0];
               verts[pointer][1] = v[3*k+1] - mMove[variant][1];
               verts[pointer][2] = v[3*k+2] - mMove[variant][2];
               pointer++;
+              }
+            }
+          }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int[][] getIndices(ArrayList<float[]> list)
       private int[][][] getIndices(ArrayList<float[][]> list)
+        {
         int indicesSoFar=0;
         int length = list.size();
         int[][] indices = new int[length][];
         int[][][] indices = new int[length][][];
         for( int i=0; i<length; i++ )
+          {
           float[] f = list.get(i);
           int len = f.length/3;
           int[] ind = new int[len];
           for(int j=0; j<len; j++) ind[j] = (indicesSoFar++);
           float[][] face = list.get(i);
           int len = face.length;
           int[][] ind = new int[len][];
           for(int j=0; j<len; j++)
+            {
             int l = face[j].length/3;
             ind[j] = new int[l];
             for(int k=0; k<l; k++) ind[j][k] = (indicesSoFar++);
+            }
           indices[i] = ind;
+          }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void markAllVertices(float[] vertex, float[][] vertices, int[][] indices, int pointer, int variant)
       private void markAllVertices(float[] vertex, float[][] vertices, int[][][] indices, int pointer, int variant)
+        {
         int lenI = indices.length;
         int numFaces = indices.length;
         for(int index=0; index<lenI; index++)
         for(int face=0; face<numFaces; face++)
+          {
           int len = indices[index].length;
           int len = indices[face].length;
           for(int i=0; i<len; i++)
           for(int comp=0; comp<len; comp++)
+            {
             if( mIndices[variant][index][i] == -1 )
+              {
               int ind = indices[index][i];
               float[] ver = vertices[ind];
             int l = indices[face][comp].length;
               if( vertex[0]==ver[0] && vertex[1]==ver[1] && vertex[2]==ver[2] )
             for(int v=0; v<l; v++)
+              {
               if( mIndices[variant][face][comp][v]==-1 )
+                {
                 mIndices[variant][index][i] = pointer;
                 int ind=indices[face][comp][v];
                 float[] ver=vertices[ind];
                 if(vertex[0]==ver[0] && vertex[1]==ver[1] && vertex[2]==ver[2])
+                  {
                   mIndices[variant][face][comp][v]=pointer;
+                  }
+                }
+              }
+            }
-...
     //   1.0f, -1.0f, +0.0f,
     //   0.0f, -1.0f, -1.0f },
       private void compressVerticesAndIndices(int variant, float[][] vertices, int[][] indices)
       private void compressVerticesAndIndices(int variant, float[][] vertices, int[][][] indices)
+        {
         if( mTmpArray==null ) mTmpArray = new ArrayList<>();
         int lenI = indices.length;
         int numFaces = indices.length;
         int pointer=0;
         mIndices[variant] = new int[lenI][];
         mIndices[variant] = new int[numFaces][][];
         for(int index=0; index<lenI; index++)
         for(int face=0; face<numFaces;face++)
+          {
           int len = indices[index].length;
           mIndices[variant][index] = new int[len];
           for(int i=0; i<len; i++) mIndices[variant][index][i] = -1;
           int len = indices[face].length;
           mIndices[variant][face] = new int[len][];
           for(int comp=0; comp<len; comp++)
+            {
             int l = indices[face][comp].length;
             for(int v=0; v<l; v++)
+              {
               mIndices[variant][face][comp] = new int[l];
               mIndices[variant][face][comp][v] = -1;
+              }
+            }
+          }
         for(int index=0; index<lenI; index++)
         for(int face=0; face<numFaces; face++)
+          {
           int len = indices[index].length;
           int len = indices[face].length;
           for(int i=0; i<len; i++)
           for(int comp=0; comp<len; comp++)
+            {
             if( mIndices[variant][index][i] == -1 )
             int l = indices[face][comp].length;
             for(int v=0; v<l; v++)
+              {
               int ind = indices[index][i];
               float[] ver = vertices[ind];
               mTmpArray.add(ver);
               markAllVertices(ver,vertices,indices,pointer,variant);
               pointer++;
               if( mIndices[variant][face][comp][v]==-1 )
+                {
                 int ind=indices[face][comp][v];
                 float[] ver=vertices[ind];
                 mTmpArray.add(ver);
                 markAllVertices(ver, vertices, indices, pointer, variant);
                 pointer++;
+                }
+              }
+            }
+          }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void displayWall(String tmp)
+        {
         StringBuilder sb = new StringBuilder();
         for(int i=0; i<mMax; i++)
+          {
           for(int j=0; j<mMax; j++)
+            {
             sb.append(mWall[i][j]);
             sb.append(' ');
+            }
           sb.append("  -  ");
+          }
         android.util.Log.e("D", tmp+" : "+sb);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void createRight(int x, ArrayList<float[]> list)
       private void createRight(int x, ArrayList<float[][]> list)
+        {
         for(int i=0; i<mMax; i++)
           for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void createLeft(int x, ArrayList<float[]> list)
       private void createLeft(int x, ArrayList<float[][]> list)
+        {
         for(int i=0; i<mMax; i++)
           for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void createTop(int y, ArrayList<float[]> list)
       private void createTop(int y, ArrayList<float[][]> list)
+        {
         for(int i=0; i<mMax; i++)
           for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void createBottom(int y, ArrayList<float[]> list)
       private void createBottom(int y, ArrayList<float[][]> list)
+        {
         for(int i=0; i<mMax; i++)
           for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void createFront(int z, ArrayList<float[]> list)
       private void createFront(int z, ArrayList<float[][]> list)
+        {
         for(int i=0; i<mMax; i++)
           for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void createBack(int z, ArrayList<float[]> list)
       private void createBack(int z, ArrayList<float[][]> list)
+        {
         for(int i=0; i<mMax; i++)
           for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;
-...
         return sections;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // return true iff exactly three or exactly one of the four values (x1,x2,x3,x4) are equal to 'value'.
       private boolean threeOrOne(int x1, int x2, int x3, int x4, int value)
+        {
         if( x1==value ) return x2==value ? (x3==value)^(x4==value) : (x3==value)^(x4!=value);
         else            return x2==value ? (x3==value)^(x4!=value) : (x3==value)^(x4==value);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private boolean isOddVertical(int x, int y)
+        {
         int number = 0;
         for(int i=0; i<y; i++)
           if( mPoints[x][i]==0 ) number++;
         return (number%2)==0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private boolean isOddHorizontal(int x, int y)
+        {
         int number = 0;
         for(int i=0; i<x; i++)
           if( mPoints[i][y]==0 ) number++;
         return (number%2)==0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int moveUp(int x, int y)
+        {
         for(int i=y-1; i>=0; i--)
           if( mPoints[x][i]==0 ) return i;
         android.util.Log.e("D", "moveUp error!");
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int moveDown(int x, int y)
+        {
         for(int i=y+1; i<=mMax; i++)
           if( mPoints[x][i]==0 ) return i;
         android.util.Log.e("D", "moveDown error!");
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int moveLeft(int x, int y)
+        {
         for(int i=x-1; i>=0; i--)
           if( mPoints[i][y]==0 ) return i;
         android.util.Log.e("D", "moveLeft error!");
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int moveRight(int x, int y)
+        {
         for(int i=x+1; i<=mMax; i++)
           if( mPoints[i][y]==0 ) return i;
         android.util.Log.e("D", "moveRight error!");
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float[] buildVertices(int[][] wall, int section, float dx, float dy)
       private float[][] buildVertices(int[][] wall, int section, float dx, float dy)
+        {
         int numPoints = buildPoints(wall,section);
         int numSections = numPoints/2;
         float[] vertices = new float[3*numPoints];
         int x=0,y=0,pointer=0;
         int numMarked = howManyMarked(wall,section);
         float[][] vertices = new float[numMarked][];
         int curr=0;
         for(int i=0; i<=mMax; i++)
           for(int j=0; j<=mMax; j++)
             if( mPoints[i][j]==0 )
         for(int x=0; x<mMax; x++)
           for(int y=0; y<mMax; y++)
             if( wall[x][y]==section )
+              {
               x = i;
               y = j;
               i = j = mMax+1;
+              }
               vertices[curr] = new float[12];
         for(int s=0; s<numSections; s++)
+          {
           vertices[6*pointer  ] = x-dx;
           vertices[6*pointer+1] = dy-y;
           vertices[6*pointer+2] = 0.0f;
               vertices[curr][ 0] = x-dx;
               vertices[curr][ 1] = dy-y;
               vertices[curr][ 2] = 0.0f;
           y = isOddVertical(x,y) ? moveDown(x,y) : moveUp(x,y);
               vertices[curr][ 3] = x-dx;
               vertices[curr][ 4] = dy-y-1;
               vertices[curr][ 5] = 0.0f;
           vertices[6*pointer+3] = x-dx;
           vertices[6*pointer+4] = dy-y;
           vertices[6*pointer+5] = 0.0f;
               vertices[curr][ 6] = x-dx+1;
               vertices[curr][ 7] = dy-y-1;
               vertices[curr][ 8] = 0.0f;
           x = isOddHorizontal(x,y) ? moveRight(x,y) : moveLeft(x,y);
               vertices[curr][ 9] = x-dx+1;
               vertices[curr][10] = dy-y;
               vertices[curr][11] = 0.0f;
           pointer++;
+          }
               curr++;
+              }
         return vertices;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int buildPoints(int[][] wall, int section)
       private int howManyMarked(int[][] wall, int section)
+        {
         int numPoints=0;
         boolean thereIsCorner;
         int numMarked=0;
         for(int x=0; x<=mMax; x++)
           for(int y=0; y<=mMax; y++)
+            {
             if( y==0 )
+              {
                    if( x==   0 ) thereIsCorner = (wall[     0][0]==section);
               else if( x==mMax ) thereIsCorner = (wall[mMax-1][0]==section);
               else               thereIsCorner = (wall[x-1][0]==section)^(wall[x][0]==section);
+              }
             else if( y==mMax )
+              {
                    if( x==   0 ) thereIsCorner = (wall[     0][mMax-1]==section);
               else if( x==mMax ) thereIsCorner = (wall[mMax-1][mMax-1]==section);
               else               thereIsCorner = (wall[x-1][mMax-1]==section)^(wall[x][mMax-1]==section);
+              }
             else if( x==0 )
+              {
               thereIsCorner = (wall[0][y-1]==section)^(wall[0][y]==section);
+              }
             else if( x==mMax )
+              {
               thereIsCorner = (wall[mMax-1][y-1]==section)^(wall[mMax-1][y]==section);
+              }
             else
+              {
               thereIsCorner = threeOrOne(wall[x-1][y-1],wall[x-1][y],wall[x][y-1],wall[x][y],section);
+              }
             if( thereIsCorner )
+              {
               mPoints[x][y] = 0;
               numPoints++;
+              }
             else
+              {
               mPoints[x][y] =-1;
+              }
+            }
         for(int x=0; x<mMax; x++)
           for(int y=0; y<mMax; y++)
             if( wall[x][y]==section ) numMarked++;
         return numPoints;
         return numMarked;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void rotateAndMoveVertices(float[] vertices, int axis, int layer)
       private void rotateAndMoveVertices(float[][] vertices, int axis, int layer)
+        {
         int i,len = vertices.length/3;
         int i,len = vertices.length;
         switch(axis)
+          {
           case AXIS_XP: for(i=0; i<len; i++)
+                          {
                           vertices[3*i+2] =-vertices[3*i  ];
                           vertices[3*i  ] = layer-(dX-1.0f);
                           int l = vertices[i].length/3;
                           for(int j=0; j<l; j++)
+                            {
                             vertices[i][3*j+2] = -vertices[i][3*j];
                             vertices[i][3*j]   = layer-(dX-1.0f);
+                            }
+                          }
                         break;
           case AXIS_XM: for(i=0; i<len; i++)
+                          {
                           vertices[3*i+2] = vertices[3*i  ];
                           vertices[3*i  ] = layer-dX;
                           int l = vertices[i].length/3;
                           for(int j=0; j<l; j++)
+                            {
                             vertices[i][3*j+2] = vertices[i][3*j];
                             vertices[i][3*j]   = layer-dX;
+                            }
+                          }
                         break;
           case AXIS_YP: for(i=0; i<len; i++)
+                          {
                           vertices[3*i+2] =-vertices[3*i+1];
                           vertices[3*i+1] = layer-(dY-1.0f);
                           int l = vertices[i].length/3;
                           for(int j=0; j<l; j++)
+                            {
                             vertices[i][3*j+2] = -vertices[i][3*j+1];
                             vertices[i][3*j+1] = layer-(dY-1.0f);
+                            }
+                          }
                         break;
           case AXIS_YM: for(i=0; i<len; i++)
+                          {
                           vertices[3*i+2] = vertices[3*i+1];
                           vertices[3*i+1] = layer-dY;
                           int l = vertices[i].length/3;
                           for(int j=0; j<l; j++)
+                            {
                             vertices[i][3*j+2] = vertices[i][3*j+1];
                             vertices[i][3*j+1] = layer-dY;
+                            }
+                          }
                         break;
           case AXIS_ZP: for(i=0; i<len; i++)
+                          {
                           vertices[3*i+2] = layer-(dZ-1.0f);
                           int l = vertices[i].length/3;
                           for(int j=0; j<l; j++)
+                            {
                             vertices[i][3*j+2] = layer-(dZ-1.0f);
+                            }
+                          }
                         break;
           case AXIS_ZM: for(i=0; i<len; i++)
+                          {
                           vertices[3*i+2] = layer-dZ;
                           vertices[3*i  ] =-vertices[3*i  ];
                           int l = vertices[i].length/3;
                           for(int j=0; j<l; j++)
+                            {
                             vertices[i][3*j+2] = layer-dZ;
                             vertices[i][3*j]   = -vertices[i][3*j];
+                            }
+                          }
                         break;
+          }
-...
     //   c. take layer into consideration and move the vertices.
     //   d. add the resulting vertices to the list.
       private void createVertices(ArrayList<float[]> list, int[][] wall, int axis, int layer)
       private void createVertices(ArrayList<float[][]> list, int[][] wall, int axis, int layer)
+        {
         int sections = markSections(wall);
-...
         for(int i=0; i<sections; i++)
+          {
           float[] vertices = buildVertices(wall,i+1,dx,dy);
           float[][] vertices = buildVertices(wall,i+1,dx,dy);
     /*
     if(axis==AXIS_XP || axis==AXIS_XM)
+      {
       StringBuilder s = new StringBuilder();
       int n = vertices.length;
       s.append("createVertices: numComp: ");
       s.append(n);
       for(float[] floats : vertices)
+        {
         int l=floats.length/3;
         for(int k=0; k<l; k++)
+          {
           s.append(" (");
           s.append(floats[3*k  ]);
           s.append(" ");
           s.append(floats[3*k+1]);
           s.append(" ");
           s.append(floats[3*k+2]);
           s.append(") ");
+          }
         s.append("\n");
+        }
       android.util.Log.e("D", "1 --> "+s);
+      }
     */
           rotateAndMoveVertices(vertices,axis,layer);
           list.add(vertices);
     /*
           int len = vertices.length/3;
           String w="";
           for(int j=0; j<len; j++)
           if(axis==AXIS_XP || axis==AXIS_XM)
+            {
             w += ( "["+vertices[3*j]+" "+vertices[3*j+1]+" "+vertices[3*j+2]+"] ");
             StringBuilder s = new StringBuilder();
             int n = vertices.length;
             s.append("createVertices: numComp: ");
             s.append(n);
             for(float[] floats : vertices)
+              {
               int l=floats.length/3;
               for(int k=0; k<l; k++)
+                {
                 s.append(" (");
                 s.append(floats[3*k  ]);
                 s.append(" ");
                 s.append(floats[3*k+1]);
                 s.append(" ");
                 s.append(floats[3*k+2]);
                 s.append(") ");
+                }
               s.append("\n");
+              }
             android.util.Log.e("D", "2 --> "+s);
+            }
           android.util.Log.e("D", "1 section: "+i+" axis: "+axis+" layer: "+layer+" vertices after: "+w);
     */
           list.add(vertices);
+          }
+        }
-...
     // (vertices,indices) define a cubit face, i.e. a connected subset of the NxN grid.
     // Return its 'diameter', i.e. max(width,height)
       private int faceDiameter(float[][] vertices, int[] indices)
       private int faceDiameter(float[][] vertices, int[][] indices)
+        {
         float maxX = -dX;
         float minX =  dX;
-...
         float maxZ = -dZ;
         float minZ =  dZ;
         for (int index : indices)
+          {
           float[] v = vertices[index];
           if (v[0] > maxX) maxX = v[0];
           if (v[0] < minX) minX = v[0];
           if (v[1] > maxY) maxY = v[1];
           if (v[1] < minY) minY = v[1];
           if (v[2] > maxZ) maxZ = v[2];
           if (v[2] < minZ) minZ = v[2];
+          }
         for (int[] ind : indices)
           for(int index : ind)
+            {
             float[] v = vertices[index];
             if (v[0] > maxX) maxX = v[0];
             if (v[0] < minX) minX = v[0];
             if (v[1] > maxY) maxY = v[1];
             if (v[1] < minY) minY = v[1];
             if (v[2] > maxZ) maxZ = v[2];
             if (v[2] < minZ) minZ = v[2];
+            }
         float diffX = maxX-minX;
         float diffY = maxY-minY;
-...
         return (int)max;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int[] computeFaceBelongsBitmap(float[][] vertices, int[][][] indices, float[] move)
+        {
         int numVerts = vertices.length;
         int[] ret = new int[numVerts];
         for(int[][] ints : indices)
           for(int[] ind : ints)
             for(int index : ind)
+              {
               int vertBelongsBitmap=0x00000000;
               float[] vert=vertices[index];
               if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[0], dX) ) vertBelongsBitmap |= (1   );
               if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[1], dX) ) vertBelongsBitmap |= (1<<1);
               if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[2], dY) ) vertBelongsBitmap |= (1<<2);
               if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[3], dY) ) vertBelongsBitmap |= (1<<3);
               if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[4], dZ) ) vertBelongsBitmap |= (1<<4);
               if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[5], dZ) ) vertBelongsBitmap |= (1<<5);
               ret[index]=vertBelongsBitmap;
+              }
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // return array of:
     // 0 if this is an inner face, 1 if its diameter is 1, 2 if diameter is 2, 3 if 3, etc
     // but only up to 5 (because the number of bands is 6 - see createIrregularFaceShape() )
       private int[] generateBandIndices(float[][] vertices, int[][] indices, float[] move)
       private int[] generateBandIndices(float[][] vertices, int[][][] indices, int[] belongs)
+        {
         int numCubitFaces = indices.length;
         int[] bandIndices = new int[numCubitFaces];
         for(int cubitFace=0; cubitFace<numCubitFaces; cubitFace++)
         for(int f=0; f<numCubitFaces; f++)
+          {
           bandIndices[cubitFace] = 0xffffffff;
           int numVertices = indices[cubitFace].length;
           bandIndices[f] = 0xffffffff;
           for( int index : indices[f][0] ) bandIndices[f] &= belongs[index];
           for(int vertex=0; vertex<numVertices; vertex++)
           if( bandIndices[f]!=0 ) // outer face
+            {
             int vertBelongsBitmap = 0x00000000;
             float[] vert = vertices[ indices[cubitFace][vertex] ];
             if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[0], dX) ) vertBelongsBitmap |= (1   );
             if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[1], dX) ) vertBelongsBitmap |= (1<<1);
             if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[2], dY) ) vertBelongsBitmap |= (1<<2);
             if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[3], dY) ) vertBelongsBitmap |= (1<<3);
             if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[4], dZ) ) vertBelongsBitmap |= (1<<4);
             if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[5], dZ) ) vertBelongsBitmap |= (1<<5);
             bandIndices[cubitFace] &= vertBelongsBitmap;
             int diameter = faceDiameter(vertices, indices[f]);
             bandIndices[f] = (diameter>=6 ? 5:diameter);
+            }
           if( bandIndices[cubitFace]!=0 ) // outer face
+            {
             int diameter = faceDiameter(vertices, indices[cubitFace]);
             bandIndices[cubitFace] = (diameter>=6 ? 5:diameter);
+            }
           //android.util.Log.e("D", "cubit face "+cubitFace+" : "+bandIndices[cubitFace]);
+          }
         return bandIndices;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float[] computeVector(int index, float[][] vertices, int[][] indices, int[] bandIndices)
       private float[] computeVector(int index, float[][] vertices, int[][][] indices, int[] bandIndices)
+        {
         int band=0;
         int len = indices.length;
         int numFaces = indices.length;
         int vector=-1;
         for(int i=0; i<len; i++)
         for(int f=0; f<numFaces; f++)
+          {
           int len2 = indices[i].length;
           int numComponentsInFace = indices[f].length;
           for(int j=0; j<len2; j++)
           for(int c=0; c<numComponentsInFace; c++)
+            {
             if( indices[i][j]==index )
             int[] ind = indices[f][c];
             int numVertsInComponent = ind.length;
             for(int v=0; v<numVertsInComponent; v++)
+              {
               int prev = j>0 ? j-1 : len2-1;
               int next = j<len2-1 ? j+1 : 0;
               if(ind[v]==index)
+                {
                 int prev=v>0 ? v-1 : numComponentsInFace-1;
                 int next=v<numComponentsInFace-1 ? v+1 : 0;
               int prevIndex = indices[i][prev];
               int currIndex = indices[i][j];
               int nextIndex = indices[i][next];
                 int prevIndex=ind[prev];
                 int currIndex=ind[v];
                 int nextIndex=ind[next];
               int newVector = computeVectorFace(vertices[prevIndex],vertices[currIndex],vertices[nextIndex]);
               if( vector!=-1 && vector!=newVector ) return null;
                 int newVector=computeVectorFace(vertices[prevIndex], vertices[currIndex], vertices[nextIndex]);
                 if(vector!=-1 && vector!=newVector) return null;
               vector = newVector;
               band |= bandIndices[i];
                 vector=newVector;
                 band|=bandIndices[f];
                 v = numVertsInComponent;
+                }
+              }
+            }
+          }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float[][] generateVectors(float[][] vertices, int[][] indices, int[] bandIndices)
       private float[][] generateVectors(float[][] vertices, int[][][] indices, int[] bandIndices)
+        {
         int len = vertices.length;
         float[][] vectors = new float[len][];
-...
         return vectors;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void displayWall(String tmp)
+        {
         StringBuilder sb = new StringBuilder();
         for(int i=0; i<mMax; i++)
+          {
           for(int j=0; j<mMax; j++)
+            {
             sb.append(mWall[i][j]);
             sb.append(' ');
+            }
           sb.append("  -  ");
+          }
         android.util.Log.e("D", tmp+" : "+sb);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void debug(float[][] vert, int[][] ind)
-...
         for (int[] ints : ind)
+          {
           ii += "\n";
           int lenI2 = ints.length;
           for (int i2 = 0; i2 < lenI2; i2++)
+            {
             ii += (ints[i2] + " ");
+            }
           for(int anInt : ints) ii+=(anInt+" ");
+          }
         android.util.Log.e("D", ii);
+        }
-...
+        {
         if( mVertexArray==null ) mVertexArray = new ArrayList<>();
         mVertices= new float[numVariants][][];
         mIndices = new int[numVariants][][];
         mIndices = new int[numVariants][][][];
         mMove = new float[numVariants][3];
         mBandIndices = new int[numVariants][];
         mFaceBelongsBitmap= new int[numVariants][];
         mX = numLayers[0];
         mY = numLayers[1];
-...
         mMax = mX>mY ? Math.max(mX,mZ) : Math.max(mY,mZ);
         mWall   = new int[mMax][mMax];
         mPoints = new int[mMax+1][mMax+1];
         mCuts   = getCuts(numLayers);
         mWall = new int[mMax][mMax];
         mCuts = getCuts(numLayers);
         createNormal();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int debugArray(int start, String str)
+        {
         StringBuilder s = new StringBuilder();
         int n = mVertexArray.size();
         for(int i=start; i<n; i++)
+          {
           float[][] v = mVertexArray.get(i);
           int numC = v.length;
           s.append("numComp: ");
           s.append(numC);
           for(float[] floats : v)
+            {
             int l=floats.length/3;
             for(int k=0; k<l; k++)
+              {
               s.append(" (");
               s.append(floats[3*k  ]);
               s.append(" ");
               s.append(floats[3*k+1]);
               s.append(" ");
               s.append(floats[3*k+2]);
               s.append(") ");
+              }
+            }
+          }
         android.util.Log.e("D", str+" : "+s);
         return n;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public ObjectShape createIrregularShape(int variant, float[] pos)
-...
         for(int i=0; i<mNumElements; i++) mElements[i] = new BandagedElementCuboid(pos, 3*i, mNormal, mCuts);
         for(int x=0; x<mX; x++) createRight (x,mVertexArray);
       //  int n = debugArray(0,"RIGHT");
         for(int x=0; x<mX; x++) createLeft  (x,mVertexArray);
       //  n = debugArray(n,"LEFT");
         for(int y=0; y<mY; y++) createTop   (y,mVertexArray);
       //  n = debugArray(n,"TOP");
         for(int y=0; y<mY; y++) createBottom(y,mVertexArray);
       //  n = debugArray(n,"BOTTOM");
         for(int z=0; z<mZ; z++) createFront (z,mVertexArray);
       //  n = debugArray(n,"FRONT");
         for(int z=0; z<mZ; z++) createBack  (z,mVertexArray);
      //   n = debugArray(n,"BACK");
         computeMove(pos,variant);
         float[][] verts = getVertices(mVertexArray,variant);
         int[][][] inds  = getIndices(mVertexArray);
         float[][] verts = getVertices(mVertexArray,pos,variant);
         int[][] inds    = getIndices(mVertexArray);
         StringBuilder str = new StringBuilder();
         for(float[] v : verts)
+          {
           str.append(" (");
           str.append(v[0]);
           str.append(" ");
           str.append(v[1]);
           str.append(" ");
           str.append(v[2]);
           str.append(")");
+          }
         android.util.Log.e("D", "createIrregularShape: "+str);
         compressVerticesAndIndices(variant,verts,inds);
         mBandIndices[variant] = generateBandIndices(mVertices[variant], mIndices[variant], mMove[variant]);
         mFaceBelongsBitmap[variant] = computeFaceBelongsBitmap(mVertices[variant], mIndices[variant], mMove[variant]);
         mBandIndices[variant] = generateBandIndices(mVertices[variant], mIndices[variant], mFaceBelongsBitmap[variant]);
         return new ObjectShape(mVertices[variant], mIndices[variant]);
+        }
-...
         int extraV  = 0;
         float[][] bands  = { {  0.001f,angle,R,S,numVerts,extraV,extraI},
                              {height/1,angle,R,S,numVerts,extraV,extraI},
                              {height  ,angle,R,S,numVerts,extraV,extraI},
                              {height/2,angle,R,S,numVerts,extraV,extraI},
                              {height/3,angle,R,S,numVerts,extraV,extraI},
                              {height/4,angle,R,S,numVerts,extraV,extraI},
-...
+        {
         prepare(1,numLayers);
         ObjectShape shape           = createIrregularShape(0,pos);
         /*
         int numP = pos.length;
         StringBuilder str = new StringBuilder();
         str.append("numPos: ");
         str.append(numP);
         str.append("  ");
         for(float po : pos)
+          {
           str.append(po);
           str.append(" ");
+          }
         android.util.Log.e("D", "POS: "+str);
         */
         shape.debug();
         throw new RuntimeException("EX");
         /*
         ObjectFaceShape face        = createIrregularFaceShape(0,iconMode);
         ObjectVertexEffects effects = createVertexEffects(0,roundCorners);
         int numFaces                = shape.getNumFaces();
-...
         factory.clear();
         factory.createNewFaceTransform(shape,null);
         return factory.createRoundedSolid(shape,face,effects,MESH_NICE,numFaces);
          */
+        }
+      }

         mNumFaces       = vertIndices.length;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void debug()
+        {
         StringBuilder str = new StringBuilder();
         str.append("isMultigon: ");
         str.append(mFacesMultigon);
         str.append("\n");
         str.append("numVertices: ");
         int numV =mVertices.length;
         str.append(numV);
         for(float[] v : mVertices)
+          {
           str.append(" (");
           str.append(v[0]);
           str.append(" ");
           str.append(v[1]);
           str.append(" ");
           str.append(v[2]);
           str.append(")");
+          }
         if( mFacesMultigon )
+          {
           int numFaces =mMultigonIndices.length;
           str.append("\nnumFaces: ");
           str.append(numFaces);
           str.append("\n");
           for(int[][] mMultigonIndex : mMultigonIndices)
+            {
             int numC=mMultigonIndex.length;
             str.append("\nnumComponents: ");
             str.append(numC);
             str.append("\n   ");
             for(int[] multigonIndex : mMultigonIndex)
+              {
               for(int index : multigonIndex)
+                {
                 str.append(" ");
                 str.append(index);
+                }
               str.append("\n   ");
+              }
+            }
+          }
         else
+          {
           int numFaces =mVertIndices.length;
           str.append("\nnumFaces: ");
           str.append(numFaces);
           str.append("\n   ");
           for(int[] vertIndex : mVertIndices)
+            {
             for(int index : vertIndex)
+              {
               str.append(" ");
               str.append(index);
+              }
             str.append("\n   ");
+            }
+          }
         android.util.Log.e("D", "ObjectShape: \n"+str);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getNumFaces()

Also available in: Unified diff

Project

General

Profile

TwistyPuzzleLib

Revision b76da174

Added by Leszek Koltunski 11 months ago