commit 46ef24e57a3550b66b432550e87985484e509be2
Author: leszek <leszek@koltunski.pl>
Date:   Tue Jun 27 15:07:38 2023 +0200

    Implement MeshMultigon out of BandedTriangles (doesn't work yet)

diff --git a/src/main/java/org/distorted/library/mesh/MeshMultigon.java b/src/main/java/org/distorted/library/mesh/MeshMultigon.java
index 8a0bcfa..163dadc 100644
--- a/src/main/java/org/distorted/library/mesh/MeshMultigon.java
+++ b/src/main/java/org/distorted/library/mesh/MeshMultigon.java
@@ -46,7 +46,7 @@ public class MeshMultigon extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private boolean isUp(float[][] vertices, int polygon, int edge)
+  private int isUp(float[][] vertices, int polygon, int edge)
     {
     //android.util.Log.e("D", "checking polygon "+polygon+" edge "+edge);
 
@@ -79,26 +79,26 @@ public class MeshMultigon extends MeshBase
           //android.util.Log.e("D", "comparing v2 to "+x1+" "+y1);
           //android.util.Log.e("D", "comparing v1 to "+x2+" "+y2);
 
-          if( isSame(v2x-x1,v2y-y1) && isSame(v1x-x2,v1y-y2) ) return true;
+          if( isSame(v2x-x1,v2y-y1) && isSame(v1x-x2,v1y-y2) ) return i;
           }
         }
 
     //android.util.Log.e("D", "FALSE");
 
-    return false;
+    return -1;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private boolean[][] computeEdgesUp(float[][] vertices)
+  private int[][] computeEdgesUp(float[][] vertices)
     {
     int num = vertices.length;
-    boolean[][] up = new boolean[num][];
+    int[][] up = new int[num][];
 
     for(int i=0; i<num; i++)
       {
       int len = vertices[i].length/2;
-      up[i] = new boolean[len];
+      up[i] = new int[len];
       for(int j=0; j<len; j++)
         {
         up[i][j] = isUp(vertices,i,j);
@@ -236,6 +236,114 @@ public class MeshMultigon extends MeshBase
     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 )
+      {
+      int eupp = edges[prev];
+      int eupn = edges[next];
+
+      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];
+
+      if( eupp<0 )
+        {
+        normL[0]=vT[0]-vL[0];
+        normL[1]=vT[1]-vL[1];
+        }
+      else
+        {
+        normL[0]= v[2*prev  ] - v[2*curr  ];
+        normL[1]= v[2*prev+1] - v[2*curr+1];
+        }
+
+      if( eupn<0 )
+        {
+        normR[0]=vT[0]-vR[0];
+        normR[1]=vT[1]-vR[1];
+        }
+      else
+        {
+        int nnxt= next==len-1 ? 0 : next+1;
+        normL[0]= v[2*nnxt  ] - v[2*next  ];
+        normL[1]= v[2*nnxt+1] - v[2*next+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 )
+        {
+        return MeshBandedTriangle.MODE_FLAT;
+        }
+      else
+        {
+        float dx=v[2*curr]-v[2*next];
+        float dy=v[2*curr+1]-v[2*next+1];
+
+        normL[0]=dx;
+        normL[1]=dy;
+        normR[0]=dx;
+        normR[1]=dy;
+
+        return MeshBandedTriangle.MODE_INVERTED;
+        }
+      }
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -246,57 +354,41 @@ public class MeshMultigon extends MeshBase
  *
  * @param vertices   an array of arrays, each specifying vertices of a single polygon.
  * @param band       see MeshPolygon. Shared among all polygons.
- * @param exIndex    see MeshPolygon. Shared among all polygons.
+ * @param exBands    see MeshPolygon. Shared among all polygons.
  * @param exVertices see MeshPolygon. Shared among all polygons.
- * @param centers    for each polygon, coordinates of its center.
  */
-  public MeshMultigon(float[][] vertices, float[] band, int exIndex, int exVertices, float[][] centers)
+  public MeshMultigon(float[][] vertices, float[] band, int exBands, int exVertices)
     {
     super();
 
-    int numPolygons = vertices.length;
-    MeshPolygon[] meshes = new MeshPolygon[numPolygons];
-    boolean[][] edgesUp = computeEdgesUp(vertices);
-    boolean[][] vertsUp = computeVertsUp(vertices);
-
-    for(int i=0; i<numPolygons; i++)
-      meshes[i] = new MeshPolygon(vertices[i],band,edgesUp[i],vertsUp[i],exIndex,exVertices,centers[i][0],centers[i][1]);
-
-    join(meshes);
-    mergeEffComponents();
-    mergeTexComponents();
-    }
+    int numTriangles=0;
+    for(float[] vertex : vertices) numTriangles+=vertex.length/2;
+    MeshBandedTriangle[] triangles = new MeshBandedTriangle[numTriangles];
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Auto-create the centers to be the centers of gravity of each polygon.
- */
+    int[][] edgesUp = computeEdgesUp(vertices);
+    boolean[][] vertsUp = computeVertsUp(vertices);
+    float[][] centers = computeCenters(vertices);
 
-  public MeshMultigon(float[][] vertices, float[] band, int exIndex, int exVertices)
-    {
-    super();
+    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 numPolygons = vertices.length;
-    MeshPolygon[] meshes = new MeshPolygon[numPolygons];
-    boolean[][] edgesUp = computeEdgesUp(vertices);
-    boolean[][] vertsUp = computeVertsUp(vertices);
+    int index=0,len = vertices.length;
 
-    for(int i=0; i<numPolygons; i++)
+    for(int i=0; i<len; i++)
       {
-      float[] v = vertices[i];
-      int num = v.length/2;
-      float xsum=0, ysum = 0;
+      int num=vertices[i].length/2;
 
       for(int j=0; j<num; j++)
         {
-        xsum += v[2*j];
-        ysum += v[2*j+1];
+        int mode=computeMode(vL, vR, vT, normL, normL, edgesUp, vertsUp,vertices,centers, i,j);
+        triangles[index++] = new MeshBandedTriangle(vL, vR, vT, band, normL, normR, mode, exBands, exVertices);
         }
-
-      meshes[i] = new MeshPolygon(v,band,edgesUp[i],vertsUp[i],exIndex,exVertices,xsum/num,ysum/num);
       }
 
-    join(meshes);
+    join(triangles);
     mergeEffComponents();
     mergeTexComponents();
     }