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

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

package org.distorted.library;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

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

/**

 * Create a flat, rectangular grid.

 * <p>

 * Perfect if you just want to display a flat Texture. If you are not planning to apply any VERTEX

 * effects to it, use MeshFlat(1,1), i.e. a Quad. Otherwise, create more vertices for more realistic effects!

 */

public class MeshFlat extends MeshObject

  {

  private int mCols, mRows;

  private int remainingVert;

  private static float[] mBoundingVert = new float[] { -0.5f,+0.5f,0.0f,

                                                       -0.5f,-0.5f,0.0f,

                                                       +0.5f,+0.5f,0.0f,

                                                       +0.5f,-0.5f,0.0f };

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

// Create a flat, full grid.

  private void computeNumberOfVertices(int cols, int rows)

     {

     mRows=rows;

     mCols=cols;

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

       {

       numVertices = 4;

       }

     else

       {

       numVertices = 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="+numVertices+" rows="+mRows+" cols="+mCols);

     remainingVert = numVertices;

     }

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

  private int addVertex(int vertex, float x, float y, float[] attribs)

     {

     remainingVert--;

     attribs[8*vertex  ] = x-0.5f;

     attribs[8*vertex+1] = 0.5f-y;

     attribs[8*vertex+2] = 0;

     attribs[8*vertex+3] = 0.0f;

     attribs[8*vertex+4] = 0.0f;

     attribs[8*vertex+5] = 1.0f;

     attribs[8*vertex+6] = x;

     attribs[8*vertex+7] = 1.0f-y;

     return vertex+1;

     }

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

  private int repeatLast(int vertex, float[] attribs)

     {

     remainingVert--;

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

     if( vertex>0 )

       {

       attribs[8*vertex  ] = attribs[8*vertex-8];

       attribs[8*vertex+1] = attribs[8*vertex-7];

       attribs[8*vertex+2] = attribs[8*vertex-6];

       attribs[8*vertex+3] = attribs[8*vertex-5];

       attribs[8*vertex+4] = attribs[8*vertex-4];

       attribs[8*vertex+5] = attribs[8*vertex-3];

       attribs[8*vertex+6] = attribs[8*vertex-2];

       attribs[8*vertex+7] = attribs[8*vertex-1];

       vertex++;

       }

     return vertex;

     }

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

  private void buildGrid(float[] attribs)

     {

     boolean lastBlockIsNE = false;

     boolean currentBlockIsNE;

     int vertex = 0;

     float x,y;

     final float X = 1.0f/mCols;

     final float Y = 1.0f/mRows;

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

     y = 0.0f;

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

       {

       x = 0.0f;

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

           vertex= addVertex( vertex, x, y+(currentBlockIsNE?0:Y), attribs);

           if( row!=0 && col==0 ) vertex = repeatLast(vertex,attribs);

           if( lastBlockIsNE^currentBlockIsNE)  vertex = repeatLast(vertex,attribs);

           vertex= addVertex( vertex, x, y+(currentBlockIsNE?Y:0), attribs);

           }

         vertex= addVertex( vertex, x+X, y+(currentBlockIsNE?0:Y), attribs);

         vertex= addVertex( vertex, x+X, y+(currentBlockIsNE?Y:0), attribs);

         lastBlockIsNE = currentBlockIsNE;

         x+=X;

         }

       y+=Y;

       }

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

     }

*/

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

  float[] getBoundingVertices()

     {

     return mBoundingVert;

     }

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

// 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 MeshFlat(int cols, int rows)

    {

    super(0.0f);

    computeNumberOfVertices(cols,rows);

    float[] attribs= new float[(POSITION_DATA_SIZE+NORMAL_DATA_SIZE+TEX_DATA_SIZE)*numVertices];

    buildGrid(attribs);

    //android.util.Log.e("MeshFlat", "dataLen="+numVertices);

    //android.util.Log.d("MeshFlat", "attribs: "+debug(attribs,8) );

    if( remainingVert!=0 )

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

    mVertAttribs = ByteBuffer.allocateDirect(numVertices*VERTSIZE).order(ByteOrder.nativeOrder()).asFloatBuffer();

    mVertAttribs.put(attribs).position(0);

    }

 }