Distorted Android

   * When creating an instance of a DistortedNode from another instance, clone the children Nodes.

    DistortedNode.reset();

    DistortedNode.release();

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

// 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/>.                            //

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

package org.distorted.library;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

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

public class DistortedBitmapGrid extends DistortedObjectGrid

  {

  private int mCols, mRows;

  private int remainingVert;

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

// Create a flat, full grid. cols and rows is guaranteed (by DistortedBitmap constructor)

// to be in 1,2,...,256.

   private void computeNumberOfVertices(int cols, int rows)

     {

     mRows=rows;

     mCols=cols;

     if( cols==1 && rows==1 )

       {

       dataLength = 4;

       }

     else

       {

       dataLength = 2*( mRows*mCols +2*mRows - 1) +2*(mCols>=2 ? mRows:0) +

                    (mCols>=2 && mRows>=2 ? 2*mRows-2 : 1);

       }

     //android.util.Log.e("BITMAP","vertices="+dataLength+" rows="+mRows+" cols="+mCols);

     remainingVert = dataLength;

     }

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

   private int addVertex(int vertex, int col, int row, float[] position, float[] normal, float[] texture)

     {

     remainingVert--;

     float x= (float)col/mCols;

     float y= (float)row/mRows;

     position[3*vertex  ] = x-0.5f;

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

     position[3*vertex+2] = 0;

     texture[2*vertex  ]  = x;

     texture[2*vertex+1]  = 1.0f-y;

     normal[3*vertex  ]   = 0.0f;

     normal[3*vertex+1]   = 0.0f;

     normal[3*vertex+2]   = 1.0f;

     return vertex+1;

     }

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

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

     {

     remainingVert--;

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

     if( vertex>0 )

       {

       position[3*vertex  ] = position[3*vertex-3];

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

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

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

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

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

       texture[2*vertex  ]  = texture[2*vertex-2];

       texture[2*vertex+1]  = texture[2*vertex-1];

       vertex++;

       }

     return vertex;

     }

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

   private void buildGrid(float[] position, float[] normal, float[] texture)

     {

     boolean lastBlockIsNE = false;

     boolean currentBlockIsNE;

     int vertex = 0;

     //android.util.Log.d("BITMAP", "buildGrid");

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

       {

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

         {

         currentBlockIsNE = (2*row<=mRows-1)^(2*col<=mCols-1);

         if( col==0 || (lastBlockIsNE^currentBlockIsNE) )

           {

           if( row!=0 && col==0 ) vertex = repeatLast(vertex,position,normal,texture);

           vertex= addVertex( vertex, col, row+(currentBlockIsNE?0:1), position, normal, texture);

           if( row!=0 && col==0 ) vertex = repeatLast(vertex,position,normal,texture);

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

           vertex= addVertex( vertex, col, row+(currentBlockIsNE?1:0), position, normal, texture);

           }

         vertex= addVertex( vertex, col+1, row+(currentBlockIsNE?0:1), position, normal, texture);

         vertex= addVertex( vertex, col+1, row+(currentBlockIsNE?1:0), position, normal, texture);

         lastBlockIsNE = currentBlockIsNE;

         }

       }

     //android.util.Log.d("BITMAP", "buildGrid done");

     }

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

/*

   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;

     }

*/

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

// PUBLIC API

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

/**

 * Creates the underlying grid of vertices, normals and texture coords.

 *

 * @param cols Number of columns in the grid.

 * @param rows Number of rows in the grid.

 */

   public DistortedBitmapGrid(int cols, int rows)

      {

      computeNumberOfVertices(cols,rows);

      float[] positionData= new float[POSITION_DATA_SIZE*dataLength];

      float[] normalData  = new float[NORMAL_DATA_SIZE  *dataLength];

      float[] textureData = new float[TEX_DATA_SIZE     *dataLength];

      buildGrid(positionData,normalData,textureData);

      //android.util.Log.e("CUBES","dataLen="+dataLength);

      //android.util.Log.d("CUBES", "position: "+debug(positionData,3) );

      //android.util.Log.d("CUBES", "normal: "  +debug(  normalData,3) );

      //android.util.Log.d("CUBES", "texture: " +debug( textureData,2) );

      if( remainingVert!=0 )

        android.util.Log.d("BITMAP", "remainingVert " +remainingVert );

      mGridPositions = ByteBuffer.allocateDirect(POSITION_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();

      mGridPositions.put(positionData).position(0);

      mGridNormals = ByteBuffer.allocateDirect(NORMAL_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();

      mGridNormals.put(normalData).position(0);

      mGridTexture = ByteBuffer.allocateDirect(TEX_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();

      mGridTexture.put(textureData).position(0);

      }

  }

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

// 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/>.                            //

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

package org.distorted.library;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.util.ArrayList;

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

public class DistortedCubesGrid extends DistortedObjectGrid

   {

   private static final float R = 0.0f;//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 boolean BACK  = true;

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

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

   private class Edge

     {

     final int side; 

     final int row;

     final int col;

     Edge(int s, int r, int c)

       {

       side= s; 

       row = r;

       col = c;

       }

     }

   private int mCols, mRows;

   private short[][] mCubes;

   private ArrayList<Edge> mEdges = new ArrayList<>();

   private int remainingVert;

   private int mSideBends;

   private int mEdgeNum;

   private int mSideWalls;

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

// 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 ( (2*row<mRows)^(2*col<mCols) );

     }

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

// return the number of vertices our grid will contain

   private int computeDataLength(boolean frontOnly)

      {

      int frontWalls=0, frontSegments=0, triangleShifts=0, windingShifts=0;

      int shiftCol = (mCols-1)/2;

      boolean lastBlockIsNE=false;

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

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

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

        {

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

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

          {

          if( mCubes[row][col]%2 == 1 )  // land

            {

            thisBlockIsNE = isNE(row,col);

            if( thisBlockIsNE^lastBlockIsNE ) windingShifts++;

            lastBlockIsNE = thisBlockIsNE;

            frontWalls++;

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

            }

          }

        }

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

      int sideVert  = 2*( mSideWalls + mSideBends + mEdgeNum -1);

      int firstWinding= (!frontOnly && (frontVert+1)%2==1 ) ? 1:0;

      int dataL = frontOnly ? frontVert : (frontVert+1) +firstWinding+ (1+sideVert+1) + (1+frontVert);

/*

      android.util.Log.e("CUBES","triangleShifts="+triangleShifts+" windingShifts="+windingShifts+" winding1="+firstWinding+" frontVert="+frontVert+" sideVert="+sideVert);

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

*/

      return dataL<0 ? 0:dataL;

      }

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

/*

   private static String debug(short[] val)

     {

     String ret="";j

     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;

     }   

*/

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

// desc is guaranteed to be padded with 0s in the end (DistortedCubes constructor does it)

   private void prepareDataStructures(int cols, String desc, boolean frontOnly)

     {

     mRows     =0;

     mCols     =0;

     dataLength=0;

     if( cols>0 && desc.contains("1") )

       {

       mCols = cols;

       mRows = desc.length()/cols;

       mCubes = new short[mRows][mCols];

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

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

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

       markRegions();

       dataLength = computeDataLength(frontOnly);

       remainingVert = dataLength;

       }

     }

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

// full grid

   private void prepareDataStructures(int cols, int rows, boolean frontOnly)

     {

     mRows     =rows;

     mCols     =cols;

     dataLength=   0;

     if( cols>0 && rows>0 )

       {

       mCubes = new short[mRows][mCols];

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

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

           mCubes[i][j] = (short)1;

       markRegions();

       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

// will start building the side walls of each connected block of land (and sides of holes of water

// inside). Each Edge needs to point from Land to Water (thus the '(SOUTH,i-1,j)' below) - otherwise

// later on setting up normal vectors wouldn't work.

   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(SOUTH,i-1,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 . Otherwise the following does not work:

     //

     // 0 1 0

     // 1 0 1

     // 0 1 0

     mEdgeNum= mEdges.size();

     int initCol, initRow, initSide, lastSide;

     Edge e1,e2;

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

       {

       e1 = mEdges.get(i);

       initRow= e1.row;

       initCol= e1.col;

       initSide=e1.side;

       do

         {

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

         mSideWalls++;

         if( e1.side==NORTH || e1.side==SOUTH )

           {

           for(j=i+1;j<mEdgeNum;j++)

             {

             e2 = mEdges.get(j);

             if( e2.side==e1.side && e2.row==e1.row && e2.col==e1.col )

               {

               mEdges.remove(j);

               mEdgeNum--;

               j--;

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

               }

             }

           }

         lastSide = e1.side;

         e1 = getNextEdge(e1);

         if( e1.side!=lastSide ) mSideBends++;

         }

       while( e1.col!=initCol || e1.row!=initRow || e1.side!=initSide );

       }

     }

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

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

     }

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

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

     {

     int td,lr; 

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

     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 s  = (               row<mRows-1) ? (mCubes[row+1][col  ]%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;

       }

     td = nw+n-w-c;

     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", "row="+row+" col="+col);

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

     */

     }

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

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

     {

     remainingVert--;

     float x = (float)col/mCols;

     float y = (float)row/mRows;

     position[3*vertex  ] = x-0.5f;

     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]  = 1.0f-y;

     return vertex+1;

     }

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

   private int buildFrontBackGrid(boolean front, int vertex, float[] position, float[] normal, float[] texture)

     {

     short last, current;

     boolean seenLand=false;

     boolean lastBlockIsNE = false;

     boolean currentBlockIsNE;

     float vectZ = front?FRONTZ:BACKZ;

     //android.util.Log.d("CUBES", "buildFrontBack");

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

       {

       last =0;

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

         {

         current = mCubes[row][col];

         if( current%2 == 1 )

           {

           currentBlockIsNE = isNE(row,col);

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

             {

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

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

             }

           createNormals(front,row,col);

           if( currentBlockIsNE )

             {

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

               {

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

               vertex= addFrontVertex( vertex, 0, vectZ, col, row, position, normal, texture);

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

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

               vertex= addFrontVertex( vertex, 1, vectZ, col, row+1, position, normal, texture);

               }

             vertex= addFrontVertex( vertex, 2, vectZ, col+1, row, position, normal, texture);

             vertex= addFrontVertex( vertex, 3, vectZ, col+1, row+1, position, normal, texture);

             }

           else

             {

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

               {

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

               vertex= addFrontVertex( vertex, 1, vectZ, col, row+1, position, normal, texture);

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

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

               vertex= addFrontVertex( vertex, 0, vectZ, col, row, position, normal, texture);

               }

             vertex= addFrontVertex( vertex, 3, vectZ, col+1, row+1, position, normal, texture);

             vertex= addFrontVertex( vertex, 2, vectZ, col+1, row  , 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!");

     if( vertex>0 )

       {

       remainingVert--;

       position[3*vertex  ] = position[3*vertex-3];

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

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

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

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

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

       texture[2*vertex  ]  = texture[2*vertex-2];

       texture[2*vertex+1]  = texture[2*vertex-1];

       vertex++;     

       }

     return vertex;

     }

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

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

     {

     //android.util.Log.d("CUBES", "buildSide");

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

       {

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

     addSideVertex(curr,BACK,LOWER,prev.side,vertex,position,normal,texture);

     vertex++;

     do

       {

       if( prev.side!=curr.side )

         {

         addSideVertex(curr,BACK,LOWER,prev.side,vertex,position,normal,texture);

         vertex++;

         addSideVertex(curr,BACK,UPPER,prev.side,vertex,position,normal,texture);

         vertex++;

         }

       addSideVertex(curr,FRONT,LOWER,next.side,vertex,position,normal,texture);

       vertex++;

       addSideVertex(curr,FRONT,UPPER,next.side,vertex,position,normal,texture);

       vertex++;

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

     switch(curr.side) 

       {

       case NORTH: if( col==mCols-1 ) 

                     return new Edge(EAST,row,col);

                   if( row>0 && mCubes[row-1][col+1]==mCubes[row][col] )

                     return new Edge(WEST,row-1,col+1);

                   if( mCubes[row][col+1]==mCubes[row][col] )

                     return new Edge(NORTH,row,col+1);

                   else  

                     return new Edge(EAST,row,col);

       case SOUTH: if( col==0 ) 

                     return new Edge(WEST,row,col);

                   if( (row<mRows-1) && mCubes[row+1][col-1]==mCubes[row][col] )

                     return new Edge(EAST,row+1,col-1); 

                   if( mCubes[row][col-1]==mCubes[row][col] )

                     return new Edge(SOUTH,row,col-1);

                   else

                     return new Edge(WEST,row,col); 

       case EAST : if( row==mRows-1 ) 

                     return new Edge(SOUTH,row,col);

                   if( (col<mCols-1) && mCubes[row+1][col+1]==mCubes[row][col] )

                     return new Edge(NORTH,row+1,col+1);

                   if( mCubes[row+1][col]==mCubes[row][col] )

                     return new Edge(EAST,row+1,col);

                   else 

                     return new Edge(SOUTH,row,col);

       default   : if( row==0 )

                     return new Edge(NORTH,row,col);

                   if( col>0 && mCubes[row-1][col-1]==mCubes[row][col] )

                     return new Edge(SOUTH,row-1,col-1);

                   if( mCubes[row-1][col]==mCubes[row][col] )

                     return new Edge(WEST,row-1,col);

                   else

                     return new Edge(NORTH,row,col);     

       }

     }

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

   private void addSideVertex(Edge curr, boolean back, boolean lower,int side, int vertex, float[] position, float[] normal, float[] texture)

     {

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

                   position[3*vertex  ] = x - 0.5f;

                   position[3*vertex+1] = 0.5f - (float)curr.row/mRows;

                   position[3*vertex+2] = lower ? BACKZ : FRONTZ;

                   normal[3*vertex  ]   = side==NORTH ? 0.0f : (side==WEST?-R:R);

                   normal[3*vertex+1]   = 1.0f;

                   normal[3*vertex+2]   = lower ? -R:R;

                   texture[2*vertex  ]  = x;

                   texture[2*vertex+1]  = 1.0f-(float)(lower? (curr.row-1):(curr.row  ))/mRows;

                   break;

       case SOUTH: x = (float)(back ? (curr.col+1):(curr.col  ))/mCols;

                   position[3*vertex  ] = x - 0.5f;

                   position[3*vertex+1] = 0.5f - (float)(curr.row+1)/mRows;

                   position[3*vertex+2] = lower ? BACKZ : FRONTZ;  

                   normal[3*vertex  ]   = side==SOUTH ? 0.0f: (side==EAST?-R:R);

                   normal[3*vertex+1]   =-1.0f;

                   normal[3*vertex+2]   = lower ? -R:R;

                   texture[2*vertex  ]  = x;

                   texture[2*vertex+1]  = 1.0f-(float)(lower? (curr.row+2):(curr.row+1))/mRows;

                   break;

       case WEST : y = (float)(back  ? (curr.row+1):(curr.row))/mRows;

                   position[3*vertex  ] = (float)curr.col/mCols -0.5f;

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

                   position[3*vertex+2] = lower ? BACKZ : FRONTZ;

                   normal[3*vertex  ]   =-1.0f;

                   normal[3*vertex+1]   = side==WEST ? 0.0f : (side==NORTH?-R:R);

                   normal[3*vertex+2]   = lower ? -R:R;

                   texture[2*vertex  ]  = (float)(lower ? (curr.col-1):(curr.col  ))/mCols;

                   texture[2*vertex+1]  = 1.0f - y;

                   break;

       case EAST : y = (float)(back  ? (curr.row):(curr.row+1))/mRows;

                   position[3*vertex  ] = (float)(curr.col+1)/mCols -0.5f;

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

                   position[3*vertex+2] = lower ? BACKZ : FRONTZ;

                   normal[3*vertex  ]   = 1.0f;

                   normal[3*vertex+1]   = side==EAST ? 0.0f : (side==SOUTH?-R:R);

                   normal[3*vertex+2]   = lower ? -R:R; 

                   texture[2*vertex  ]  = (float)(lower ? (curr.col+2):(curr.col+1))/mCols;

                   texture[2*vertex+1]  = 1.0f - y;

                   break;

       }

     if(texture[2*vertex  ]>1.0f) texture[2*vertex  ] =2.0f-texture[2*vertex  ];

     if(texture[2*vertex  ]<0.0f) texture[2*vertex  ] =    -texture[2*vertex  ];

     if(texture[2*vertex+1]>1.0f) texture[2*vertex+1] =2.0f-texture[2*vertex+1];

     if(texture[2*vertex+1]<0.0f) texture[2*vertex+1] =    -texture[2*vertex+1];

     }

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

   private void build(boolean frontOnly)

     {

     int numVertices=0;

     float[] positionData= new float[POSITION_DATA_SIZE*dataLength];

     float[] normalData  = new float[NORMAL_DATA_SIZE  *dataLength];

     float[] textureData = new float[TEX_DATA_SIZE     *dataLength];

     //android.util.Log.d("CUBES","building front grid...");

     numVertices = buildFrontBackGrid(true, numVertices,positionData,normalData,textureData);

     if( !frontOnly )

       {

       numVertices = repeatLast(numVertices,positionData,normalData,textureData);

       if( numVertices%2==1 )

         {

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

         numVertices = repeatLast(numVertices,positionData,normalData,textureData);

         }

       //android.util.Log.d("CUBES","building side grid...");

       numVertices = buildSideGrid (numVertices,positionData,normalData,textureData);

       //android.util.Log.d("CUBES","building back grid...");

       numVertices = buildFrontBackGrid (false,numVertices,positionData,normalData,textureData);

       }

     /*

     android.util.Log.e("CUBES","dataLen="+dataLength+" vertex="+numVertices);

     android.util.Log.d("CUBES", "position: "+debug(positionData,3) );

     android.util.Log.d("CUBES", "normal: "  +debug(  normalData,3) );

     android.util.Log.d("CUBES", "texture: " +debug( textureData,2) );

     */

     mEdges.clear();

     mEdges = null;

     mCubes = null;

     if( remainingVert!=0 )

       android.util.Log.d("CUBES", "remainingVert " +remainingVert );

     mGridPositions = ByteBuffer.allocateDirect(POSITION_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();

     mGridPositions.put(positionData).position(0);

     mGridNormals = ByteBuffer.allocateDirect(NORMAL_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();

     mGridNormals.put(normalData).position(0);

     mGridTexture = ByteBuffer.allocateDirect(TEX_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();

     mGridTexture.put(textureData).position(0);

     }

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

// PUBLIC API

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

/**

 * Creates the underlying grid of vertices, normals, texture coords and colors.

 *    

 * @param cols      Integer helping to parse the next parameter.

 * @param desc      String describing the subset of a MxNx1 cuboid that we want to create.

 *                  Its MxN characters - all 0 or 1 - decide of appropriate field is taken or not.

 *                  <p></p>

 *                  <p>

 *                  <pre>

 *                  For example, (cols=2, desc="111010") describes the following shape:

 *

 *                  XX

 *                  X

 *                  X

 *

 *                  whereas (cols=2,desc="110001") describes

 *

 *                  XX

 *

 *                   X

 *                  </pre>

 *                  </p>

 * @param frontOnly Only create the front wall or side and back as well?

 */

   public DistortedCubesGrid(int cols, String desc, boolean frontOnly)

      {

      prepareDataStructures(cols,desc,frontOnly);

      build(frontOnly);

      }

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

/**

 * Creates a full, hole-less underlying grid of vertices, normals, texture coords and colors.

 *

 * @param cols      Number of columns.

 * @param rows      Number of rows.

 * @param frontOnly Only create the front wall or side and back as well?

 */

   public DistortedCubesGrid(int cols, int rows, boolean frontOnly)

      {

      prepareDataStructures(cols,rows,frontOnly);

      build(frontOnly);

      }

   }

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

 * FBOs (used by the DistortedNode, but also can be used by external users of the library)

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

// 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/>.                            //

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

package org.distorted.library;

import java.util.ArrayList;

import java.util.HashMap;

import android.opengl.GLES20;

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

/**

 * Class which represents a Node in a Tree of DistortedObjects.

 *  

 * Having organized a set of DistortedObjects into a Tree, we can then render any Node to any Framebuffer.

 * That recursively renders the Object held in the Node and all its children, along with whatever effects

 * each one of them has. 

 */

public class DistortedNode 

  {

  private static HashMap<ArrayList<Long>,NodeData> mMapNodeID = new HashMap<>();

  private static long mNextNodeID =0;

  private DistortedObjectGrid mGrid;

  private DistortedObject mObject;

  private NodeData mData;

  private DistortedNode mParent;

  private ArrayList<DistortedNode> mChildren;

  private int[] mNumChildren;  // ==mChildren.length(), but we only create mChildren if the first one gets added

  private class NodeData

    {

    long ID;

    int numPointingNodes;

    DistortedFramebuffer mDF;

    boolean mRendered;

    NodeData(long id)

      {

      ID              = id;

      numPointingNodes= 1;

      mDF             = null;

      mRendered       = false;

      }

    }

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

  static void release()

    {

    mNextNodeID = 0;

    mMapNodeID.clear();

    }

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

  private void markRecursive()

    {

    mData.mRendered = false;

    synchronized(this)

      {

      for(int i=0; i<mNumChildren[0]; i++) mChildren.get(i).markRecursive();

      }

    }

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

  private void drawRecursive(long currTime, DistortedFramebuffer df)

    {

    if( mNumChildren[0]<=0 )

      {

      GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mObject.mTextureDataH[0]);

      }

    else

      {

      if( !mData.mRendered )

        {

        mData.mRendered = true;

        mData.mDF.setAsOutput();

        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

        GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

        if( mObject.mBitmapSet[0] )

          {

          GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mObject.mTextureDataH[0]);

          mObject.drawNoEffectsPriv(mGrid, mData.mDF);

          }

        synchronized(this)

          {

          for(int i=0; i<mNumChildren[0]; i++)

            {

            mChildren.get(i).drawRecursive(currTime, mData.mDF);

            }

          }

        }

      df.setAsOutput();

      mData.mDF.setAsInput();

      }

    mObject.drawPriv(currTime, mGrid, df);

    }

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

// tree isomorphism

  private void RecomputeNodeID(ArrayList<Long> prev)

    {

    ArrayList<Long> curr = generateIDList();

    if( mParent==null )

      {

      adjustNodeData(prev,curr);

      }

    else

      {

      ArrayList<Long> parentPrev = mParent.generateIDList();

      adjustNodeData(prev,curr);

      mParent.RecomputeNodeID(parentPrev);

      }

    }

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

  private ArrayList<Long> generateIDList()

    {

    ArrayList<Long> ret = new ArrayList<>();

    ret.add( mNumChildren[0]>0 ? mObject.getBitmapID() : mObject.getID() );

    DistortedNode node;

    for(int i=0; i<mNumChildren[0]; i++)

      {

      node = mChildren.get(i);

      ret.add(node.mData.ID);

      }

    return ret;

    }

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

  private void adjustNodeData(ArrayList<Long> oldList, ArrayList<Long> newList)

    {

    boolean otherNodesPoint = (mData.numPointingNodes>1);

    if( otherNodesPoint ) mData.numPointingNodes--;

    else                  mMapNodeID.remove(oldList);

    NodeData newData = mMapNodeID.get(newList);

    if( newData==null )

      {

      if( otherNodesPoint )  mData = new NodeData(++mNextNodeID);

      else                   mData.ID = ++mNextNodeID;  // numPointingNodes must be 1 already

      if( newList.size()>1 )

        {

        if( mData.mDF==null )

          mData.mDF = new DistortedFramebuffer(mObject.getWidth(), mObject.getHeight());

        }

      else

        {

        if( mData.mDF!=null )

          {

          mData.mDF.markForDeletion();

          mData.mDF = null;

          }

        else

          {

          android.util.Log.e("DistortedNode", "adjustNodeData: impossible situation??");

          }

        }

      mMapNodeID.put(newList, mData);

      }

    else

      {

      newData.numPointingNodes++;

      mData = newData;

      }

    }

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

// this will be called on startup and every time OpenGL context has been lost

// also call this from the constructor if the OpenGL context has been created already.

  static void reset()

    {

    NodeData tmp;   

    for(ArrayList<Long> key: mMapNodeID.keySet())

      {

      tmp = mMapNodeID.get(key);

      if( tmp.mDF != null )

        {

    	  tmp.mDF.reset();

        tmp.mRendered  = false;

        }

      }

    }

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

// Debug - print all the Node IDs

/*

  void debug(int depth)

    {

    String tmp="";

    int i;

    for(i=0; i<depth; i++) tmp +="   ";

    tmp += (""+mData.ID);

    android.util.Log.e("node", tmp);

    for(i=0; i<mNumChildren[0]; i++)

      mChildren.get(i).debug(depth+1);

    }

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

// Debug - print contents of the HashMap

  static void debugMap()

    {

    NodeData tmp;

    for(ArrayList<Long> key: mMapNodeID.keySet())

      {

      tmp = mMapNodeID.get(key);

      android.util.Log.e("NODE", "key="+key+" NodeID: "+tmp.ID);

      }

    }

*/

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

// PUBLIC API

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

/**

 * Constructs new Node of the Tree.

 *     

 * @param obj DistortedObject to put into the new Node.

 */

  public DistortedNode(DistortedObject obj, DistortedObjectGrid grid)

    {

    mObject = obj;

    mGrid   = grid;

    mParent = null;

    mChildren = null;

    mNumChildren = new int[1];

    mNumChildren[0] = 0;

    ArrayList<Long> list = new ArrayList<>();

    list.add(obj.getID());

    mData = mMapNodeID.get(list);

    if( mData!=null )

      {

      mData.numPointingNodes++;

      }

    else

      {

      mData = new NodeData(++mNextNodeID);   

      mMapNodeID.put(list, mData);  

      }

    }

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

/**

 * Copy-constructs new Node of the Tree from another Node.

 *     

 * @param node The DistortedNode to copy data from.

 * @param flags bit field composed of a subset of the following:

 *        {@link Distorted#CLONE_BITMAP},  {@link Distorted#CLONE_MATRIX}, {@link Distorted#CLONE_VERTEX},

 *        {@link Distorted#CLONE_FRAGMENT} and {@link Distorted#CLONE_CHILDREN}.

 *        For example flags = CLONE_BITMAP | CLONE_CHILDREN.

 */

  public DistortedNode(DistortedNode node, int flags)

    {

    mParent = null;

    mObject = new DistortedObject(node.mObject,flags);

    mGrid   = node.mGrid;

    if( (flags & Distorted.CLONE_CHILDREN) != 0 )

      {

      mChildren = node.mChildren;

      mNumChildren = node.mNumChildren;

      }

    else

      {

      mChildren = null;

      mNumChildren = new int[1];

      mNumChildren[0] = 0;

      }

    ArrayList<Long> list = generateIDList();

    mData = mMapNodeID.get(list);

    if( mData!=null )

      {

      mData.numPointingNodes++;

      }

    else

      {

      mData = new NodeData(++mNextNodeID);   

      mMapNodeID.put(list, mData);

      }

    }

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

/**

 * Adds a new child to the last position in the list of our Node's children.

 * 

 * @param node The new Node to add.

 */

  public synchronized void attach(DistortedNode node)

    {

    ArrayList<Long> prev = generateIDList(); 

    if( mChildren==null ) mChildren = new ArrayList<>(2);

    node.mParent = this;

    mChildren.add(node);

    mNumChildren[0]++;

    RecomputeNodeID(prev);

    }

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

/**

 * Adds a new child to the last position in the list of our Node's children.

 * 

 * @param obj DistortedObject to initialize our child Node with.

 * @return the newly constructed child Node, or null if we couldn't allocate resources.

 */

  public synchronized DistortedNode attach(DistortedObject obj, DistortedObjectGrid grid)

    {

    ArrayList<Long> prev = generateIDList(); 

    if( mChildren==null ) mChildren = new ArrayList<>(2);

    DistortedNode node = new DistortedNode(obj,grid);

    node.mParent = this;

    mChildren.add(node);

    mNumChildren[0]++;

    RecomputeNodeID(prev);

    return node;

    }

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

/**

 * Removes the first occurrence of a specified child from the list of children of our Node.

 * 

 * @param node The Node to remove.

 * @return <code>true</code> if the child was successfully removed.

 */

  public synchronized boolean detach(DistortedNode node)

    {

    if( mNumChildren[0]>0 )

      {

      ArrayList<Long> prev = generateIDList();  

      if( mChildren.remove(node) )

        {

        node.mParent = null;  

        mNumChildren[0]--;

        RecomputeNodeID(prev);

        return true;

        }

      }

    return false;

    }

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

/**

 * Removes the first occurrence of a specified child from the list of children of our Node.

 * 

 * @param obj DistortedObject to remove.

 * @return <code>true</code> if the child was successfully removed.

 */

  public synchronized boolean detach(DistortedObject obj)

    {

    long id = obj.getID();

    DistortedNode node;

    for(int i=0; i<mNumChildren[0]; i++)

      {

      node = mChildren.get(i);

      if( node.mObject.getID()==id )

        {

        ArrayList<Long> prev = generateIDList();   

        node.mParent = null;  

        mChildren.remove(i);

        mNumChildren[0]--;

        RecomputeNodeID(prev);

        return true;

        }

      }

    return false;

    }

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

/**

 * Removes all children Nodes.

 */

  public synchronized void detachAll()

    {

    for(int i=0; i<mNumChildren[0]; i++)

      {

      mChildren.get(i).mParent = null;

      }

    if( mNumChildren[0]>0 )

      {

      ArrayList<Long> prev = generateIDList();  

      mNumChildren[0] = 0;

      mChildren.clear();

      RecomputeNodeID(prev);

      }

    }