Distorted Android

   private static final int NW = 0;

   private static final int NE = 1;

   private static final int SW = 2;

   private static final int SE = 3;

   private static final float[] mNormalZ = new float[4];

   private boolean addEmpty1; // add an initial empty vertex? ( that would be because the initial block

                              // of land is in the top-right quarter (or bottom-left) and thus the very

                              // first triangle is counter-clockwise)

   private boolean addEmpty2; // add an empty vertex when shifting from front to the side (that happens

                              // iff the last front block is in the front-left or bottom-right quarter)

   private boolean addEmpty3; // add an empty vertex when shifting from the side to the back. (that

                              // happens iff the first back block is in the top right or bottom-left

                              // quarter, i.e. actually addEmpty3 = addEmpty1.

///////////////////////////////////////////////////////////////////////////////////////////////////

// a Block is split into two triangles along the NE-SW line iff it is in the top-right

// or bottom-left quadrant of the grid.

   private boolean isNE(int row,int col)

     {

     return ( (row<=(mRows-1)/2)^(col<=(mCols-1)/2) );

     }

      int frontWalls=0, frontSegments=0, sideWalls=0, sideBends=0, triangleShifts=0, rowJumpShifts=0;

      int shiftCol = (mCols-1)/2;

      boolean seenLand=false;

      boolean lastBlockIsNE=false;

      boolean seenBlockInRow;

      boolean thisBlockIsNE;        // the block we are currently looking at is split into

                                    // two triangles along the NE-SW line (rather than NW-SE)

         {

         if( mCols>=2 && (mCubes[i][shiftCol]%2 == 1) && (mCubes[i][shiftCol+1]%2 == 1) ) triangleShifts++;

         seenBlockInRow=false;

              thisBlockIsNE = isNE(i,j);

              if( !seenBlockInRow )

                {

                if( thisBlockIsNE^lastBlockIsNE ) rowJumpShifts++;

                seenBlockInRow=true;

                }

              lastBlockIsNE = thisBlockIsNE;

              if( !seenLand )

                {

                addEmpty1 = addEmpty3 = lastBlockIsNE;

                seenLand=true;

                }

         }

      addEmpty2 = !lastBlockIsNE;

      int frontVert = 2*( frontWalls + 2*frontSegments - 1) +3*triangleShifts + rowJumpShifts;

      // no we don't add addEmpty1 because this is already included in the rowJumpShifts

      int dataL = frontOnly ? frontVert : (frontVert+1) + (1+sideVert+1) + (1+frontVert) +(addEmpty2?1:0) + (addEmpty3?1:0);

      android.util.Log.e("CUBES","triangleShifts="+triangleShifts+" rowJumpShifts="+rowJumpShifts);

      android.util.Log.e("CUBES","addEmpty1="+addEmpty1+" addEmpty2="+addEmpty2+" addEmpty3="+addEmpty3);

      android.util.Log.e("CUBES","frontVert="+frontVert+" sideVert="+sideVert);

      android.util.Log.e("CUBES", "frontW="+frontWalls+" fSegments="+frontSegments+" sWalls="+sideWalls+" sSegments="+edges+" sideBends="+sideBends+" dataLen="+dataL );

     String ret="";j

   private void createNormals(boolean front, int row, int col)

     if(front)

       {

       mNormalZ[0] = 1.0f;

       mNormalZ[1] = 1.0f;

       mNormalZ[2] = 1.0f;

       mNormalZ[3] = 1.0f;

       }

     else

       {

       mNormalZ[0] =-1.0f;

       mNormalZ[1] =-1.0f;

       mNormalZ[2] =-1.0f;

       mNormalZ[3] =-1.0f;

       }

   private int addFrontVertex(int corner, int vertex, float centerX, float centerY, float vectZ, int col, int row, float[] position, float[] normal, float[] texture)

     {

     switch(corner)

       {

       case NW: position[3*vertex  ] = (centerX-0.5f)/mCols;

                position[3*vertex+1] = (centerY+0.5f)/mRows;

                position[3*vertex+2] = vectZ;

                normal[3*vertex  ]   = mNormalX[0];

                normal[3*vertex+1]   = mNormalY[0];

                normal[3*vertex+2]   = mNormalZ[0];

                texture[2*vertex  ]  = (float)col/mCols;

                texture[2*vertex+1]  = (float)row/mRows;

                return vertex+1;

       case SW: position[3*vertex  ] = (centerX-0.5f)/mCols;

                position[3*vertex+1] = (centerY-0.5f)/mRows;

                position[3*vertex+2] = vectZ;

                normal[3*vertex  ]   = mNormalX[1];

                normal[3*vertex+1]   = mNormalY[1];

                normal[3*vertex+2]   = mNormalZ[1];

                texture[2*vertex  ]  = (float)col/mCols;

                texture[2*vertex+1]  = (float)(row+1)/mRows;

                return vertex+1;

       case NE: position[3*vertex  ] = (centerX+0.5f)/mCols;

                position[3*vertex+1] = (centerY+0.5f)/mRows;

                position[3*vertex+2] = vectZ;

                normal[3*vertex  ]   = mNormalX[2];

                normal[3*vertex+1]   = mNormalY[2];

                normal[3*vertex+2]   = mNormalZ[2];

                texture[2*vertex  ]  = (float)(col+1)/mCols;

                texture[2*vertex+1]  = (float)row/mRows;

                return vertex+1;

       case SE: position[3*vertex  ] = (centerX+0.5f)/mCols;

                position[3*vertex+1] = (centerY-0.5f)/mRows;

                position[3*vertex+2] = vectZ;

                normal[3*vertex  ]   = mNormalX[3];

                normal[3*vertex+1]   = mNormalY[3];

                normal[3*vertex+2]   = mNormalZ[3];

                texture[2*vertex  ]  = (float)(col+1)/mCols;

                texture[2*vertex+1]  = (float)(row+1)/mRows;

       }

     return vertex;

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

     boolean seenLand=false;

     boolean lastBlockIsNE = false;

     boolean currentBlockIsNE;

     float vectZ = front?FRONTZ:BACKZ;

           currentBlockIsNE = isNE(i,j);

           createNormals(front,i,j);

           if( (last!=current) || (lastBlockIsNE^currentBlockIsNE) )

             if( seenLand  && (last != current) ) vertex = repeatLast(vertex,position,normal,texture);

             vertex= addFrontVertex( currentBlockIsNE ? NW:SW, vertex, centerX, centerY, vectZ, j, i, position, normal, texture);

             if( seenLand  && (last != current) ) vertex = repeatLast(vertex,position,normal,texture);

             if( lastBlockIsNE^currentBlockIsNE ) vertex = repeatLast(vertex,position,normal,texture);

             vertex= addFrontVertex( currentBlockIsNE ? SW:NW, vertex, centerX, centerY, vectZ, j, i, position, normal, texture);

           vertex= addFrontVertex( currentBlockIsNE ? NE:SE, vertex, centerX, centerY, vectZ, j, i, position, normal, texture);

           vertex= addFrontVertex( currentBlockIsNE ? SE:NE, vertex, centerX, centerY, vectZ, j, i, position, normal, texture);

           seenLand = true;

           lastBlockIsNE = currentBlockIsNE;

     if( addEmpty2 ) vertex = repeatLast(vertex,position,normal,texture);