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;

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

class DistortedBitmapGrid extends DistortedObjectGrid

  {

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

  DistortedBitmapGrid(int xLength, int yLength)

    {

    dataLength = 2*xLength*(yLength-1)+2*(yLength-2); // (yLength-1) strips, 2*xLength triangles in each, plus 2 degenerate triangles per each of (yLength-2) joins 

    final short[] indexData = new short[dataLength];

    int offset=0;    

    for(int y=0; y<yLength-1; y++) 

      {

      if (y>0) indexData[offset++] = (short) (y*xLength); // Degenerate begin: repeat first vertex

      for (int x = 0; x < xLength; x++) 

        {

        indexData[offset++] = (short) (( y   *xLength)+x);

        indexData[offset++] = (short) (((y+1)*xLength)+x);

        }

      if (y<yLength-2) indexData[offset++] = (short) (((y+1)*xLength) + (xLength-1)); // Degenerate end: repeat last vertex

      }

    // for(int g=0; g<dataLength; g++) Log.e(TAG_BACKGROUND, "index["+g+"]="+indexData[g]);

    float[] bufferData= new float[COLOR_DATA_SIZE*dataLength];

    offset=0;

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

      {

      bufferData[offset++] = 1.0f; // r

      bufferData[offset++] = 1.0f; // g

      bufferData[offset++] = 1.0f; // b

      bufferData[offset++] = 1.0f; // a

      }

    mGridColors = ByteBuffer.allocateDirect(COLOR_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();                                                        

    mGridColors.put(bufferData).position(0); 

    bufferData = new float[NORMAL_DATA_SIZE*dataLength];

    offset=0;

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

      {

      bufferData[offset++] = 0.0f; // x

      bufferData[offset++] = 0.0f; // y

      bufferData[offset++] = 1.0f; // z

      }

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

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

    float tmpx,tmpy,tmpz;

    bufferData = new float[TEX_DATA_SIZE*dataLength];

    offset=0;

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

      {

      tmpx = ((float)(indexData[offset/2]%xLength))/(xLength-1);

      tmpy = ((float)(indexData[offset/2]/xLength))/(yLength-1);

      bufferData[offset++] = tmpx; // s=x

      bufferData[offset++] = tmpy; // t=y

      }

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

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

    //for(int g=0; g<dataLength; g++) Log.e(TAG_BACKGROUND, "tex["+g+"]=("+bufferData[2*g]+","+bufferData[2*g+1]+")");

    //Log.e(TAG, "regWidth="+(2*mRegW)+" regHeight="+(2*mRegH)+" xLength="+xLength+" yLength="+yLength);

    offset=0;

    bufferData= new float[POSITION_DATA_SIZE*dataLength];

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

      {

      tmpx = ((float)(indexData[offset/3]%xLength))/(xLength-1);

      tmpy = ((float)(indexData[offset/3]/xLength))/(yLength-1);

      tmpz = 0;

      bufferData[offset++] = (tmpx-0.5f); // x

      bufferData[offset++] = (0.5f-tmpy); // y

      bufferData[offset++] =        tmpz; // z

      }

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

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

    //for(int g=0; g<dataLength; g++) android.util.Log.e("BACKGROUND", "pos["+g+"]=("+bufferData[3*g]+","+bufferData[3*g+1]+")");

    }

  };

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