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.mesh;

import org.distorted.library.type.Static4D;

import java.util.ArrayList;

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

/**

 * Create a 3D grid composed of Cubes.

 * <p>

 * Any subset of a MxNx1 cuboid is possible. (repeated arbitrary number of times into Z-dir)

 */

public class MeshCubes extends MeshBase

   {

   private static final float R = 0.0f;//0.2f;

   private static final int FRONT = 0;

   private static final int BACK  = 1;

   private static final int LEFT  = 2;

   private static final int RIGHT = 3;

   private static final int TOP   = 4;

   private static final int BOTTOM= 5;

   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 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 float[] mTexMappingX,mTexMappingY, mTexMappingW, mTexMappingH;

   private int mCols, mRows, mSlices;

   private int[][] mCubes;

   private byte[][] mInflateX, mInflateY;

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

   private int currVert;

   private int numVertices;

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

     }

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

// fill per-side texture mappings. Default: all 6 sides map to the whole texture.

// Each Static4D describes the way its side will map. Format:

//

// 1st float: X-coord of the texture point that our top-left corner of the side maps to

// 2nd float: Y-coord of the texture point that our top-left corner of the side maps to

// 3rd float: X-coord of the texture point that our bot-right corner of the side maps to

// 4th float: Y-coord of the texture point that our bot-right corner of the side maps to

   private void fillTexMappings(Static4D front, Static4D back, Static4D left, Static4D right, Static4D top, Static4D bottom)

     {

     if( mTexMappingX==null ) mTexMappingX = new float[6];

     if( mTexMappingY==null ) mTexMappingY = new float[6];

     if( mTexMappingW==null ) mTexMappingW = new float[6];

     if( mTexMappingH==null ) mTexMappingH = new float[6];

     mTexMappingX[FRONT]  = front.get0();

     mTexMappingY[FRONT]  = front.get1();

     mTexMappingW[FRONT]  = front.get2() - front.get0();

     mTexMappingH[FRONT]  = front.get3() - front.get1();

     mTexMappingX[BACK]   = back.get0();

     mTexMappingY[BACK]   = back.get1();

     mTexMappingW[BACK]   = back.get2() - back.get0();

     mTexMappingH[BACK]   = back.get3() - back.get1();

     mTexMappingX[LEFT]   = left.get0();

     mTexMappingY[LEFT]   = left.get1();

     mTexMappingW[LEFT]   = left.get2() - left.get0();

     mTexMappingH[LEFT]   = left.get3() - left.get1();

     mTexMappingX[RIGHT]  = right.get0();

     mTexMappingY[RIGHT]  = right.get1();

     mTexMappingW[RIGHT]  = right.get2() - right.get0();

     mTexMappingH[RIGHT]  = right.get3() - right.get1();

     mTexMappingX[TOP]    = top.get0();

     mTexMappingY[TOP]    = top.get1();

     mTexMappingW[TOP]    = top.get2() - top.get0();

     mTexMappingH[TOP]    = top.get3() - top.get1();

     mTexMappingX[BOTTOM] = bottom.get0();

     mTexMappingY[BOTTOM] = bottom.get1();

     mTexMappingW[BOTTOM] = bottom.get2() - bottom.get0();

     mTexMappingH[BOTTOM] = bottom.get3() - bottom.get1();

     }

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

// return the number of vertices our grid will contain

   private int computeDataLength()

      {

      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 sideVertOneSlice= 2*( mSideWalls + mSideBends + mEdgeNum -1);

      int sideVert        = 2*(mSlices-1) + mSlices*sideVertOneSlice;

      int firstWinding    = (mSlices>0 && (frontVert+1)%2==1 ) ? 1:0;

      int dataL           = mSlices==0 ? 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="";

     float v;

     boolean neg;

     int mod;

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

        {

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

        mod = i%stop;

        if( mod==0 || mod==3 || mod==6 ) ret+=" (";

        v = val[i];

        if( v==-0.0f ) v=0.0f;

        neg = v<0;

        v = (v<0 ? -v:v);

        ret+=((neg? " -":" +")+v);

        if( mod==2 || mod==5 || mod==7 ) ret+=")";

        }

     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;

     }   

*/

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

   private void prepareDataStructures(int cols, String desc, int slices)

     {

     mRows       =0;

     mCols       =0;

     mSlices     =slices;

     numVertices =0;

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

       {

       mCols = cols;

       mRows = desc.length()/cols;

       mCubes    = new int[mRows][mCols];

       mInflateX = new byte[mRows+1][mCols+1];

       mInflateY = new byte[mRows+1][mCols+1];

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

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

           mCubes[row][col] = (desc.charAt(row * mCols + col) == '1' ? 1 : 0);

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

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

           {

           fillInflate(row,col);

           }

       markRegions();

       numVertices = computeDataLength();

       currVert = 0;

       }

     }

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

// full grid

   private void prepareDataStructures(int cols, int rows, int slices)

     {

     mRows        =rows;

     mCols        =cols;

     mSlices      =slices;

     numVertices  =0;

     if( cols>0 && rows>0 )

       {

       mCubes    = new int[mRows][mCols];

       mInflateX = new byte[mRows+1][mCols+1];

       mInflateY = new byte[mRows+1][mCols+1];

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

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

           mCubes[row][col] = 1;

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

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

           {

           fillInflate(row,col);

           }

       markRegions();

       numVertices = computeDataLength();

       currVert = 0;

       }

     }

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

