Distorted Android

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

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

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

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.util.ArrayList;

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

   private static final float R = 0.2f;

   private static final float FRONTZ = 0.5f;

   private static final float BACKZ  =-0.5f;

   private static final int NORTH = 0;

   private static final int WEST  = 1;

   private static final int EAST  = 2;

   private static final int SOUTH = 3;

   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 boolean FRONT = false;

   private static final boolean UPPER = false;

   private static final boolean LOWER = true;

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

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

     {

     final int side; 

     final int row;

     final int col;

     public Edge(int s, int r, int c)

       {

       side= s; 

       row = r;

       col = c;

       }

   private int mCols, mRows;

   private short[][] mCubes;

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

// 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) );

     }

   private int computeDataLength(boolean frontOnly)

      {

      //boolean firstBlockIsNE=false;

      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++;

            {

            if( mCubes[i][j]%2 == 1 )  // land

              {

                {

                seenLand=true;

              if( j==mCols-1 || mCubes[i][j+1]%2 == 0 ) frontSegments++;

              }

            if( (i==0 && mCubes[i][j]!=2) || (i!=0 && mCubes[i][j] != mCubes[i-1][j  ]) ) sideWalls++; // up

            if( (j==0 && mCubes[i][j]!=2) || (j!=0 && mCubes[i][j] != mCubes[i  ][j-1]) ) sideWalls++; // left

            if( i==mRows-1 && mCubes[i][j]!=2                                           ) sideWalls++; // bottom

            if( j==mCols-1 && mCubes[i][j]!=2                                           ) sideWalls++; // right

            }

      for(int i=0; i<edges; i++) 

        {

        Edge curr = mEdges.get(i);

        Edge next = getNextEdge(curr);

        int startX = curr.col;

        int startY = curr.row;

        int startS = curr.side;

        do

          {

          if( next.side != curr.side ) sideBends++; 

          curr  = next; 

          next = getNextEdge(curr);

          }

        while( curr.col!=startX || curr.row!=startY || curr.side!=startS );

        }

      //int secondWinding=0;

        {

        if( (frontVert+1)%2==1 ) firstWinding=1;

        //if( (((frontVert+1)+firstWinding+(1+sideVert+1))%2==1)^firstBlockIsNE ) secondWinding=1;

        }

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

      //android.util.Log.e("CUBES","Winding1="+firstWinding+" Winding2="+secondWinding);

      //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 );

      return dataL<0 ? 0:dataL;

      }

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

/*

   private static String debug(short[] val)

     {

     for(int i=0; i<val.length; i++) ret+=(" "+val[i]); 

     return ret;

     }

*/

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

/*

   private static String debug(float[] val, int stop)

     {

     String ret="";

     for(int i=0; i<val.length; i++) 

        {

        if( i%stop==0 ) ret+="\n";

        ret+=(" "+val[i]);

        }

     return ret;

     }

*/  

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

/*

   private static String debug(Edge e)

     {

     String d = "";

     switch(e.side)

       {

       case NORTH: d+="NORTH "; break;

       case SOUTH: d+="SOUTH "; break;

       case WEST : d+="WEST  "; break;

       case EAST : d+="EAST  "; break;

       }

     d+=("("+e.row+","+e.col+")");

     return d;

     }   

*/ 

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

     mRows     =0;

     mCols     =0;

     dataLength=0;

       mRows = desc.length()/cols;

         for(int i=0; i<mRows; i++)

           mCubes[i][j] = (short)(desc.charAt(i*mCols+j) == '1' ? 1:0);

       dataLength = computeDataLength(frontOnly);

       remainingVert = dataLength;

     }

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

// Mark all the 'regions' of our grid  - i.e. separate pieces of 'land' (connected blocks that will 

// be rendered) and 'water' (connected holes in between) with integers. Each connected block of land

// gets a unique odd integer, each connected block of water a unique even integer.

//

// Water on the edges of the grid is also considered connected to itself!   

//   

