Distorted Android

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

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

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

/**

 * Create a Mesh which approximates a triangle with vertices at (-0.5,-0.5),(+0.5,-0.5),(0.0,0.5)

 */

public class MeshTriangle extends MeshBase

  {

  private int numVertices;

  private int remainingVert;

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

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

     {

     remainingVert--;

     attribs1[VERT1_ATTRIBS*vertex + POS_ATTRIB  ] = x-0.5f;

     attribs1[VERT1_ATTRIBS*vertex + POS_ATTRIB+1] = y-0.5f;

     attribs1[VERT1_ATTRIBS*vertex + POS_ATTRIB+2] = 0.0f;

     attribs1[VERT1_ATTRIBS*vertex + NOR_ATTRIB  ] = 0.0f;

     attribs1[VERT1_ATTRIBS*vertex + NOR_ATTRIB+1] = 0.0f;

     attribs1[VERT1_ATTRIBS*vertex + NOR_ATTRIB+2] = 1.0f;

     attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB  ] = x;

     attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB+1] = y;

     return vertex+1;

     }

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

  private void computeNumberOfVertices(int level)

     {

     numVertices = level*(level+2);

     remainingVert = numVertices;

     }

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

  private int buildRow(int vertex,float sx, float sy, int length, float dx, float dy, float[] attribs1, float[] attribs2)

    {

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

      {

      vertex = addVertex(vertex, sx   , sy   , attribs1, attribs2);

      vertex = addVertex(vertex, sx+dx, sy+dy, attribs1, attribs2);

      sx += 2*dx;

      }

    vertex = addVertex(vertex, sx, sy, attribs1, attribs2);

    return vertex;

    }

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

  private void buildGrid(float[] attribs1, float[] attribs2, int level)

     {

     float sx = 0.0f;

     float sy = 0.0f;

     float dx = 0.5f/level;

     float dy = 1.0f/level;

     int vertex = 0;

     for(int row=level; row>=1; row--)

       {

       vertex = buildRow(vertex,sx,sy,row,dx,dy,attribs1,attribs2);

       sx += 2*dx*(row-0.5f);

       sy += dy;

       dx *= -1;

       }

     }

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

// PUBLIC API

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

  /**

   * Creates the underlying grid of vertices with the usual attribs which approximates a triangle

   * with vertices at (-0.5,-0.5),(+0.5,-0.5),(0.0,0.5)

   *

   * @param level Specifies the level of slicing. Valid values: level ≥ 1

   */

  public MeshTriangle(int level)

     {

     super();

     computeNumberOfVertices(level);

     float[] attribs1= new float[VERT1_ATTRIBS*numVertices];

     float[] attribs2= new float[VERT2_ATTRIBS*numVertices];

     buildGrid(attribs1, attribs2, level);

     if( remainingVert!=0 )

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

     setAttribs(attribs1, attribs2);

     }

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

/**

 * Copy constructor.

 */

  public MeshTriangle(MeshTriangle mesh, boolean deep)

    {

    super(mesh,deep);

    }

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

/**

 * Copy the Mesh.

 *

 * @param deep If to be a deep or shallow copy of mVertAttribs1, i.e. the array holding vertices,

 *             normals and inflates (the rest, in particular the mVertAttribs2 containing texture

 *             coordinates and effect associations, is always deep copied)

 */

  public MeshTriangle copy(boolean deep)

    {

    return new MeshTriangle(this,deep);

    }

  }