commit 15290f35791c7eca26f76c3d98d6b56e5caca994
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Sat Dec 1 00:14:39 2018 +0000

    Progress with the Inflate vector in MeshCubes.

diff --git a/src/main/java/org/distorted/library/mesh/MeshCubes.java b/src/main/java/org/distorted/library/mesh/MeshCubes.java
index 232bbac..a2a8f76 100644
--- a/src/main/java/org/distorted/library/mesh/MeshCubes.java
+++ b/src/main/java/org/distorted/library/mesh/MeshCubes.java
@@ -58,7 +58,7 @@ public class MeshCubes extends MeshBase
    private int[][] mCubes;
    private ArrayList<Edge> mEdges = new ArrayList<>();
 
-   private int remainingVert;
+   private int currVert;
    private int numVertices;
    private int mSideBends;
    private int mEdgeNum;
@@ -197,7 +197,7 @@ public class MeshCubes extends MeshBase
 
        markRegions();
        numVertices = computeDataLength();
-       remainingVert = numVertices;
+       currVert = 0;
        }
      }
 
@@ -221,7 +221,7 @@ public class MeshCubes extends MeshBase
 
        markRegions();
        numVertices = computeDataLength();
-       remainingVert = numVertices;
+       currVert = 0;
        }
      }
 
@@ -392,7 +392,7 @@ public class MeshCubes extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private int buildFrontBackGrid(boolean front, int vertex, float[] attribs)
+  private void buildFrontBackGrid(boolean front, float[] attribs)
      {
      int last, current;
      boolean seenLand=false;
@@ -414,11 +414,11 @@ public class MeshCubes extends MeshBase
            {
            currentBlockIsNE = isNE(row,col);
 
-           if( !seenLand && !front && ((vertex%2==1)^currentBlockIsNE) )
+           if( !seenLand && !front && ((currVert%2==1)^currentBlockIsNE) )
              {
              //android.util.Log.d("CUBES","repeating winding2 vertex");
 
-             vertex = repeatLast(vertex,attribs);
+             repeatLast(attribs);
              }
 
            createNormals(front,row,col);
@@ -427,27 +427,27 @@ public class MeshCubes extends MeshBase
              {
              if( (last!=current) || !lastBlockIsNE )
                {
-               if( seenLand  && (last != current) ) vertex = repeatLast(vertex,attribs);
-               vertex= addFrontVertex( vertex, 0, vectZ, col, row, attribs);
-               if( seenLand  && (last != current) ) vertex = repeatLast(vertex,attribs);
-               if( !lastBlockIsNE || (!front && !seenLand) ) vertex = repeatLast(vertex,attribs);
-               vertex= addFrontVertex( vertex, 1, vectZ, col, row+1, attribs);
+               if( seenLand  && (last != current) ) repeatLast(attribs);
+               addFrontVertex( 0, vectZ, col, row, attribs);
+               if( seenLand  && (last != current) ) repeatLast(attribs);
+               if( !lastBlockIsNE || (!front && !seenLand) ) repeatLast(attribs);
+               addFrontVertex( 1, vectZ, col, row+1, attribs);
                }
-             vertex= addFrontVertex( vertex, 2, vectZ, col+1, row, attribs);
-             vertex= addFrontVertex( vertex, 3, vectZ, col+1, row+1, attribs);
+             addFrontVertex( 2, vectZ, col+1, row, attribs);
+             addFrontVertex( 3, vectZ, col+1, row+1, attribs);
              }
            else
              {
              if( (last!=current) || lastBlockIsNE )
                {
-               if( seenLand  && (last != current) ) vertex = repeatLast(vertex,attribs);
-               vertex= addFrontVertex( vertex, 1, vectZ, col, row+1, attribs);
-               if( seenLand  && (last != current) ) vertex = repeatLast(vertex,attribs);
-               if( lastBlockIsNE || (!front && !seenLand) ) vertex = repeatLast(vertex,attribs);
-               vertex= addFrontVertex( vertex, 0, vectZ, col, row, attribs);
+               if( seenLand  && (last != current) ) repeatLast(attribs);
+               addFrontVertex( 1, vectZ, col, row+1, attribs);
+               if( seenLand  && (last != current) ) repeatLast(attribs);
+               if( lastBlockIsNE || (!front && !seenLand) ) repeatLast(attribs);
+               addFrontVertex( 0, vectZ, col, row, attribs);
                }
-             vertex= addFrontVertex( vertex, 3, vectZ, col+1, row+1, attribs);
-             vertex= addFrontVertex( vertex, 2, vectZ, col+1, row  , attribs);
+             addFrontVertex( 3, vectZ, col+1, row+1, attribs);
+             addFrontVertex( 2, vectZ, col+1, row  , attribs);
              }
 
            seenLand = true;
@@ -457,27 +457,23 @@ public class MeshCubes extends MeshBase
          last = current;
          }
        }
