Distorted Android

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

// This file is part of Distorted.                                                               //

//                                                                                               //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

// Lesser General Public License for more details.                                               //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

package org.distorted.library.mesh;

 * Create a polygon of any shape and varying elevations from the edges towards the center.

 * <p>

 * Specify a list of vertices. Any two adjacent vertices + the center (0,0,0) form a triangle. The

 */

public class MeshPolygon extends MeshBase

  {

  private int mNumPolygonVertices;

  private float[] mPolygonBands;

  private int mNumPolygonBands;

  private int remainingVert;

  private int numVertices;

// polygonVertices>=3 , polygonBands>=2

     else

       {

       numVertices = (mNumPolygonVertices*mNumPolygonBands+2)*(mNumPolygonBands-1) - 1;

    float[] tmpD = new float[mNumPolygonBands+1];

    float[] tmpX = new float[mNumPolygonBands+1];

      {

      tmpD[i] = (mPolygonBands[2*i-1]-mPolygonBands[2*i+1]) / (mPolygonBands[2*i]-mPolygonBands[2*i-2]);

      tmpX[i] = 1.0f - (mPolygonBands[2*i]+mPolygonBands[2*i-2])/2;

      }

    tmpD[0] = tmpD[1];

    tmpD[mNumPolygonBands] = tmpD[mNumPolygonBands-1];

    tmpX[0] = 0.0f;

    tmpX[mNumPolygonBands] = 1.0f;

    int next = 0;

    for(int i=0; i<NUM_CACHE-1; i++)

        {

        prev = next;

        while( next<=mNumPolygonBands && x>=tmpX[next] ) next++;

        }

      if( next>prev )

        {

        float t = (x-tmpX[prev]) / (tmpX[next]-tmpX[prev]);

        mCurveCache[i] = t*(tmpD[next]-tmpD[prev]) + tmpD[prev];

        }

      else

        {

        mCurveCache[i] = tmpD[next];

        }

    mCurveCache[NUM_CACHE-1] = tmpD[mNumPolygonBands];

  private float getSpecialQuot(int index)

    {

    int change2 = num-change1;

    if( index<change1 )      return index*quot/change1;

    else if( index>change2 ) return 1-quot + (index-change2)*quot/change1;

    else                     return (index-change1+1)*quot;

    }

      {

      if( isExtra )

        {

        if( index < extra )

          {

          }

        else if( index > num+2*extraVertices-extra )

          {

          return (1.0f-((float)extraBand-band)/num) + (index-num-2*extraVertices+extra)*quot;

        else

          {

          return ((float)(index-extraVertices))/num;

          }

        }

      }

    }

  private float derivative(float x)

    {

    if( x>=1.0f )

      {

    else

      {

      float tmp = x*(NUM_CACHE-1);

      int i1 = (int)tmp;

      int i2 = i1+1;

      // why 0.5? Arbitrarily; this way the cubit faces of Twisty Puzzles

      // [the main and only user of this class] look better.

    }

  private int addVertex(int vertex, int polyBand, int polyVertex, int polyEndVer, float quot,

    remainingVert--;

    float Yfirst= mPolygonVertices[2*polyVertex+1];

    float Xlast = mPolygonVertices[2*polyEndVer  ];

    float Ylast = mPolygonVertices[2*polyEndVer+1];

    float yEdge = Yfirst + quot*(Ylast-Yfirst);

    float y = q*yEdge;

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

    float vy = d*yEdge;

    float vz = xEdge*xEdge + yEdge*yEdge;

    attribs1[index+1] = vy/len;

    attribs1[index+2] = vz/len;

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

    return vertex+1;

    }

    if( polyVertex==0 )

      {

      if( polyBand>0 ) vertex = addVertex(vertex,polyBand,0,1,0,attribs1,attribs2);

    boolean isExtra = polyBand<extraBand;

    int numPairs = specialCase ? extraBand+1 : mNumPolygonBands-1-polyBand;

        {

        quot1 = 1.0f;

        quot2 = getSpecialQuot(index+1);

        }

      else

        {

        quot1 = getQuot(index  ,polyBand+1, isExtra);

        quot2 = getQuot(index+1,polyBand  , isExtra);

        }

      vertex = addVertex(vertex,polyBand  ,polyVertex,polyEndVer,quot2,attribs1,attribs2);

    }

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

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

    {

    int vertex=0;

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

// PUBLIC API

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

/**

 * Create a polygon of any shape and varying elevations from the edges towards the center.

 * @param verticesXY 2N floats - packed description of polygon vertices. N pairs (x,y).

 *                   From (1.0,Z[0]) (outer edge, its Z elevation) to (0.0,Z[K]) (the center,

 *                   its elevation). The polygon is split into such concentric bands.

 * @param exVertices See above.

 *                   all bands go to.

 * @param centerY    Y coordinate of the center.

    super();

    mPolygonBands      = bands;

    mNumPolygonVertices= mPolygonVertices.length /2;

    mNumPolygonBands   = mPolygonBands.length /2;

      {

      for(int v=0; v<mNumPolygonVertices; v++)

        {

        mPolygonVertices[2*v  ] -= centerX;

        mPolygonVertices[2*v+1] -= centerY;

        }

      }

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

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

    buildGrid(attribs1,attribs2);

    if( remainingVert!=0 )

      {

      for(int v=0; v<numVertices; v++)

        {

        attribs1[VERT1_ATTRIBS*v + POS_ATTRIB  ] += centerX;

        attribs1[VERT1_ATTRIBS*v + POS_ATTRIB+1] += centerY;

        attribs2[VERT2_ATTRIBS*v + TEX_ATTRIB  ] += centerX;

        attribs2[VERT2_ATTRIBS*v + TEX_ATTRIB+1] += centerY;

        }

      }

    }

  public MeshPolygon(float[] verticesXY, float[] bands, int exIndex, int exVertices)

    {

/**

 * Create a polygon of any shape and varying elevations from the edges towards the center.

 * Equivalent of the previous with exIndex=0 or exVertices=0.

 */

  public MeshPolygon(float[] verticesXY, float[] bands)

    {

/**

 * Copy constructor.

 */

  public MeshPolygon(MeshPolygon 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 MeshPolygon copy(boolean deep)

    {

    return new MeshPolygon(this,deep);

    }

 }