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;

/**

 * Creator a triangular mesh divided into 'bands' i.e. strips parallel to one of the sides and

 * and of different elevations.

 * <p>

 * This is a building block for MeshMultigon.

 */

public class MeshBandedTriangle extends MeshBase

  {

  public static final int MODE_INVERTED= 1;

  public static final int MODE_FLAT    = 2;

  private float mLeftX, mLeftY;

  private float mRightX, mRightY;

  private float mTopX, mTopY;

  private float[] mNormL, mNormR;

  private int mMode;

  private float[] mBands;

  private int mNumBands;

  private int remainingVert;

  private int numVertices;

  private float[] mCurveCache;

  private float mVecX, mVecY;

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

  private void computeNumberOfVertices()

    if( mMode==MODE_FLAT )

      {

      numVertices = 3;

      }

    else if( mMode==MODE_NORMAL )

      {

      numVertices = mNumBands*(mNumBands+2) + 4*extraVertices*extraBands;

      }

    else

      {

      numVertices = mNumBands*(mNumBands+2);

      }

    remainingVert = numVertices;

    }

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

  private void computeCache()

    {

    mCurveCache = new float[NUM_CACHE];

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

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

    tmpD[0] = tmpD[1];

    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;

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

        }

      }

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

  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;

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

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

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

      }

    }

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

    mVecY = mNormL[1] + qx*(mNormR[1]-mNormL[1]);

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

      case MODE_INVERTED: return -derivative(qy);

      default           : return 0;

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

  private float computeElevation(int band)

    {

    switch(mMode)

      case MODE_INVERTED: return mBands[2*(mNumBands-band)+1];

      default           : return mBands[2*mNumBands+1];

    }

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

    remainingVert--;

    float by = mLeftY + qx*(mRightY-mLeftY);

    float x = bx + q*(mTopX-bx);

    float y = by + q*(mTopY-by);

    float z = computeElevation(band);

    float d = figureOutDerivative(qy);

    attribs1[VERT1_ATTRIBS*vertex + POS_ATTRIB  ] = x;

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

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

    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;

    }

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

    int extra = ((band<extraBands && mMode==MODE_NORMAL) ? extraVertices : 0);

    int n = mNumBands-band-1;

    float b = 1.0f/(mNumBands-band);

    float dxb = fromLeft ? b : -b;

    float sdx = dxb/(extra+1);

    float qx = fromLeft ? 0.0f : 1.0f;

    int bb = mMode==MODE_NORMAL ? band   : mNumBands-band;

    int bt = mMode==MODE_NORMAL ? band+1 : mNumBands-(band+1);

    float qyb = mBands[2*bb];

    float qyt = mBands[2*bt];

    if( mMode!=MODE_NORMAL )

      qyt = 1-qyt;

      {

      vertex = addStripVertex(vertex, qx          , qyt, band+1, attribs1,attribs2);

      vertex = addStripVertex(vertex, qx+(v+1)*sdx, qyb, band  , attribs1,attribs2);

      }

      float dxt = fromLeft ? t : -t;

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

        vertex=addStripVertex(vertex, qx+(v+1)*dxb, qyb, band  , attribs1, attribs2);

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

      {

      vertex = addStripVertex(vertex, qx              , qyt, band+1, attribs1,attribs2);

      vertex = addStripVertex(vertex, qx-dxb+(v+1)*sdx, qyb, band  , attribs1,attribs2);

    return vertex;

    }

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

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

    {

      {

      addStripVertex(0, 0, 1, 0, attribs1,attribs2);

      addStripVertex(1, 0, 0, 0, attribs1,attribs2);

      addStripVertex(2, 1, 1, 0, attribs1,attribs2);

      }

    else

      {

      int vertex=0;

      for(int b=0; b<mNumBands; b++) vertex=createBand(vertex, b, attribs1, attribs2);

      }

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

// PUBLIC API

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

/**

 * Create a triangular mesh split into 'bands' - i.e. strips of triangles - which are parallel to

 * a given edge.

 *

 * @param vL         A pair of floats (x,y) which defines the 'left' vertex of the triangle.

 * @param vR         A pair of floats (x,y) which defines the 'right' vertex of the triangle.

 * @param vT         A pair of floats (x,y) which defines the 'top' vertex of the triangle.

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

 *                   From (1.0,Z[0]) (the 'left-right' edge, its Z elevation) to (0.0,Z[K])

 *                   (the 'top' vertex, its elevation). The polygon is split into such strips.

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

 *                   The way the bands get interpreted also depends on the 'mode' param.

 * @param normL      A pair of floats which define a 2D vector - which is the normal vector of each

 *                   mesh vertex which lies on the 'left-top' edge casted to the XY plane.

 * @param normR      Same as above but about the vertices which belong to the 'right-top' triangle

 *                   edge. This and the previous param define the vector field of normals, as seen

 *                   from above, of the whole mesh.

 * @param mode       MODE_UP, MODE_DOWN or MODE_FLAT.

 *                   This defines how we interpret the bands.

 *                   If UP, we interpret them the same as in MeshPolygon - i.e. the first band is

 *                   about the 'left-right' edge, then progressively towards the 'top'.

 *                   If DOWN, we turn the interpretation of the bands upside-down: it is the last

 *                   band which defines the strip aong the 'left-right' edge.

 *                   If FLAT, everything is flat anyway, so we disregard the bands and return a mesh

 *                   with 3 vertices.

 *                   'left' and 'right' vertices. If e.g. exBands=3 and exVertices=2, then 3 triangles

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

 * @param exVertices See above.

 */

    super();

    mLeftX   = vL[0];

    mLeftY   = vL[1];

    mRightX  = vR[0];

    mRightY  = vR[1];

    mTopX    = vT[0];

    mTopY    = vT[1];

    mMode = mode;

    mNormR= new float[] { normR[0],normR[1] };

    mBands        = bands;

    extraBands    = exBands;

    computeNumberOfVertices();

    computeCache();

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

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

    buildGrid(attribs1,attribs2);

    if( remainingVert!=0 )

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

    setAttribs(attribs1,attribs2);

    }

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

/**

 * Copy constructor.

 */

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

    {

    return new MeshBandedTriangle(this,deep);

    }

 }