-     
-     return vertex;
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private int buildSideGrid(int vertex, float[] attribs)
+  private void buildSideGrid(float[] attribs)
      {
      //android.util.Log.d("CUBES", "buildSide");
 
      for(int i=0; i<mEdgeNum; i++)
        {
-       vertex = buildIthSide(mEdges.get(i), vertex, attribs);
-       } 
-      
-     return vertex;
+       buildIthSide(mEdges.get(i), attribs);
+       }
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private int buildIthSide(Edge curr, int vertex, float[] attribs)
+  private void buildIthSide(Edge curr, float[] attribs)
      {
      Edge prev, next;
      int col, row, side;
@@ -499,18 +495,18 @@ public class MeshCubes extends MeshBase
        side= curr.side;
        next = getNextEdge(curr);
      
-       addSideVertex(curr,true,i+1,prev.side,vertex++,attribs);
+       addSideVertex(curr,true,i+1,prev.side,attribs);
 
        do
          {
          if( prev.side!=curr.side )
            {
-           addSideVertex(curr,true,i+1,prev.side,vertex++,attribs);
-           addSideVertex(curr,true,i  ,prev.side,vertex++,attribs);
+           addSideVertex(curr,true,i+1,prev.side,attribs);
+           addSideVertex(curr,true,i  ,prev.side,attribs);
            }
        
-         addSideVertex(curr,false,i+1,next.side,vertex++,attribs);
-         addSideVertex(curr,false,i  ,next.side,vertex++,attribs);
+         addSideVertex(curr,false,i+1,next.side,attribs);
+         addSideVertex(curr,false,i  ,next.side,attribs);
        
          prev = curr;
          curr = next;
@@ -518,10 +514,8 @@ public class MeshCubes extends MeshBase
          }
        while( curr.col!=col || curr.row!=row || curr.side!=side );
      
-       vertex = repeatLast(vertex,attribs);
+       repeatLast(attribs);
        }
-
-     return vertex;
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -575,180 +569,165 @@ public class MeshCubes extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private int addFrontVertex(int vertex, int index, float vectZ, int col, int row, float[] attribs)
+  private void addFrontVertex(int index, float vectZ, int col, int row, float[] attribs)
      {
-     remainingVert--;
-
      float x = (float)col/mCols;
      float y = (float)row/mRows;
 
-     attribs[VERT_ATTRIBS*vertex + POS_ATTRIB  ] = x-0.5f;
-     attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+1] = 0.5f-y;
-     attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+2] = vectZ;
+     attribs[VERT_ATTRIBS*currVert + POS_ATTRIB  ] = x-0.5f;
+     attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = 0.5f-y;
+     attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = vectZ;
 
-     attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB  ] = mNormalX[index];
-     attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+1] = mNormalY[index];
-     attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+2] = mNormalZ[index];
+     attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB  ] = mNormalX[index];
+     attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] = mNormalY[index];
+     attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = mNormalZ[index];
 
-     attribs[VERT_ATTRIBS*vertex + INF_ATTRIB  ] = 1.0f;  //
-     attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+1] = 0.0f;  // TODO
-     attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+2] = 0.0f;  //
+     attribs[VERT_ATTRIBS*currVert + INF_ATTRIB  ] = 0.0f;  // TODO
+     attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = 0.0f;  // TODO
+     attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = vectZ;
 
-     attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB  ] = x;
-     attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = 1.0f-y;
+     attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = x;
+     attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f-y;
 
-     return vertex+1;
+     currVert++;
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
    
-  private void addSideVertex(Edge curr, boolean back, int slice,int side, int vertex, float[] attribs)
+  private void addSideVertex(Edge curr, boolean back, int slice, int side, float[] attribs)
      {
      //android.util.Log.e("CUBES", "adding Side vertex!");
-
-     remainingVert--;
-
      float x, y;
 
      switch(curr.side)
        {
        case NORTH: x = (float)(back ? (curr.col  ):(curr.col+1))/mCols;
 
-                   attribs[VERT_ATTRIBS*vertex + POS_ATTRIB  ] = x - 0.5f;
-                   attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+1] = 0.5f - (float)curr.row/mRows;
-                   attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB  ] = x - 0.5f;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = 0.5f - (float)curr.row/mRows;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
 
-                   attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB  ] = side==NORTH ? 0.0f : (side==WEST?-R:R);
-                   attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+1] = 1.0f;
-                   attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
+                   attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB  ] = side==NORTH ? 0.0f : (side==WEST?-R:R);
+                   attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] = 1.0f;
+                   attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
 
-                   attribs[VERT_ATTRIBS*vertex + INF_ATTRIB  ] = 1.0f;  //
-                   attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+1] = 0.0f;  // TODO
-                   attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+2] = 0.0f;  //
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB  ] = 0.0f;  //
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = 0.0f;  // TODO
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = 0.5f - (float)slice/mSlices;
 
