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;

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

  private int remainingVert;

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

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

     {

     mCols=cols;

       {

       dataLength = 4;

       }

     else

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

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

     {

     remainingVert--;

     float y= (float)row/mRows;

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

     position[3*vertex+2] = 0;

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

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

     }

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

     {

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

       }

     }

   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;

     }

*/

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

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

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

 */

      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.d("CUBES", "position: "+debug(positionData,3) );

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

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

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