Distorted Android

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

// Copyright 2023 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 java.util.ArrayList;

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

/**

 * Create a 'multigon' mesh - a union of several polygons.

 *

 * <p>

 * Specify several lists of vertices. Each list defines one polygon. (@see MeshPolygon).

 * If two such polygons share an edge (or several edges) then the edge in both of them is

 * marked 'up'.

 */

public class MeshMultigon extends MeshBase

  {

  private static final float MAX_ERROR = 0.000001f;

  private float[][][] mOuterAndHoleVertices;

  private float[][][] mEdgeVectors;

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

  private static boolean isSame(float dx, float dy)

    {

    return (dx*dx + dy*dy < MAX_ERROR);

    }

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

  private static int isUp(float[][][] vertices, int polygon, int edge)

    {

    float[][] p= vertices[polygon];

    int lenP = p.length;

    int len  = vertices.length;

    int next = (edge==lenP-1 ? 0 : edge+1);

    float v1x = p[edge][0];

    float v1y = p[edge][1];

    float v2x = p[next][0];

    float v2y = p[next][1];

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

      if( i!=polygon )

        {

        int num = vertices[i].length;

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

          {

          int n = (j==num-1 ? 0 : j+1);

          float[][] v = vertices[i];

          float x1 = v[j][0];

          float y1 = v[j][1];

          float x2 = v[n][0];

          float y2 = v[n][1];

          if( isSame(v2x-x1,v2y-y1) && isSame(v1x-x2,v1y-y2) ) return i;

          }

        }

    return -1;

    }

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

  private static float[] detectFirstOuterVertex(float[][][] vertices)

    {

    float X = -Float.MAX_VALUE;

    int I=0,J=0, len = vertices.length;

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

      {

      float[][] v = vertices[i];

      int num = v.length;

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

        if( v[j][0]>X )

          {

          X = v[j][0];

          I = i;

          J = j;

          }

      }

    float[] v = vertices[I][J];

    return new float[] {v[0],v[1]};

    }

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

  private static double computeAngle(float x1,float y1, float x2, float y2)

    {

    double diff = Math.atan2(y2,x2)-Math.atan2(y1,x1);

    return diff<0 ? diff+(2*Math.PI) : diff;

    }

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

  private static float[] detectNextOuterVertex(float[][][] vertices, float[] curr, float[] vect, int[][] edgesUp)

    {

    double maxAngle = 0;

    float x=0, y=0;

    int numC = vertices.length;

    for( int c=0; c<numC; c++ )

      {

      float[][] vert = vertices[c];

      int numV = vert.length;

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

        {

        float xc = vert[v][0];

        float yc = vert[v][1];

        if( edgesUp[c][v]<0 && isSame(xc-curr[0],yc-curr[1]) )

          {

          int n = (v==numV-1 ? 0 : v+1);

          float xn = vert[n][0];

          float yn = vert[n][1];

          double angle = computeAngle(vect[0], vect[1], xn-xc, yn-yc);

          if (angle > maxAngle)

            {

            maxAngle = angle;

            x = xn;

            y = yn;

            }

          break;

          }

        }

      }

    return new float[] {x,y};

    }

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

  private static int getNextIndex(float[][][] vertices, int[][] unclaimedEdges, int currIndex, int numHoleVerts)

    {

    int[] currEdge = unclaimedEdges[currIndex];

    int currP = currEdge[0];

    int currE = currEdge[1];

    float[][] polygon = vertices[currP];

    int numV = polygon.length;

    int nextE= currE<numV-1 ? currE+1 : 0;

    float x = polygon[nextE][0];

    float y = polygon[nextE][1];

    for(int e=0; e<numHoleVerts; e++)

      {

      int[] edge = unclaimedEdges[e];

      if( edge[2]==1 )

        {

        int po = edge[0];

        int ed = edge[1];

        float cx = vertices[po][ed][0];

        float cy = vertices[po][ed][1];

        if( isSame(cx-x,cy-y) )

          {

          edge[2] = 0;

          return e;

          }

        }

      }

    return -1;

    }

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

  private static int generateHole(float[][][] vertices, int[][] unclaimedEdges, float[][] output, int[][] edgesUp, int holeNumber, int numHoleVerts)

    {

    int firstIndex=-1;

    for(int e=0; e<numHoleVerts; e++)

      if( unclaimedEdges[e][2]==1 )

        {

        firstIndex = e;

        break;

        }

    int currIndex = firstIndex;

    int nextIndex=-1;

    int numAdded = 0;

    while( nextIndex!=firstIndex )

      {

      nextIndex = getNextIndex(vertices,unclaimedEdges,currIndex,numHoleVerts);

      int p = unclaimedEdges[nextIndex][0];

      int v = unclaimedEdges[nextIndex][1];

      edgesUp[p][v] = -holeNumber-2;

      currIndex = nextIndex;

      int[] e = unclaimedEdges[nextIndex];

      float[] ve = vertices[e[0]][e[1]];

      output[numAdded][0] = ve[0];

      output[numAdded][1] = ve[1];

      numAdded++;

      }

    return numAdded;

    }

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

  private static boolean doesNotBelongToOuter(float x, float y, float[][] outer)

    {

    for(float[] v : outer)

      if(isSame(x-v[0], y-v[1])) return false;

    return true;

    }

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

  private static float[][][] computeHoles(float[][][] vertices, int[][] edgesUp, float[][] outer, int numHoleVerts)

    {

    int[][] unclaimedEdges = new int[numHoleVerts][];

    int index = 0;

    int numPoly = vertices.length;

    for(int p=0; p<numPoly; p++)

      {

      float[][] ve = vertices[p];

      int numEdges = ve.length;

      for(int e=0; e<numEdges; e++)

        if( edgesUp[p][e]<0 )

          {

          float x1 = ve[e][0];

          float y1 = ve[e][1];

          int n = e<numEdges-1 ? e+1 : 0;

          float x2 = ve[n][0];

          float y2 = ve[n][1];

          // yes, we need to check both ends of the edge - otherwise the

          // following 3x3 situation (x - wall, o - hole ) does not work:

          // x x x

          // x o x

          // o x x

          if( doesNotBelongToOuter(x1,y1,outer) || doesNotBelongToOuter(x2,y2,outer) )

            {

            unclaimedEdges[index]=new int[] {p, e, 1};

            index++;

            }

          }

      }

    int remaining = numHoleVerts;

    ArrayList<float[][]> holes = new ArrayList<>();

    float[][] output = new float[numHoleVerts][2];

    int numHoles = 0;

    while(remaining>0)

      {

      int num = generateHole(vertices,unclaimedEdges,output,edgesUp,numHoles,numHoleVerts);

      remaining -= num;

      numHoles++;

      float[][] hole = new float[num][2];

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

        {

        hole[h][0] = output[h][0];

        hole[h][1] = output[h][1];

        }

      holes.add(hole);

      }

    float[][][] ret = new float[numHoles][][];

    for(int h=0; h<numHoles; h++) ret[h] = holes.remove(0);

    return ret;

    }

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

  private static int countEdgesDown(int[][] edgesUp)

    {

    int numEdgesDown = 0;

    for(int[] edgeUp : edgesUp)

      for(int edge : edgeUp)

        if( edge<0 ) numEdgesDown++;

    return numEdgesDown;

    }

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

  private float[] produceNormalVector(float[][] outerAndHole, float xs, float ys)

    {

    int vCurr,len = outerAndHole.length;

    for(vCurr=0; vCurr<len; vCurr++)

      {

      float[] vs = outerAndHole[vCurr];

      if( isSame(vs[0]-xs,vs[1]-ys) ) break;

      }

    if( vCurr==len ) android.util.Log.e("D", "ERROR in produceNormalVector!!");

    int vPrev = vCurr==0 ? len-1 : vCurr-1;

    int vNext = vCurr>=len-1 ? 0 : vCurr+1;

    float[] vp = outerAndHole[vPrev];

    float[] vn = outerAndHole[vNext];

    return new float[] { vp[1]-vn[1], vn[0]-vp[0] };

    }

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

  private float[] produceNormalVector(float[][] outerAndHole, float xs, float ys, float xe, float ye)

    {

    int vCurr,len = outerAndHole.length;

    for(vCurr=0; vCurr<len; vCurr++)

      {

      float[] vs = outerAndHole[vCurr];

      if( isSame(vs[0]-xs,vs[1]-ys) )

        {

        int vNext = vCurr==len-1 ? 0 : vCurr+1;

        float[] ve = outerAndHole[vNext];

        if( isSame(ve[0]-xe,ve[1]-ye) ) break;

        }

      }

    int vPrev = vCurr==0 ? len-1 : vCurr-1;

    int vNext = vCurr>=len-1 ? 0 : vCurr+1;

    float[] vp = outerAndHole[vPrev];

    float[] vn = outerAndHole[vNext];

    return new float[] { vp[1]-vn[1], vn[0]-vp[0] };

    }

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

  private void computeEdgeVectors(float[][][] vertices, int[][] edgesUp)

    {

    int numPoly = vertices.length;

    mEdgeVectors = new float[numPoly][][];

    for(int c=0; c<numPoly; c++)

      {

      float[][] polygon = vertices[c];

      int numV = polygon.length;

      mEdgeVectors[c] = new float[numV][];

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

        {

        int edgeUp = edgesUp[c][v];

        float xs = polygon[v][0];

        float ys = polygon[v][1];

        int n = v==numV-1 ? 0 : v+1;

        float xe = polygon[n][0];

        float ye = polygon[n][1];

        if( edgeUp<0 ) // external edge, normal vector

          {

          float[][] verts = mOuterAndHoleVertices[-edgeUp-1];

          mEdgeVectors[c][v] = produceNormalVector(verts,xs,ys,xe,ye);

          }

        else // internal edge - but the vertex that begins it might still be outer!

          {

          int numComp = retIndexBelongs(xs,ys);

          if( numComp<0 ) mEdgeVectors[c][v] = null;

          else

            {

            float[][] verts = mOuterAndHoleVertices[numComp];

            mEdgeVectors[c][v] = produceNormalVector(verts,xs,ys);

            }

          }

        }

      }

    }

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

// ret:

// -1  : vertex (x,y) is 'inner' (does not belong to outer vertices or any hole)

// N>=0: vertex (x,y) is outer [ N==0 --> outer, 1--> 1sr hole, 2 --> 2nd hole, etc ]

  private int retIndexBelongs(float x, float y)

    {

    int numOuterComponents = mOuterAndHoleVertices.length;

    for(int c=0; c<numOuterComponents; c++)

      {

      float[][] comp = mOuterAndHoleVertices[c];

      for(float[] v : comp)

        if( isSame(x-v[0],y-v[1]) ) return c;

      }

    return -1;

    }

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

  private float[] retOuterVector(int component, int vert)

    {

    return mEdgeVectors[component][vert];

    }

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

  private boolean[][] computeVertsUp(float[][][] vertices)

    {

    int numPoly = vertices.length;

    boolean[][] up = new boolean[numPoly][];

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

      {

      float[][] v = vertices[i];

      int len = v.length;

      up[i] = new boolean[len];

      for(int j=0; j<len; j++)

        {

        float[] vect = retOuterVector(i,j);

        up[i][j] = (vect==null);

        }

      }

    return up;

    }

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

  private float[] computeCenter(float[][] vertices)

    {

    int num = vertices.length;

    float[] ret = new float[2];

    for(float[] vertex : vertices)

      {

      ret[0] += vertex[0];

      ret[1] += vertex[1];

      }

    ret[0] /= num;

    ret[1] /= num;

    return ret;

    }

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

  private float[][] computeCenters(float[][][] vertices)

    {

    int num = vertices.length;

    float[][] ret = new float[num][];

    for(int i=0; i<num; i++) ret[i] = computeCenter(vertices[i]);

    return ret;

    }

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

  private int computeMode(float[] vL, float[] vR, float[] vT, float[] normL, float[] normR,

                          int[][] edgesUp, boolean[][] vertsUp, float[][][] vertices, float[][] centers, int component, int curr)

    {

    float[][] v = vertices[component];

    int[] edges = edgesUp[component];

    int numPoly = v.length;

    int next= curr==numPoly-1 ? 0 : curr+1;

    int prev= curr==0 ? numPoly-1 : curr-1;

    int eupc = edges[curr];

    if( eupc<0 )

      {

      vL[0] = v[curr][0];

      vL[1] = v[curr][1];

      vR[0] = v[next][0];

      vR[1] = v[next][1];

      vT[0] = centers[component][0];

      vT[1] = centers[component][1];

      float[] outerL = retOuterVector(component,curr);

      float[] outerR = retOuterVector(component,next);

      if( outerL!=null && outerR!=null )

        {

        normL[0] = -outerL[0];

        normL[1] = -outerL[1];

        normR[0] = -outerR[0];

        normR[1] = -outerR[1];

        }

      else

        {

        int eupp = edges[prev];

        int eupn = edges[next];

        if( eupp<0 )

          {

          normL[0]= vL[0]-vT[0];

          normL[1]= vL[1]-vT[1];

          }

        else

          {

          normL[0]= v[curr][0] - v[prev][0];

          normL[1]= v[curr][1] - v[prev][1];

          }

        if( eupn<0 )

          {

          normR[0]= vR[0]-vT[0];

          normR[1]= vR[1]-vT[1];

          }

        else

          {

          int nnxt= next==numPoly-1 ? 0 : next+1;

          normR[0]= v[next][0] - v[nnxt][0];

          normR[1]= v[next][1] - v[nnxt][1];

          }

        }

      return MeshBandedTriangle.MODE_NORMAL;

      }

    else

      {

      vL[0] = centers[eupc][0];

      vL[1] = centers[eupc][1];

      vR[0] = centers[component][0];

      vR[1] = centers[component][1];

      vT[0] = v[curr][0];

      vT[1] = v[curr][1];

      boolean vup = vertsUp[component][curr];

      if( vup )

        {

        normL[0]=0;

        normL[1]=1;

        normR[0]=0;

        normR[1]=1;

        return MeshBandedTriangle.MODE_FLAT;

        }

      else

        {

        float[] outerT = retOuterVector(component,curr);

        if( outerT!=null )

          {

          normL[0]= outerT[0];

          normL[1]= outerT[1];

          normR[0]= outerT[0];

          normR[1]= outerT[1];

          }

        else

          {

          float dx = v[next][0]-v[curr][0];

          float dy = v[next][1]-v[curr][1];

          normL[0]= dx;

          normL[1]= dy;

          normR[0]= dx;

          normR[1]= dy;

          }

        return MeshBandedTriangle.MODE_INVERTED;

        }

      }

    }

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

// PUBLIC API

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

  public static int[][] computeEdgesUp(float[][][] vertices)

    {

    int numPoly = vertices.length;

    int[][] up = new int[numPoly][];

    for(int p=0; p<numPoly; p++)

      {

      int numEdges = vertices[p].length;

      up[p] = new int[numEdges];

      for(int e=0; e<numEdges; e++) up[p][e] = isUp(vertices,p,e);

      }

    return up;

    }

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

  public static float[][][] computeOuterAndHoleVertices(float[][][] vertices, int[][] edgesUp)

    {

    ArrayList<float[]> tmp = new ArrayList<>();

    float[] vect = new float[] {1,0};

    float[] first= detectFirstOuterVertex(vertices);

    float[] next = first;

    do

      {

      float[] prev = next;

      next = detectNextOuterVertex(vertices,next,vect,edgesUp);

      vect[0] = prev[0]-next[0];

      vect[1] = prev[1]-next[1];

      tmp.add(next);

      }

    while( !isSame(next[0]-first[0],next[1]-first[1]) );

    int numOuterVerts= tmp.size();

    float[][] outerVertices = new float[numOuterVerts][];

    for(int i=0; i<numOuterVerts; i++) outerVertices[i] = tmp.remove(0);

    int numEdgesDown = countEdgesDown(edgesUp);

    int numHoleVerts= numEdgesDown-numOuterVerts;

    float[][][] holeVertices=null;

    if( numHoleVerts>0 ) holeVertices = computeHoles(vertices,edgesUp,outerVertices,numHoleVerts);

    int numHoles = holeVertices==null ? 0 : holeVertices.length;

    float[][][] ret = new float[1+numHoles][][];

    ret[0] = outerVertices;

    for(int i=0; i<numHoles; i++) ret[i+1] = holeVertices[i];

    return ret;

    }

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

  private void printVertices(float[][][] vertices)

    {

    StringBuilder sb = new StringBuilder();

    int loop=0;

    for(float[][] vert : vertices)

      {

      sb.append("Loop ");

      sb.append(loop);

      sb.append(" : { ");

      loop++;

      int num=0;

      for( float[] v : vert)

        {

        if( num>=0 ) sb.append(", ");

        num++;

        sb.append(v[0]);

        sb.append(", ");

        sb.append(v[1]);

        }

      sb.append(" }\n");

      }

    android.util.Log.e("D", "vertices: \n"+sb);

    }

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

  private void printBand(float[] band)

    {

    StringBuilder sb = new StringBuilder();

    for(float v : band)

      {

      sb.append(v);

      sb.append("f, ");

      }

    android.util.Log.e("D", "band: \n"+sb);

    }

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

/**

 * Specify several lists of vertices. Each list defines one polygon. (@see MeshPolygon).

 * If two such polygons share an edge (or several edges) then the edge in both of them is

 * marked 'up'.

 *

 * @param vertices   an array float[][]s, each specifying vertices of a single polygon.

 * @param band       see MeshPolygon. Shared among all polygons.

 * @param exBands    see MeshPolygon. Shared among all polygons.

 * @param exVertices see MeshPolygon. Shared among all polygons.

 */

  public MeshMultigon(float[][][] vertices, float[] band, int exBands, int exVertices)

    {

    super();

    int numTriangles=0;

    for(float[][] vertex : vertices) numTriangles+=vertex.length;

    MeshBandedTriangle[] triangles = new MeshBandedTriangle[numTriangles];

    int[][] edgesUp = computeEdgesUp(vertices);

    mOuterAndHoleVertices = computeOuterAndHoleVertices(vertices,edgesUp);

    computeEdgeVectors(vertices,edgesUp);

    boolean[][] vertsUp = computeVertsUp(vertices);

    float[][] centers = computeCenters(vertices);

    float[] vL = new float[2];

    float[] vR = new float[2];

    float[] vT = new float[2];

    float[] normL = new float[2];

    float[] normR = new float[2];

    int index=0,len = vertices.length;

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

      {

      int num=vertices[i].length;

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

        {

        int mode=computeMode(vL, vR, vT, normL, normR, edgesUp, vertsUp,vertices,centers, i,j);

        triangles[index++] = new MeshBandedTriangle(vL, vR, vT, band, normL, normR, mode, exBands, exVertices);

        }

      }

    join(triangles);

    mergeEffComponents();

    mergeTexComponents();

    }

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

/**

 * Copy constructor.

 */

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

    {

    return new MeshMultigon(this,deep);

    }

 }