commit 9d0df4c64b61e7be0c478a1cdbf2d305050607c0
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Sun Dec 2 01:13:23 2018 +0000

    Progress with the Inflate vector in MeshCubes.
    
    Pretty much works now - what remains is calibration.

diff --git a/src/main/java/org/distorted/library/mesh/MeshCubes.java b/src/main/java/org/distorted/library/mesh/MeshCubes.java
index a2a8f76..a6871c1 100644
--- a/src/main/java/org/distorted/library/mesh/MeshCubes.java
+++ b/src/main/java/org/distorted/library/mesh/MeshCubes.java
@@ -56,6 +56,7 @@ public class MeshCubes extends MeshBase
    
    private int mCols, mRows, mSlices;
    private int[][] mCubes;
+   private byte[][] mInflateX, mInflateY;
    private ArrayList<Edge> mEdges = new ArrayList<>();
 
    private int currVert;
@@ -189,11 +190,19 @@ public class MeshCubes extends MeshBase
        mCols = cols;
        mRows = desc.length()/cols;
 
-       mCubes = new int[mRows][mCols];
-       
+       mCubes    = new int[mRows][mCols];
+       mInflateX = new byte[mRows+1][mCols+1];
+       mInflateY = new byte[mRows+1][mCols+1];
+
        for(int j=0; j<mCols; j++)
          for(int i=0; i<mRows; i++)
-           mCubes[i][j] = (desc.charAt(i*mCols+j) == '1' ? 1:0);
+           mCubes[i][j] = (desc.charAt(i * mCols + j) == '1' ? 1 : 0);
+
+       for(int j=0; j<mCols+1; j++)
+         for(int i=0; i<mRows+1; i++)
+           {
+           fillInflate(j,i);
+           }
 
        markRegions();
        numVertices = computeDataLength();
@@ -213,12 +222,20 @@ public class MeshCubes extends MeshBase
 
      if( cols>0 && rows>0 )
        {
-       mCubes = new int[mRows][mCols];
+       mCubes    = new int[mRows][mCols];
+       mInflateX = new byte[mRows+1][mCols+1];
+       mInflateY = new byte[mRows+1][mCols+1];
 
        for(int j=0; j<mCols; j++)
          for(int i=0; i<mRows; i++)
            mCubes[i][j] = 1;
 
+       for(int j=0; j<mCols+1; j++)
+         for(int i=0; i<mRows+1; i++)
+           {
+           fillInflate(j,i);
+           }
+
        markRegions();
        numVertices = computeDataLength();
        currVert = 0;
@@ -488,25 +505,25 @@ public class MeshCubes extends MeshBase
        curr = new Edge(EAST,curr.row+1,curr.col-1);
        }
 
-     for(int i=0; i<mSlices; i++)
+     for(int slice=0; slice<mSlices; slice++)
        {
        col = curr.col;
        row = curr.row;
        side= curr.side;
        next = getNextEdge(curr);
      
-       addSideVertex(curr,true,i+1,prev.side,attribs);
+       addSideVertex(curr,true,slice+1,prev.side,attribs);
 
        do
          {
          if( prev.side!=curr.side )
            {
-           addSideVertex(curr,true,i+1,prev.side,attribs);
-           addSideVertex(curr,true,i  ,prev.side,attribs);
+           addSideVertex(curr,true,slice+1,prev.side,attribs);
+           addSideVertex(curr,true,slice  ,prev.side,attribs);
            }
        
-         addSideVertex(curr,false,i+1,next.side,attribs);
-         addSideVertex(curr,false,i  ,next.side,attribs);
+         addSideVertex(curr,false,slice+1,next.side,attribs);
+         addSideVertex(curr,false,slice  ,next.side,attribs);
        
          prev = curr;
          curr = next;
@@ -567,6 +584,63 @@ public class MeshCubes extends MeshBase
        }
      }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private void fillInflate(int col, int row)
