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.effect.MatrixEffect;

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.effectqueue.EffectQueueVertex;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.type.Static4D;

import java.util.ArrayList;

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

/**

 * Not part of public API, do not document (public only because has to be cleaned from the main package)

 *

 * @y.exclude

 */

public class DeferredJobs

  {

  private static final int JOB_TYPE_VERTEX       = 0;

  private static final int JOB_TYPE_MATRIX       = 1;

  private static final int JOB_TYPE_MERGE_TEX    = 2;

  private static final int JOB_TYPE_MERGE_EFF    = 3;

  private static final int JOB_TYPE_JOIN         = 4;

  private static final int JOB_TYPE_COPY         = 5;

  private static final int JOB_TYPE_TEXTURE      = 6;

  private static final int JOB_TYPE_ASSOC        = 7;

  private static final int JOB_TYPE_CENTER       = 8;

  private static final int JOB_TYPE_ADD_EMPTY_TEX= 9;

  private static final int JOB_TYPE_NOT_AFFECTED = 10;

  private static final ArrayList<JobNode> mJobs = new ArrayList<>();

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

  private static class Job

    {

    private final int mType;

    private final MeshBase mTarget;

    private final MeshBase[] mSource;

    private final MatrixEffect mMatrixEffect;

    private final Static4D[] mMaps;

    private final int mComp, mAndAssoc, mEquAssoc;

    private final float mX,mY,mZ;

    private final int[] mComps;

    private EffectQueueVertex mVertexEffects;

    Job(int type, MeshBase target, MeshBase[] source, VertexEffect vEff, MatrixEffect mEff,

        Static4D[] maps, int comp, int and, int equ, float x, float y, float z, int[] comps)

      {

      mType     = type;

      mTarget   = target;

      mSource   = source;

      mMaps     = maps;

      mComp     = comp;

      mAndAssoc = and;

      mEquAssoc = equ;

      mX        = x;

      mY        = y;

      mZ        = z;

      mComps    = comps;

      if( vEff!=null )

        {

        mVertexEffects= new EffectQueueVertex();

        mVertexEffects.add(vEff);

        }

      mMatrixEffect = mEff;

      }

    void addEffect(VertexEffect effect)

      {

      mVertexEffects.add(effect);

      }

    void execute()

      {

      switch(mType)

        {

        case JOB_TYPE_VERTEX       : DistortedLibrary.adjustVertices(mTarget, mVertexEffects);

                                     break;

        case JOB_TYPE_MATRIX       : mTarget.applyMatrix(mMatrixEffect,mAndAssoc,mEquAssoc);

                                     break;

        case JOB_TYPE_MERGE_TEX    : mTarget.mergeTexComponentsNow();

                                     break;

        case JOB_TYPE_MERGE_EFF    : mTarget.mergeEffComponentsNow();

                                     break;

        case JOB_TYPE_JOIN         : mTarget.joinAttribs(mSource);

                                     break;

        case JOB_TYPE_COPY         : mTarget.copy(mSource[0]);

                                     break;

        case JOB_TYPE_TEXTURE      : mTarget.textureMap(mMaps,mComp);

                                     break;

        case JOB_TYPE_ASSOC        : mTarget.setEffectAssociationNow(mComp,mAndAssoc,mEquAssoc);

                                     break;

        case JOB_TYPE_CENTER       : mTarget.setComponentCenterNow(mComp,mX,mY,mZ);

                                     break;

        case JOB_TYPE_ADD_EMPTY_TEX: mTarget.addEmptyTexComponentNow();

                                     break;

        case JOB_TYPE_NOT_AFFECTED:  mTarget.setNotAffectedComponentsNow(mComps);

        }

      }

    void clear()

      {

      if( mVertexEffects!=null ) mVertexEffects.removeAll(false);

      }

    String print()

      {

      switch(mType)

        {

        case JOB_TYPE_VERTEX       : return "VERTEX";

        case JOB_TYPE_MATRIX       : return "MATRIX";

        case JOB_TYPE_MERGE_TEX    : return "MERGE_TEX";

        case JOB_TYPE_MERGE_EFF    : return "MERGE_EFF";

        case JOB_TYPE_JOIN         : return "JOIN";

        case JOB_TYPE_COPY         : return "COPY";

        case JOB_TYPE_TEXTURE      : return "TEXTURE";

        case JOB_TYPE_ASSOC        : return "ASSOC";

        case JOB_TYPE_CENTER       : return "CENTER";

        case JOB_TYPE_ADD_EMPTY_TEX: return "ADD_EMPTY_TEX";

        case JOB_TYPE_NOT_AFFECTED : return "POSTPROC COMPS";

        }

      return null;

      }

    }

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

  static class JobNode

    {

    private ArrayList<JobNode> mPrevJobs;

    private ArrayList<JobNode> mNextJobs;

    private Job mJob;

    JobNode(Job job)

      {

      mPrevJobs = new ArrayList<>();

      mNextJobs = new ArrayList<>();

      mJob      = job;

      }

    synchronized void execute()

      {

      if( mPrevJobs!=null )

        {

        JobNode node;

        int numPrev = mPrevJobs.size();

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

          {

          node = mPrevJobs.get(0);  // removeNode() rips the executed job out, thus the 0

          node.execute();

          }

        removeNode(this);

        mJob.execute();

        }

      }

    synchronized void clear()

      {

      mPrevJobs.clear();

      mPrevJobs = null;

      mNextJobs.clear();

      mNextJobs = null;

      mJob.clear();

      mJob = null;

      }

    void print(int level)

      {

      int numPrev = mPrevJobs.size();

      int numNext = mNextJobs.size();

      String str = "";

      for(int i=0; i<level; i++) str+=" ";

      str += mJob.print();

      str += (" next: "+numNext+" prev: "+numPrev);

      DistortedLibrary.logMessage("DeferredJobs: "+str);

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

        {

        JobNode node = mPrevJobs.get(i);

        node.print(level+1);

        }

      }

    }

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

  private static void removeNode(JobNode node)

    {

    mJobs.remove(node);

    JobNode jn;

    int numPrev = node.mPrevJobs.size();

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

      {

      jn = node.mPrevJobs.get(i);

      jn.mNextJobs.remove(node);

      }

    int numNext = node.mNextJobs.size();

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

      {

      jn = node.mNextJobs.get(i);

      jn.mPrevJobs.remove(node);

      }

    node.mJob.mTarget.mJobNode[0] = null;

    }

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

  static JobNode vertex(MeshBase target, VertexEffect effect)

    {

    JobNode jn = target.mJobNode[0];

    if( jn==null )

      {

      Job job = new Job(JOB_TYPE_VERTEX,target,null,effect,null,null,0,0,0,0,0,0,null);

      JobNode node = new JobNode(job);

      mJobs.add(node);

      return node;

      }

    else

      {

      if( jn.mJob.mType==JOB_TYPE_VERTEX )

        {

        jn.mJob.addEffect(effect);

        return jn;

        }

      else

        {

        Job job = new Job(JOB_TYPE_VERTEX,target,null,effect,null,null,0,0,0,0,0,0,null);

        JobNode node = new JobNode(job);

        node.mPrevJobs.add(jn);

        jn.mNextJobs.add(node);

        mJobs.add(node);

        return node;

        }

      }

    }

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

  static JobNode matrix(MeshBase target, MatrixEffect effect, int andAssoc, int ecuAssoc)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_MATRIX,target,null,null,effect,null,0,andAssoc,ecuAssoc,0,0,0,null);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode mergeTex(MeshBase target)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_MERGE_TEX,target,null,null,null,null,0,0,0,0,0,0,null);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode addEmptyTex(MeshBase target)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_ADD_EMPTY_TEX,target,null,null,null,null,0,0,0,0,0,0,null);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode mergeEff(MeshBase target)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_MERGE_EFF,target,null,null,null,null,0,0,0,0,0,0,null);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode join(MeshBase target, MeshBase[] meshes)

    {

    JobNode jn;

    Job job = new Job(JOB_TYPE_JOIN,target,meshes,null,null,null,0,0,0,0,0,0,null);

    JobNode node = new JobNode(job);

    for (MeshBase mesh : meshes)

      {

      jn = mesh.mJobNode[0];

      if( jn!=null )

        {

        node.mPrevJobs.add(jn);

        jn.mNextJobs.add(node);

        }

      }

    mJobs.add(node);

    return node;

    }

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

  static JobNode copy(MeshBase target, MeshBase mesh)

    {

    JobNode jn = mesh.mJobNode[0];

    MeshBase[] meshes = new MeshBase[1];

    meshes[0] = mesh;

    Job job = new Job(JOB_TYPE_COPY,target,meshes,null,null,null,0,0,0,0,0,0,null);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode textureMap(MeshBase target, Static4D[] maps, int comp)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_TEXTURE,target,null,null,null,maps,comp,0,0,0,0,0,null);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode effectAssoc(MeshBase target, int comp, int andAssoc, int equAssoc)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_ASSOC,target,null,null,null,null,comp,andAssoc,equAssoc,0,0,0,null);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode componentCenter(MeshBase target, int comp, float x, float y, float z)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_CENTER,target,null,null,null,null,comp,0,0,x,y,z,null);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode setNotAffected(MeshBase target, int[] comps)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_NOT_AFFECTED,target,null,null,null,null,0,0,0,0,0,0,comps);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public static void onPause()

    {

    int num = mJobs.size();

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

      {

      mJobs.get(i).clear();

      }

    mJobs.clear();

    }

  }

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

