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

  private float[][] mOuterVectors;

  private int mNumOuter;

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

  private boolean isSame(float dx, float dy)

    {

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

    }

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

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

    {

    float[] p= vertices[polygon];

    int lenP = p.length/2;

    int len  = vertices.length;

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

    float v1x = p[2*edge  ];

    float v1y = p[2*edge+1];

    float v2x = p[2*next  ];

    float v2y = p[2*next+1];

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

      if( i!=polygon )

        {

        int num = vertices[i].length/2;

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

          {

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

          float[] v = vertices[i];

          float x1 = v[2*j  ];

          float y1 = v[2*j+1];

          float x2 = v[2*n  ];

          float y2 = v[2*n+1];

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

          }

        }

    return -1;

    }

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

  private int[][] computeEdgesUp(float[][] vertices)

    {

    int num = vertices.length;

    int[][] up = new int[num][];

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

      {

      int len = vertices[i].length/2;

      up[i] = new int[len];

      for(int j=0; j<len; j++) up[i][j] = isUp(vertices,i,j);

      }

    return up;

    }

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

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

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

        if(v[2*j]>X)

          {

          X = v[2*j];

          I = i;

          J = j;

          }

      }

    float[] v = vertices[I];

    return new float[] {v[2*J],v[2*J+1]};

    }

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

  private 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 float[] detectNextOuterVertex(float[][] vertices, float[] curr, float[] vect)

    {

    double minAngle = 2*Math.PI;

    float x=0, y=0;

    for( float[] v : vertices )

      {

      int num = v.length/2;

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

        {

        float xc = v[2*j];

        float yc = v[2*j+1];

        if( isSame(xc-curr[0],yc-curr[1]) )

          {

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

          float xn = v[2*n];

          float yn = v[2*n+1];

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

          if (angle < minAngle)

            {

            minAngle = angle;

            x = xn;

            y = yn;

            }

          break;

          }

        }

      }

    return new float[] {x,y};

    }

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

  private void computeOuterVectors()

    {

    mOuterVectors = new float[mNumOuter][];

    for(int curr=0; curr<mNumOuter; curr++)

      {

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

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

      float[] vP = mOuterVertices[prev];

      float[] vN = mOuterVertices[next];

      float dx = vP[0]-vN[0];

      float dy = vP[1]-vN[1];

      mOuterVectors[curr] = new float[] { dy,-dx };

      }

    }

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

  private void computeOuterVertices(float[][] vertices)

    {

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

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

    mNumOuter = tmp.size();

    mOuterVertices = new float[mNumOuter][];

    for(int i=0; i<mNumOuter; i++) mOuterVertices[i] = tmp.remove(0);

    }

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

  private int belongsToOuter(float x, float y)

    {

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

      {

      float[] v = mOuterVertices[i];

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

      }

    return -1;

    }

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

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

    {

    int num = vertices.length;

    boolean[][] up = new boolean[num][];

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

      {

      float[] v = vertices[i];

      int len = v.length/2;

      up[i] = new boolean[len];

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

        {

        int vert = belongsToOuter(v[2*j],v[2*j+1]);

        up[i][j] = (vert==-1);

        }

      }

    return up;

    }

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

  private float[] computeCenter(float[] vertices)

    {

    int num = vertices.length/2;

    float[] ret = new float[2];

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

      {

      ret[0] += vertices[2*i];

      ret[1] += vertices[2*i+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 len = v.length /2;

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

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

    int eupc = edges[curr];

    if( eupc<0 )

      {

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

      vL[1] = v[2*curr+1];

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

      vR[1] = v[2*next+1];

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

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

      int outerL = belongsToOuter(vL[0],vL[1]);

      int outerR = belongsToOuter(vR[0],vR[1]);

      if( outerL>=0 && outerR>=0 )

        {

        float[] vl =mOuterVectors[outerL];

        normL[0] = -vl[0];

        normL[1] = -vl[1];

        float[] vr =mOuterVectors[outerR];

        normR[0] = -vr[0];

        normR[1] = -vr[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[2*curr  ] - v[2*prev  ];

          normL[1]= v[2*curr+1] - v[2*prev+1];

          }

        if( eupn<0 )

          {

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

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

          }

        else

          {

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

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

          normR[1]= v[2*next+1] - v[2*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[2*curr];

      vT[1] = v[2*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

        {

        int outerT = belongsToOuter(vT[0],vT[1]);

        if( outerT>=0 )

          {

          float[] vt =mOuterVectors[outerT];

          normL[0]= vt[0];

          normL[1]= vt[1];

          normR[0]= vt[0];

          normR[1]= vt[1];

          }

        else

          {

          float dx = v[2*next  ]-v[2*curr  ];

          float dy = v[2*next+1]-v[2*curr+1];

          normL[0]= dx;

          normL[1]= dy;

          normR[0]= dx;

          normR[1]= dy;

          }

        return MeshBandedTriangle.MODE_INVERTED;

        }

      }

    }

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

// PUBLIC API

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

/**

 * 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 of arrays, 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/2;

    MeshBandedTriangle[] triangles = new MeshBandedTriangle[numTriangles];

    computeOuterVertices(vertices);

    computeOuterVectors();

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

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

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

    }

 }