-                   attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB  ] = x;
-                   attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = 1.0f-(float)(curr.row-slice)/mRows;
+                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = x;
+                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f-(float)(curr.row-slice)/mRows;
                    break;
        case SOUTH: x = (float)(back ? (curr.col+1):(curr.col  ))/mCols;
 
-                   attribs[VERT_ATTRIBS*vertex + POS_ATTRIB  ] = x - 0.5f;
-                   attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+1] = 0.5f - (float)(curr.row+1)/mRows;
-                   attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB  ] = x - 0.5f;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = 0.5f - (float)(curr.row+1)/mRows;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
 
-                   attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB  ] = side==SOUTH ? 0.0f: (side==EAST?-R:R);
-                   attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+1] =-1.0f;
-                   attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
+                   attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB  ] = side==SOUTH ? 0.0f: (side==EAST?-R:R);
+                   attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] =-1.0f;
+                   attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
 
-                   attribs[VERT_ATTRIBS*vertex + INF_ATTRIB  ] = 1.0f;  //
-                   attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+1] = 0.0f;  // TODO
-                   attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+2] = 0.0f;  //
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB  ] = 0.0f;  //
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = 0.0f;  // TODO
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = 0.5f - (float)slice/mSlices;
 
-                   attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB  ] = x;
-                   attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = 1.0f - (float)(curr.row+1+slice)/mRows;
+                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = x;
+                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f - (float)(curr.row+1+slice)/mRows;
                    break;
        case WEST : y = (float)(back  ? (curr.row+1):(curr.row))/mRows;
 
-                   attribs[VERT_ATTRIBS*vertex + POS_ATTRIB  ] = (float)curr.col/mCols -0.5f;
-                   attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+1] = 0.5f - y;
-                   attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB  ] = (float)curr.col/mCols -0.5f;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = 0.5f - y;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
 
-                   attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB  ] =-1.0f;
-                   attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+1] = side==WEST ? 0.0f : (side==NORTH?-R:R);
-                   attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
+                   attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB  ] =-1.0f;
+                   attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] = side==WEST ? 0.0f : (side==NORTH?-R:R);
+                   attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
 
-                   attribs[VERT_ATTRIBS*vertex + INF_ATTRIB  ] = 1.0f;  //
-                   attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+1] = 0.0f;  // TODO
-                   attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+2] = 0.0f;  //
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB  ] = 0.0f;  //
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = 0.0f;  // TODO
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = 0.5f - (float)slice/mSlices;
 
-                   attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB  ] = (float)(curr.col-slice)/mCols;
-                   attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = 1.0f - y;
+                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = (float)(curr.col-slice)/mCols;
+                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f - y;
                    break;
        case EAST : y = (float)(back  ? (curr.row):(curr.row+1))/mRows;
 
-                   attribs[VERT_ATTRIBS*vertex + POS_ATTRIB  ] = (float)(curr.col+1)/mCols -0.5f;
-                   attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+1] = 0.5f - y;
-                   attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB  ] = (float)(curr.col+1)/mCols -0.5f;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = 0.5f - y;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
 
-                   attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB  ] = 1.0f;
-                   attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+1] = side==EAST ? 0.0f : (side==SOUTH?-R:R);
-                   attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
+                   attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB  ] = 1.0f;
+                   attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] = side==EAST ? 0.0f : (side==SOUTH?-R:R);
+                   attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
 
-                   attribs[VERT_ATTRIBS*vertex + INF_ATTRIB  ] = 1.0f;  //
-                   attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+1] = 0.0f;  // TODO
-                   attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+2] = 0.0f;  //
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB  ] = 0.0f;  //
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = 0.0f;  // TODO
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = 0.5f - (float)slice/mSlices;
 
-                   attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB  ] = (float)(curr.col+1+slice)/mCols;
-                   attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = 1.0f - y;
+                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = (float)(curr.col+1+slice)/mCols;
+                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f - y;
                    break;
        }
 
-     float tex0 =  attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB  ];
-     float tex1 =  attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1];
+     float tex0 =  attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ];
+     float tex1 =  attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1];
+
+     if(tex0>1.0f) attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = 2.0f-tex0;
+     if(tex0<0.0f) attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] =     -tex0;
+     if(tex1>1.0f) attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 2.0f-tex1;
+     if(tex1<0.0f) attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] =     -tex1;
 