// 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_NORMAL  = 0;

  public static final int MODE_INVERTED= 1;

  public static final int MODE_FLAT    = 2;

  private static final int NUM_CACHE = 20;

  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 int extraBands, extraVertices;

  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[] tmpD = new float[mNumBands+1];

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

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

      {

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

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

      }

    tmpD[0] = tmpD[1];

    tmpD[mNumBands] = tmpD[mNumBands-1];

    tmpX[0] = 0.0f;

    tmpX[mNumBands] = 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<=mNumBands && 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[mNumBands];

    }

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

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

      }

    }

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

  private void figureOutNormalVector2D(float qx)

    {

    mVecX = mNormL[0] + qx*(mNormR[0]-mNormL[0]);

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

    }

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

  private float figureOutDerivative(float qy)

    {

    switch(mMode)

      {

      case MODE_NORMAL  : return derivative(1-qy);

      case MODE_INVERTED: return -derivative(qy);

      default           : return 0;

      }

    }

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

  private float computeElevation(int band)

    {

    switch(mMode)

      {

      case MODE_NORMAL  : return mBands[2*band+1];

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

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

      }

    }

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

  private int addStripVertex(int vertex, float qx, float qy, int band, float[] attribs1, float[] attribs2)

    {

    remainingVert--;

    float bx = mLeftX + qx*(mRightX-mLeftX);

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

    float q = 1-qy;

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

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

    float z = computeElevation(band);

    figureOutNormalVector2D(band<mNumBands ? qx : 0.5f);

    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;

    }

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

  private int createBand(int vertex, int band, float[] attribs1, float[] attribs2)

    {

    boolean fromLeft = (band%2 == 0);

    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 )

      {

      qyb = 1-qyb;

      qyt = 1-qyt;

      }

    vertex = addStripVertex(vertex, qx, qyb, band, attribs1,attribs2);

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

      {

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

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

      }

    if( n>0 )

      {

      float t = 1.0f/n;

      float dxt = fromLeft ? t : -t;

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

        {

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

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

        }

      }

    qx = 1-qx;

    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)

    {

    if( mMode==MODE_FLAT )

      {

      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.

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

 *                   'left' and 'right' vertices. If e.g. exBands=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.

 */

  public MeshBandedTriangle(float[] vL, float[] vR, float[] vT, float[] bands, float[] normL, float[] normR, int mode, int exBands, int exVertices)

    {

    super();

    mLeftX   = vL[0];

    mLeftY   = vL[1];

    mRightX  = vR[0];

    mRightY  = vR[1];

    mTopX    = vT[0];

    mTopY    = vT[1];

    mMode = mode;

    mNormL= new float[] { normL[0],normL[1] };

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

    mBands        = bands;

    mNumBands     = mBands.length/2 -1;

    extraBands    = exBands;

    extraVertices = exVertices;

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

    }

 }