// 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,row-1,col)' below) - otherwise

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

  private void markRegions()

     {

     int row, col, numWater=1, numLand=0;

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

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

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

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

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

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

           {

           if( mCubes[row][col] == 0 ) { numWater++; markRegion( (short)(2*numWater ),row,col); mEdges.add(new Edge(SOUTH,row-1,col)); }

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

           }

     // 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(int edge=0; edge<mEdgeNum; edge++)

       {

       e1 = mEdges.get(edge);

       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(int j=edge+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)

     {

     int 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 void buildFrontBackGrid(boolean front, float[] attribs)

     {

     int last, current;

     boolean seenLand=false;

     boolean lastBlockIsNE = false;

     boolean currentBlockIsNE;

     float vectZ = (front ? 0.5f : -0.5f);

     //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 && ((currVert%2==1)^currentBlockIsNE) )

             {

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

             repeatLast(attribs);

             }

           createNormals(front,row,col);

           if( currentBlockIsNE )

             {

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

               {

               if( seenLand  && (last != current) ) repeatLast(attribs);

               addFrontVertex( 0, vectZ, col, row, attribs);

               if( seenLand  && (last != current) ) repeatLast(attribs);

               if( !lastBlockIsNE || (!front && !seenLand) ) repeatLast(attribs);

               addFrontVertex( 1, vectZ, col, row+1, attribs);

               }

             addFrontVertex( 2, vectZ, col+1, row  , attribs);

             addFrontVertex( 3, vectZ, col+1, row+1, attribs);

             }

           else

             {

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

               {

               if( seenLand  && (last != current) ) repeatLast(attribs);

               addFrontVertex( 1, vectZ, col, row+1, attribs);

               if( seenLand  && (last != current) ) repeatLast(attribs);

               if( lastBlockIsNE || (!front && !seenLand) ) repeatLast(attribs);

               addFrontVertex( 0, vectZ, col, row, attribs);

               }

             addFrontVertex( 3, vectZ, col+1, row+1, attribs);

             addFrontVertex( 2, vectZ, col+1, row  , attribs);

             }

           seenLand = true;

           lastBlockIsNE = currentBlockIsNE;

           }

         last = current;

         }

       }

     }

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

  private void buildSideGrid(float[] attribs)

     {

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

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

       {

       buildIthSide(mEdges.get(i), attribs);

       }

     }

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

  private void buildIthSide(Edge curr, float[] attribs)

     {

     Edge prev, next;

     int col, row, side;

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

       }

     for(int slice=0; slice<mSlices; slice++)

       {

       col = curr.col;

       row = curr.row;

       side= curr.side;

       next = getNextEdge(curr);

       addSideVertex(curr,true,slice+1,prev.side,attribs);

       do

         {

         if( prev.side!=curr.side )

           {

           addSideVertex(curr,true,slice+1,prev.side,attribs);

           addSideVertex(curr,true,slice  ,prev.side,attribs);

           }

         addSideVertex(curr,false,slice+1,next.side,attribs);

         addSideVertex(curr,false,slice  ,next.side,attribs);

         prev = curr;

         curr = next;

         next = getNextEdge(curr);

         }

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

       repeatLast(attribs);

       }

     }

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

  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 fillInflate(int row, int col)

    {

    int diff;

         if( col==0     ) mInflateX[row][col] = -1;

    else if( col==mCols ) mInflateX[row][col] = +1;

    else

      {

      if( row==0 )

        {

        diff = mCubes[0][col-1]-mCubes[0][col];

        }

      else if( row==mRows )

        {

        diff = mCubes[mRows-1][col-1]-mCubes[mRows-1][col];

        }

      else

        {

        diff = (mCubes[row  ][col-1]-mCubes[row  ][col]) +

               (mCubes[row-1][col-1]-mCubes[row-1][col]) ;

        if( diff==-2 ) diff=-1;

        if( diff== 2 ) diff= 1;

        }

      mInflateX[row][col] = (byte)diff;

      }

         if( row==0     ) mInflateY[row][col] = +1;

    else if( row==mRows ) mInflateY[row][col] = -1;

    else

      {

      if( col==0 )

        {

        diff = mCubes[row][0]-mCubes[row-1][0];

        }

      else if( col==mCols )

        {

        diff = mCubes[row][mCols-1]-mCubes[row-1][mCols-1];

        }

      else

        {

        diff = (mCubes[row  ][col-1]+mCubes[row  ][col]) -

               (mCubes[row-1][col-1]+mCubes[row-1][col]) ;

        if( diff==-2 ) diff=-1;

        if( diff== 2 ) diff= 1;

        }

      mInflateY[row][col] = (byte)diff;

      }

    //android.util.Log.e("mesh","col="+col+" row="+row+" inflateX="+mInflateX[col][row]+" InflateY="+mInflateY[col][row]);

    }

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

  private void addFrontVertex(int index, float vectZ, int col, int row, float[] attribs)

     {

     float x = (float)col/mCols;

     float y = (float)row/mRows;

     attribs[VERT_ATTRIBS*currVert + POS_ATTRIB  ] = x-0.5f;

     attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = 0.5f-y;

     attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = vectZ;

     attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB  ] = mNormalX[index];

     attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] = mNormalY[index];

     attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = mNormalZ[index];

     attribs[VERT_ATTRIBS*currVert + INF_ATTRIB  ] = mInflateX[row][col]/2.0f;

     attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = mInflateY[row][col]/2.0f;

     attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = vectZ;

     if( vectZ>0 )

       {

       attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB  ] = mTexMappingX[FRONT] +       x  * mTexMappingW[FRONT];

       attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[FRONT] + (1.0f-y) * mTexMappingH[FRONT];

       }