// This function also creates a list of 'Edges'. Each Edge is a data structure from which later on we

   private void markRegions()

     {

     int i, j, numWater=1, numLand=0;

     for(i=0; i<mRows;i++) if( mCubes[      i][      0]==0 ) markRegion((short)2,      i,       0);

     for(i=0; i<mRows;i++) if( mCubes[      i][mCols-1]==0 ) markRegion((short)2,      i, mCols-1);

     for(i=0; i<mCols;i++) if( mCubes[0      ][      i]==0 ) markRegion((short)2,      0,       i);

     for(i=0; i<mCols;i++) if( mCubes[mRows-1][      i]==0 ) markRegion((short)2,mRows-1,       i);

     for(i=0; i<mRows; i++)

        for(j=0; j<mCols; j++)

           {

           if( mCubes[i][j] == 0 ) { numWater++; markRegion( (short)(2*numWater ),i,j); mEdges.add(new Edge(NORTH,i,j)); }

           if( mCubes[i][j] == 1 ) { numLand ++; markRegion( (short)(2*numLand+1),i,j); mEdges.add(new Edge(NORTH,i,j)); }

           }

     // now we potentially need to kick out some Edges - precisely the edges with water inside -

     // which are surrounded by more than one type of land. Otherwise the following does not work:

     //

     // 0 1 0

     // 1 0 1

     // 0 1 0

     //

     // The 'water inside' edges that did not get kicked out by this procedure need to be transformed

     // with Edge(NORTH,row,col) -> Edge(SOUTH,row-1,col) so that later on normals work correctly

     // (Edge always needs to point out from land to water for that)

     int numEdges= mEdges.size();

     short initLand;

     int initCol, initRow;

     boolean kicked;

     Edge e;

     for(i=0; i<numEdges; i++) 

       {

       e = mEdges.get(i);

       initRow= e.row;

       initCol= e.col;

       //android.util.Log.e("CUBES", "checking edge "+debug(e));

       if( mCubes[initRow][initCol]%2==0 )

         {

         kicked = false; 

         initLand = mCubes[initRow-1][initCol];

         do

           {

           e = getNextEdge(e); 

           //android.util.Log.e("CUBES", " next edge "+debug(e));   

           switch(e.side)

             {

             case NORTH: if( initLand!=mCubes[e.row-1][e.col  ] ) kicked=true; break;

             case SOUTH: if( initLand!=mCubes[e.row+1][e.col  ] ) kicked=true; break;

             case WEST:  if( initLand!=mCubes[e.row  ][e.col-1] ) kicked=true; break;

             case EAST:  if( initLand!=mCubes[e.row  ][e.col+1] ) kicked=true; break;

             }

           if( kicked )

             {

             //android.util.Log.e("CUBES", "kicking out edge!");

             mEdges.remove(i);

             i--;

             numEdges--; 

             }

           }

         while( kicked==false && (e.col!=initCol || e.row!=initRow || e.side!=NORTH) );

         if( kicked==false )

           {

           mEdges.set(i, new Edge(SOUTH,e.row-1,e.col)); 

           }

         }

       }

     }

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