+    {
+    int diff;
+
+         if( col==0     ) mInflateX[col][row] = -1;
+    else if( col==mCols ) mInflateX[col][row] = +1;
+    else
+      {
+      if( row==0 )
+        {
+        diff = mCubes[0][col-1]-mCubes[0][col];
+        }
+      else if( row==mRows )
+        {
+        diff = mCubes[mRows-1][col-1]-mCubes[mRows-1][col];
+        }
+      else
+        {
+        diff = (mCubes[row  ][col-1]-mCubes[row  ][col]) +
+               (mCubes[row-1][col-1]-mCubes[row-1][col]) ;
+
+        if( diff==-2 ) diff=-1;
+        if( diff== 2 ) diff= 1;
+        }
+
+      mInflateX[col][row] = (byte)diff;
+      }
+
+         if( row==0    ) mInflateY[col][row] = +1;
+    else if(row==mRows ) mInflateY[col][row] = -1;
+    else
+      {
+      if( col==0 )
+        {
+        diff = mCubes[row][0]-mCubes[row-1][0];
+        }
+      else if( col==mCols )
+        {
+        diff = mCubes[row][mCols-1]-mCubes[row-1][mCols-1];
+        }
+      else
+        {
+        diff = (mCubes[row  ][col-1]+mCubes[row  ][col]) -
+               (mCubes[row-1][col-1]+mCubes[row-1][col]) ;
+
+        if( diff==-2 ) diff=-1;
+        if( diff== 2 ) diff= 1;
+        }
+
+      mInflateY[col][row] = (byte)diff;
+      }
+
+    //android.util.Log.e("mesh","col="+col+" row="+row+" inflateX="+mInflateX[col][row]+" InflateY="+mInflateY[col][row]);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   private void addFrontVertex(int index, float vectZ, int col, int row, float[] attribs)
@@ -582,8 +656,8 @@ public class MeshCubes extends MeshBase
      attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] = mNormalY[index];
      attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = mNormalZ[index];
 
-     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  ] = mInflateX[col][row]/2.0f;
+     attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = mInflateY[col][row]/2.0f;
      attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = vectZ;
 
      attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = x;
@@ -597,76 +671,93 @@ public class MeshCubes extends MeshBase
   private void addSideVertex(Edge curr, boolean back, int slice, int side, float[] attribs)
      {
      //android.util.Log.e("CUBES", "adding Side vertex!");
-     float x, y;
+     float x, y, z;
+     int row, col;
 
      switch(curr.side)
        {
-       case NORTH: x = (float)(back ? (curr.col  ):(curr.col+1))/mCols;
+       case NORTH: row = curr.row;
+                   col = (back ? (curr.col  ):(curr.col+1));
+                   x = (float)col/mCols;
+                   y = 0.5f - (float)row/mRows;
+                   z = 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*currVert + POS_ATTRIB+1] = y;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = z;
 
                    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*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*currVert + INF_ATTRIB  ] = mInflateX[col][row]/2.0f;
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = mInflateY[col][row]/2.0f;
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = z;
 
                    attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = x;
-                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f-(float)(curr.row-slice)/mRows;
+                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f-(float)(row-slice)/mRows;
                    break;
-       case SOUTH: x = (float)(back ? (curr.col+1):(curr.col  ))/mCols;
+       case SOUTH: row = curr.row+1;
+                   col = (back ? (curr.col+1):(curr.col));
+                   x = (float)col/mCols;
+                   y = 0.5f - (float)row/mRows;
+                   z = 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*currVert + POS_ATTRIB+1] = y;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = z;
 
                    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*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*currVert + INF_ATTRIB  ] = mInflateX[col][row]/2.0f;
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = mInflateY[col][row]/2.0f;
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = z;
 
                    attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = x;
-                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f - (float)(curr.row+1+slice)/mRows;
+                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f - (float)(row+slice)/mRows;
                    break;
-       case WEST : y = (float)(back  ? (curr.row+1):(curr.row))/mRows;
+       case WEST : row = (back  ? (curr.row+1):(curr.row));
+                   col = curr.col;
+                   x = (float)col/mCols -0.5f;
+                   y = (float)row/mRows;
+                   z = 0.5f - (float)slice/mSlices;
 
-                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB  ] = (float)curr.col/mCols -0.5f;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB  ] = x;
                    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*currVert + POS_ATTRIB+2] = z;
 
                    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*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*currVert + INF_ATTRIB  ] = mInflateX[col][row]/2.0f;
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = mInflateY[col][row]/2.0f;
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = z;
 
-                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = (float)(curr.col-slice)/mCols;
+                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = (float)(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;
+       case EAST : row = (back  ? (curr.row):(curr.row+1));
+                   col = (curr.col+1);
+                   x = (float)col/mCols -0.5f;
+                   y = (float)row/mRows;
+                   z = 0.5f - (float)slice/mSlices;
 
-                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB  ] = (float)(curr.col+1)/mCols -0.5f;
+                   attribs[VERT_ATTRIBS*currVert + POS_ATTRIB  ] = x;
                    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*currVert + POS_ATTRIB+2] = z;
 
                    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*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*currVert + INF_ATTRIB  ] = mInflateX[col][row]/2.0f;
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = mInflateY[col][row]/2.0f;
+                   attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = z;
 
-                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = (float)(curr.col+1+slice)/mCols;
+                   attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = (float)(col+slice)/mCols;
                    attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f - y;
                    break;
        }
@@ -725,6 +816,8 @@ public class MeshCubes extends MeshBase
      mEdges.clear();
      mEdges = null;
      mCubes = null;
+     mInflateX = null;
+     mInflateY = null;
 
      if( currVert!=numVertices )
        android.util.Log.e("MeshCubes", "currVert " +currVert+" numVertices="+numVertices );