Distorted Android

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

// Copyright 2020 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

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

//                                                                                               //

// This library 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                             //

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

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

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

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

import org.distorted.library.main.DistortedLibrary;

/**

 * 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

 * polygon is going to be split into such triangles, and each triangle is split into adjustable number

 * of 'bands' form the outer edge towards the center. Edges of each band can can at any elevation.

 */

public class MeshPolygon extends MeshBase

  {

  private static final int NUM_CACHE = 20;

  private static final int SHAPE_DD = 0;

  private static final int SHAPE_DU = 1;

  private static final int SHAPE_UD = 2;

  private static final int SHAPE_UU = 3;

  private static final int SHAPE_DUD= 4;

  private float[] mPolygonVertices;

  private int mNumPolygonVertices;

  private float[] mPolygonBands;

  private int mNumPolygonBands;

  private boolean[] mEdgeUp;

  private boolean[] mVertUp;

  private int remainingVert;

  private int numVertices;

  private int extraIndex, extraVertices;

  private float[] mCurveCache;

  private float mVecX, mVecY;

  private int[] mEdgeShape;

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

// polygonVertices>=3 , polygonBands>=2

  private void computeNumberOfVertices()

     {

     if( mNumPolygonBands==2 && extraIndex>0 )

       {

       numVertices = 1 + 2*mNumPolygonVertices*(1+extraIndex+2*extraVertices);

       }

     else

       {

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

       numVertices+= 2*mNumPolygonVertices*(2*extraIndex*extraVertices);

       }

     remainingVert = numVertices;

     }

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

  private void computeCache()

    {

    mCurveCache = new float[NUM_CACHE];

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

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

    for(int i=1; i<mNumPolygonBands; i++)

      {

      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 prev = 0;

    int next = 0;

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

      {

      float x = i/(NUM_CACHE-1.0f);

      if( x>=tmpX[next] )

        {

        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 num = 1 + extraIndex + 2*extraVertices;

    int change1 = extraVertices+1;

    int change2 = num-change1;

    float quot = 1.0f/(extraIndex+1);

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

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

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

    }

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

  private float getQuot(int index, int band, boolean isExtra)

    {

    int num = mNumPolygonBands-1-band;

    if( num>0 )

      {

      if( isExtra )

        {

        int extra = extraIndex-band+extraVertices;

        if( index < extra )

          {

          float quot = ((float)extraIndex-band)/(extra*num);

          return index*quot;

          }

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

          {

          float quot = ((float)extraIndex-band)/(extra*num);

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

          }

        else

          {

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

          }

        }

      return (float)index/num;

      }

    return 1.0f;

    }

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

  private float computeZEdge(float quot)

    {

    if( quot>=1.0f ) return 0.0f;

    for(int band=1; band<mNumPolygonBands; band++)

      {

      float curr = mPolygonBands[2*band];

      if( curr<=quot )

        {

        float prev = mPolygonBands[2*band-2];

        float prevH= mPolygonBands[2*band-1];

        float currH= mPolygonBands[2*band+1];

        float A = (prev-quot)/(prev-curr);

        return A*currH + (1-A)*prevH;

        }

      }

    return 0.0f;

    }

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

  private float derivative(float x)

    {

    if( x>=1.0f )

      {

      return 0.0f;

      }

    else

      {

      float tmp = x*(NUM_CACHE-1);

      int i1 = (int)tmp;

      int i2 = i1+1;

      return (tmp-i1)*(mCurveCache[i2]-mCurveCache[i1]) + mCurveCache[i1];

      }

    }

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

  private void figureOutNormalVector2D(int edgeShape, int polyVertex, int polyEndVer, float quot, float xEdge, float yEdge )

    {

    if( edgeShape==SHAPE_DD )

      {

      if( quot<0.5f )

        {

        int p = polyVertex>0 ? polyVertex-1 : mNumPolygonVertices-1;

        int prvShape = mEdgeShape[p];

        switch(prvShape)

          {

          case SHAPE_DD : mVecX = xEdge;

                          mVecY = yEdge;

                          break;

          case SHAPE_UD :

          case SHAPE_DUD: float a = 2*quot;

                          float xCurr= mPolygonVertices[2*polyVertex  ];

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

                          float xPrev= mPolygonVertices[2*p  ];

                          float yPrev= mPolygonVertices[2*p+1];

                          float xVec = xCurr-xPrev;

                          float yVec = yCurr-yPrev;

                          mVecX = a*xEdge + (1-a)*xVec;

                          mVecY = a*yEdge + (1-a)*yVec;

                          break;

          default: throw new RuntimeException("figureOutNormalVector2D: impossible1: "+prvShape);

          }

        }

      else

        {

        int n = polyEndVer==mNumPolygonVertices-1 ? 0 : polyEndVer+1;

        int nxtShape = mEdgeShape[polyEndVer];

        switch(nxtShape)

          {

          case SHAPE_DD : mVecX = xEdge;

                          mVecY = yEdge;

                          break;

          case SHAPE_DU :

          case SHAPE_DUD: float a = 2-2*quot;

                          float xCurr= mPolygonVertices[2*polyEndVer  ];

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

                          float xNext= mPolygonVertices[2*n  ];

                          float yNext= mPolygonVertices[2*n+1];

                          float xVec = xCurr-xNext;

                          float yVec = yCurr-yNext;

                          mVecX = a*xEdge + (1-a)*xVec;

                          mVecY = a*yEdge + (1-a)*yVec;

                          break;

          default: throw new RuntimeException("figureOutNormalVector2D: impossible2: "+nxtShape);

          }

        }

      }

    else if( edgeShape==SHAPE_UU || (quot>=0.5f && edgeShape==SHAPE_DU) || (quot<0.5f && edgeShape==SHAPE_UD) )

      {

      mVecX = 1;

      mVecY = 0;

      }

    else

      {

      float dx = mPolygonVertices[2*polyVertex  ] - mPolygonVertices[2*polyEndVer  ];

      float dy = mPolygonVertices[2*polyVertex+1] - mPolygonVertices[2*polyEndVer+1];

      if( quot<0.5 )

        {

        mVecX = dx;

        mVecY = dy;

        }

      else

        {

        mVecX = -dx;

        mVecY = -dy;

        }

      }

    }

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

  private float figureOutDerivative(int edgeShape, int polyBand, float quot)

    {

    if( edgeShape==SHAPE_DD )

      {

      return derivative(1-mPolygonBands[2*polyBand]);

      }

    if( edgeShape==SHAPE_UU || (quot>=0.5f && edgeShape==SHAPE_DU) || (quot<0.5f && edgeShape==SHAPE_UD) )

      {

      return 0;

      }

    float x = 1-mPolygonBands[2*polyBand];

    float q = quot>=0.5f ? 2-2*quot : 2*quot;

    return derivative((1-x)*q+x);

    }

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

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

                        float[] attribs1, float[] attribs2)

    {

    remainingVert--;

    float Xfirst= mPolygonVertices[2*polyVertex  ];

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

    float Xlast = mPolygonVertices[2*polyEndVer  ];

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

    float xEdge = Xfirst + quot*(Xlast-Xfirst);

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

    float zEdge;

    float q = mPolygonBands[2*polyBand];

    float o = mPolygonBands[2*polyBand+1];

    float t = mPolygonBands[2*mNumPolygonBands-1];

    int shape = mEdgeShape[polyVertex];

    switch(shape)

      {

      case SHAPE_DD : zEdge = 0.0f; break;

      case SHAPE_UU : zEdge = t;    break;

      case SHAPE_DU : zEdge = quot>=0.5f ? t : computeZEdge(1-2*quot); break;

      case SHAPE_UD : zEdge = quot<=0.5f ? t : computeZEdge(2*quot-1); break;

      default       : zEdge = quot<=0.5f ? computeZEdge(1-2*quot) : computeZEdge(2*quot-1); break;

      }

    float x = q*xEdge;

    float y = q*yEdge;

    float z = o + (t-o)*(zEdge/t);

    attribs1[VERT1_ATTRIBS*vertex + POS_ATTRIB  ] = x;

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

    attribs1[VERT1_ATTRIBS*vertex + POS_ATTRIB+2] = z;

    figureOutNormalVector2D(shape, polyVertex, polyEndVer, quot, xEdge, yEdge);

    float d = figureOutDerivative(shape,polyBand,quot);

    float vx = d*mVecX;

    float vy = d*mVecY;

    float vz = mVecX*mVecX + mVecY*mVecY;

    float len = (float)Math.sqrt(vx*vx + vy*vy + vz*vz);

    int index = VERT1_ATTRIBS*vertex + NOR_ATTRIB;

    attribs1[index  ] = vx/len;

    attribs1[index+1] = vy/len;

    attribs1[index+2] = vz/len;

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

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

    return vertex+1;

    }

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

  private int createBandStrip(int vertex, int polyBand, int polyVertex, float[] attribs1, float[] attribs2)

    {

    if( polyVertex==0 )

      {

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

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

      }

    boolean specialCase = mNumPolygonBands==2 && polyBand==0 && extraIndex>0;

    boolean isExtra = polyBand<extraIndex;

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

    if( isExtra ) numPairs += 2*extraVertices;

    int polyEndVer = polyVertex==mNumPolygonVertices-1 ? 0 : polyVertex+1;

    float quot1, quot2;

    for(int index=0; index<numPairs; index++)

      {

      if( specialCase )

        {

        quot1 = 1.0f;

        quot2 = getSpecialQuot(index+1);

        }

      else

        {

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

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

        }

      vertex = addVertex(vertex,polyBand+1,polyVertex,polyEndVer,quot1,attribs1,attribs2);

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

      }

    return vertex;

    }

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

  private int computeEdgeShape(int curr)

    {

    if( mEdgeUp==null || !mEdgeUp[curr] ) return SHAPE_DD;

    int prev = (curr==0 ? mNumPolygonVertices-1 : curr-1);

    int next = (curr==mNumPolygonVertices-1 ? 0 : curr+1);

    boolean rd = ( !mEdgeUp[next] || mVertUp==null || !mVertUp[next] );

    boolean ld = ( !mEdgeUp[prev] || mVertUp==null || !mVertUp[curr] );

    return rd ? (ld ? SHAPE_DUD : SHAPE_UD) : (ld ? SHAPE_DU : SHAPE_UU);

    }

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

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

    {

    int vertex=0;

    mEdgeShape = new int[mNumPolygonVertices];

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

      mEdgeShape[polyVertex] = computeEdgeShape(polyVertex);

    for(int polyBand=0; polyBand<mNumPolygonBands-1; polyBand++)

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

        vertex = createBandStrip(vertex,polyBand,polyVertex,attribs1,attribs2);

    }

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

// PUBLIC API

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

/**

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

 * Optionally make it more dense at the vertices.

 *

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

 *                   Vertices HAVE TO be specified in a COUNTERCLOCKWISE order (starting from any).

 * @param bands      2K floats; K pairs of two floats each describing a single band.

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

 *                   Must be band[2*i] > band[2*(i+1)] !

 * @param edgeUp     N booleans - one for each edge; the first connects vertices (0,1) and (2,3);

 *                   then just like 'verticesXY', i.e. counterclockwise.

 *                   If this is null, all edges are by default 'down'.

 *                   'Down' means that edge's Z is equal to 0; 'up' means that its Z, at least in its

 *                   middle, is equal to the highest elevation in the middle of the mesh.

 *                   If the 'previous' edge is also up, then the Z is up horizontally from its middle

 *                   to the left vertex; else it goes down along the same function it goes along the bands.

 *                   Same with the right half of the edge.

 * @param vertUp     N booleans - one for each vertex. The first is about vertex 0, then vertex 1, etc.

 *                   If this is null or false, the vertex is down; otheerwise - it is 'up'.

 *                   This is taken into account only in one case: if both edges the vertex is the end of

 *                   are 'up', then the vertex can be 'up' or 'down'; otherwise - if at least one of

 *                   those edges is 'down' - then the vertex must be 'down' as well and this is ignored.

 * @param exIndex    This and the next parameter describe how to make the mesh denser at the

 *                   polyVertices. If e.g. exIndex=3 and exVertices=2, then 3 triangles of the

 *                   outermost band (and 2 triangles of the next band, and 1 triangle of the third

 *                   band) get denser - the 3 triangles become 3+2 = 5.

 * @param exVertices See above.

 * @param centerX    the X coordinate of the 'center' of the Polygon, i.e. point of the mesh

 *                   all bands go to.

 * @param centerY    Y coordinate of the center.

 */

  public MeshPolygon(float[] verticesXY, float[] bands, boolean[] edgeUp, boolean[] vertUp, int exIndex, int exVertices, float centerX, float centerY)

    {

    super();

    mPolygonVertices   = verticesXY;

    mPolygonBands      = bands;

    mNumPolygonVertices= mPolygonVertices.length /2;

    mNumPolygonBands   = mPolygonBands.length /2;

    mEdgeUp            = edgeUp;

    mVertUp            = vertUp;

    extraIndex         = exIndex;

    extraVertices      = exVertices;

    if( centerX!=0.0f || centerY!=0.0f )

      {

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

        {

        mPolygonVertices[2*v  ] -= centerX;

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

        }

      }

    computeNumberOfVertices();

    computeCache();

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

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

    buildGrid(attribs1,attribs2);

    if( remainingVert!=0 )

      DistortedLibrary.logMessage("MeshPolygon: remainingVert " +remainingVert );

    if( centerX!=0.0f || centerY!=0.0f )

      {

      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;

        }

      }

    setAttribs(attribs1,attribs2);

    }

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

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

    {

    this(verticesXY,bands,null,null,exIndex,exVertices,0.0f,0.0f);

    }

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

/**

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

    {

    this(verticesXY,bands,null,null,0,0,0.0f,0.0f);

    }

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

/**

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

    }

 }