// when calling, make sure that newVal != val

   private void markRegion(short newVal, int row, int col)

     {

     short val = mCubes[row][col];

     mCubes[row][col] = newVal;

     if( row>0       && mCubes[row-1][col  ]==val ) markRegion(newVal, row-1, col  );

     if( row<mRows-1 && mCubes[row+1][col  ]==val ) markRegion(newVal, row+1, col  );

     if( col>0       && mCubes[row  ][col-1]==val ) markRegion(newVal, row  , col-1);

     if( col<mCols-1 && mCubes[row  ][col+1]==val ) markRegion(newVal, row  , col+1);

     }

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

     int td,lr; 

     int w  = (col>0                     ) ? (mCubes[row  ][col-1]%2) : 0;

     int n  = (               row>0      ) ? (mCubes[row-1][col  ]%2) : 0;

     int c  =                                (mCubes[row  ][col  ]%2);

     int sw = (col>0       && row<mRows-1) ? (mCubes[row+1][col-1]%2) : 0;

     int ne = (col<mCols-1 && row>0      ) ? (mCubes[row-1][col+1]%2) : 0;

     int e  = (col<mCols-1               ) ? (mCubes[row  ][col+1]%2) : 0;

     int se = (col<mCols-1 && row<mRows-1) ? (mCubes[row+1][col+1]%2) : 0;

     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;

       }

     lr = c+n-w-nw;

     if( td<0 ) td=-1;

     if( td>0 ) td= 1;

     if( lr<0 ) lr=-1;

     if( lr>0 ) lr= 1;

     mNormalX[0] = lr*R;

     mNormalY[0] = td*R;

     td = w+c-sw-s;

     lr = c+s-w-sw;

     if( td<0 ) td=-1;

     if( td>0 ) td= 1;

     if( lr<0 ) lr=-1;

     if( lr>0 ) lr= 1;

     mNormalX[1] = lr*R;

     mNormalY[1] = td*R;

     td = n+ne-c-e;

     lr = e+ne-c-n;

     if( td<0 ) td=-1;

     if( td>0 ) td= 1;

     if( lr<0 ) lr=-1;

     if( lr>0 ) lr= 1;

     mNormalX[2] = lr*R;

     mNormalY[2] = td*R;

     td = c+e-s-se;

     lr = e+se-c-s;

     if( td<0 ) td=-1;

     if( td>0 ) td= 1;

     if( lr<0 ) lr=-1;

     if( lr>0 ) lr= 1;

     mNormalX[3] = lr*R;

     mNormalY[3] = td*R;

     /*

     android.util.Log.d("CUBES", mNormalX[0]+" "+mNormalY[0]);

     android.util.Log.d("CUBES", mNormalX[1]+" "+mNormalY[1]);

     android.util.Log.d("CUBES", mNormalX[2]+" "+mNormalY[2]);

     android.util.Log.d("CUBES", mNormalX[3]+" "+mNormalY[3]);

     }

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

     float x=0,y=0;

     int index=0;

       {

                y = (float)row/mRows;

                index = 0;

                y = (float)(row+1)/mRows;

                index = 1;

                y = (float)row/mRows;

                index = 2;

                y = (float)(row+1)/mRows;

                index = 3;

       }

     position[3*vertex+1] = 0.5f-y;

     position[3*vertex+2] = vectZ;

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

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

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

     texture[2*vertex  ]  = x;

     texture[2*vertex+1]  = y;

     return vertex+1;

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

     {

     short last, current;

     boolean lastBlockIsNE = false;

     boolean currentBlockIsNE;

     float vectZ = front?FRONTZ:BACKZ;

       {

       last =0;

       for(int j=0; j<mCols; j++)

         {

         current = mCubes[i][j];

           {

           if( !seenLand && !front && ((vertex%2==1)^currentBlockIsNE) )

             {

             //android.util.Log.d("CUBES","repeating winding2 vertex");

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

             }

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

                 || (!front && !seenLand)       ) vertex = repeatLast(vertex,position,normal,texture);

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

           seenLand = true;

           lastBlockIsNE = currentBlockIsNE;

         last = current;

         }

       }

     return vertex;

     }

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

   private int repeatLast(int vertex, float[] position, float[] normal, float[] texture)

     {

     //android.util.Log.e("CUBES", "repeating last vertex!");

       {

       position[3*vertex+2] = position[3*vertex-1];

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

       vertex++;     

       }

     return vertex;

     }

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

   private int buildSideGrid(int vertex, float[] position, float[] normal, float[] texture)

     {

       {

       vertex = buildIthSide(mEdges.get(i), vertex, position, normal, texture);  

       } 

     return vertex;

     }

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

   private int buildIthSide(Edge curr, int vertex, float[] position, float[] normal, float[] texture)

     {

     Edge prev; 

     if( curr.side==NORTH ) // water outside

       {

       prev = new Edge(WEST,curr.row,curr.col);

       }

     else                   // land outside; we need to move forward one link because we are going in opposite direction and we need to start from a bend.

       {

       prev = curr;

       curr = new Edge(EAST,curr.row+1,curr.col-1);

       }

     int col = curr.col;

     int row = curr.row;

     int side= curr.side;  

     Edge next = getNextEdge(curr);

     do

       {

       if( prev.side!=curr.side )

         {

         }

       prev = curr;

       curr = next; 

       next = getNextEdge(curr);

       }

     while( curr.col!=col || curr.row!=row || curr.side!=side );

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

     return vertex;

     }

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

   private Edge getNextEdge(Edge curr)

     {

     int col = curr.col;

     int row = curr.row;

     //android.util.Log.e("CUBES", "row="+row+" col="+col+" mRows="+mRows+" mCols="+mCols);