Distorted Android

  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 boolean[] mEdgeUp;

  //private float[] mBandQuot;

/*

*/

  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 int addVertex(int vertex, int polyBand, int polyVertex, int polyEndVer, float quot,

                        int edgeShape, float[] attribs1, float[] attribs2)

    float zEdge;

    switch(edgeShape)

      case SHAPE_DD : zEdge = 0.0f;

                      break;

      case SHAPE_UU : zEdge = mPolygonBands[2*mNumPolygonBands-1];

                      break;

      case SHAPE_DU : zEdge = quot>=0.5f ? mPolygonBands[2*mNumPolygonBands-1] : computeZEdge(1-2*quot);

                      break;

      case SHAPE_UD : zEdge = quot<=0.5f ? mPolygonBands[2*mNumPolygonBands-1] : computeZEdge(2*quot-1);

                      break;

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

                      break;

    float q =  mPolygonBands[2*polyBand];

    float x = q*xEdge;

    float y = q*yEdge;

    float z = q*zEdge + mPolygonBands[2*polyBand+1];

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

  private void addVertexNormal(int vertex, int end1, int end2, float[] attribs1)

    {

    android.util.Log.e("D", "vertex="+vertex+" end1="+end1+" end2="+end2);

    int iv = VERT1_ATTRIBS*vertex + POS_ATTRIB;

    int i1 = VERT1_ATTRIBS*end1   + POS_ATTRIB;

    int i2 = VERT1_ATTRIBS*end2   + POS_ATTRIB;

    float vx = attribs1[iv  ];

    float vy = attribs1[iv+1];

    float vz = attribs1[iv+2];

    float x1 = attribs1[i1  ];

    float y1 = attribs1[i1+1];

    float z1 = attribs1[i1+2];

    float x2 = attribs1[i2  ];

    float y2 = attribs1[i2+1];

    float z2 = attribs1[i2+2];

    float dx1 = vx-x1;

    float dy1 = vy-y1;

    float dz1 = vz-z1;

    float dx2 = vx-x2;

    float dy2 = vy-y2;

    float dz2 = vz-z2;

    float cx = dy1*dz2 - dz1*dy2;

    float cy = dz1*dx2 - dx1*dz2;

    float cz = dx1*dy2 - dy1*dx2;

    float len = (float)Math.sqrt(cx*cx + cy*cy + cz*cz);

    int index = VERT1_ATTRIBS*vertex + NOR_ATTRIB;

    attribs1[index  ] = cx/len;

    attribs1[index+1] = cy/len;

    attribs1[index+2] = cz/len;

    }

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

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

    int initVertex = vertex;

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

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

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

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

      }

    if( polyVertex==0 )

      {

      if( polyBand>0 ) addVertexNormal(initVertex,initVertex+3,initVertex+2,attribs1);

      else             addVertexNormal(initVertex,initVertex+2,initVertex+1,attribs1);

      }

    else

      {

      addVertexNormal(initVertex,initVertex-1,initVertex+1,attribs1);

      }

    boolean lower = (polyVertex>0 || polyBand>0);

    for(int index=initVertex+1; index<vertex-1; index++)

      {

      addVertexNormal(index,(lower ? index+2 : index-1),index+1,attribs1);

      lower = !lower;

    addVertexNormal(vertex-1,vertex-2,vertex-3,attribs1);

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

  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 l = mEdgeUp[prev];

    boolean r = mEdgeUp[next];

    return l ? (r ? SHAPE_UU : SHAPE_UD) : (r ? SHAPE_DU : SHAPE_DUD);

    }

    int[] edgeShape = new int[mNumPolygonVertices];

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

      edgeShape[polyVertex] = computeEdgeShape(polyVertex);

        android.util.Log.e("D", "creating strip polyBand="+polyBand+" polyVertex="+polyVertex+" : "+vertex);

        vertex = createBandStrip(vertex,polyBand,polyVertex,edgeShape[polyVertex],attribs1,attribs2);

        android.util.Log.e("D", "  "+vertex);

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

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

    mEdgeUp            = edgeUp;

    //computeCache();

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

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