-     if(tex0>1.0f) attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB  ] = 2.0f-tex0;
-     if(tex0<0.0f) attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB  ] =     -tex0;
-     if(tex1>1.0f) attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = 2.0f-tex1;
-     if(tex1<0.0f) attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] =     -tex1;
+     currVert++;
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-   private int repeatLast(int vertex, float[] attribs)
+   private void repeatLast(float[] attribs)
      {
      //android.util.Log.e("CUBES", "repeating last vertex!");
 
-     if( vertex>0 )
-       {
-       remainingVert--;
-
-       attribs[VERT_ATTRIBS*vertex + POS_ATTRIB  ] = attribs[VERT_ATTRIBS*(vertex-1) + POS_ATTRIB  ];
-       attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+1] = attribs[VERT_ATTRIBS*(vertex-1) + POS_ATTRIB+1];
-       attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+2] = attribs[VERT_ATTRIBS*(vertex-1) + POS_ATTRIB+2];
+     attribs[VERT_ATTRIBS*currVert + POS_ATTRIB  ] = attribs[VERT_ATTRIBS*(currVert-1) + POS_ATTRIB  ];
+     attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = attribs[VERT_ATTRIBS*(currVert-1) + POS_ATTRIB+1];
+     attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = attribs[VERT_ATTRIBS*(currVert-1) + POS_ATTRIB+2];
 
-       attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB  ] = attribs[VERT_ATTRIBS*(vertex-1) + NOR_ATTRIB  ];
-       attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+1] = attribs[VERT_ATTRIBS*(vertex-1) + NOR_ATTRIB+1];
-       attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+2] = attribs[VERT_ATTRIBS*(vertex-1) + NOR_ATTRIB+2];
+     attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB  ] = attribs[VERT_ATTRIBS*(currVert-1) + NOR_ATTRIB  ];
+     attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] = attribs[VERT_ATTRIBS*(currVert-1) + NOR_ATTRIB+1];
+     attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = attribs[VERT_ATTRIBS*(currVert-1) + NOR_ATTRIB+2];
 
-       attribs[VERT_ATTRIBS*vertex + INF_ATTRIB  ] = attribs[VERT_ATTRIBS*(vertex-1) + INF_ATTRIB  ];
-       attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+1] = attribs[VERT_ATTRIBS*(vertex-1) + INF_ATTRIB+1];
-       attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+2] = attribs[VERT_ATTRIBS*(vertex-1) + INF_ATTRIB+2];
+     attribs[VERT_ATTRIBS*currVert + INF_ATTRIB  ] = attribs[VERT_ATTRIBS*(currVert-1) + INF_ATTRIB  ];
+     attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = attribs[VERT_ATTRIBS*(currVert-1) + INF_ATTRIB+1];
+     attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = attribs[VERT_ATTRIBS*(currVert-1) + INF_ATTRIB+2];
 
-       attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB  ] = attribs[VERT_ATTRIBS*(vertex-1) + TEX_ATTRIB  ];
-       attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = attribs[VERT_ATTRIBS*(vertex-1) + TEX_ATTRIB+1];
+     attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = attribs[VERT_ATTRIBS*(currVert-1) + TEX_ATTRIB  ];
+     attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = attribs[VERT_ATTRIBS*(currVert-1) + TEX_ATTRIB+1];
 
-
-       vertex++;
-       }
-
-     return vertex;
+     currVert++;
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   private void build()
      {
-     int vertSoFar=0;
      float[] attribs= new float[VERT_ATTRIBS*numVertices];
 
-     vertSoFar = buildFrontBackGrid(true, vertSoFar,attribs);
+     buildFrontBackGrid(true,attribs);
 
      if( mSlices>0 )
        {
-       vertSoFar = repeatLast(vertSoFar,attribs);
-       if( vertSoFar%2==1 )
-         {
-         vertSoFar = repeatLast(vertSoFar,attribs);
-         }
-       vertSoFar = buildSideGrid (vertSoFar,attribs);
-       buildFrontBackGrid (false,vertSoFar,attribs);
+       repeatLast(attribs);
+       if( currVert%2==1 ) repeatLast(attribs);
+       buildSideGrid(attribs);
+       buildFrontBackGrid(false,attribs);
        }
 
      mEdges.clear();
      mEdges = null;
      mCubes = null;
 
-     if( remainingVert!=0 )
-       android.util.Log.e("MeshCubes", "remainingVert " +remainingVert );
+     if( currVert!=numVertices )
+       android.util.Log.e("MeshCubes", "currVert " +currVert+" numVertices="+numVertices );
 
      setAttribs(attribs);
      }
diff --git a/src/main/java/org/distorted/library/mesh/MeshFlat.java b/src/main/java/org/distorted/library/mesh/MeshFlat.java
index 44f0fbd..0fb1dc6 100644
--- a/src/main/java/org/distorted/library/mesh/MeshFlat.java
+++ b/src/main/java/org/distorted/library/mesh/MeshFlat.java
@@ -55,7 +55,6 @@ public class MeshFlat extends MeshBase
      remainingVert = numVertices;
      }
 
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   private int addVertex(int vertex, float x, float y, float[] attribs)