commit bc6adbb5d77358f7a351a4e9119b179d4b67fd20
Author: leszek <leszek@koltunski.pl>
Date:   Wed Aug 2 00:20:39 2023 +0200

    also change the fullVertices to the same format

diff --git a/src/main/java/org/distorted/library/mesh/MeshMultigon.java b/src/main/java/org/distorted/library/mesh/MeshMultigon.java
index e974c8f..c6e1cf1 100644
--- a/src/main/java/org/distorted/library/mesh/MeshMultigon.java
+++ b/src/main/java/org/distorted/library/mesh/MeshMultigon.java
@@ -47,31 +47,31 @@ public class MeshMultigon extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private static int isUp(float[][] vertices, int polygon, int edge)
+  private static int isUp(float[][][] vertices, int polygon, int edge)
     {
-    float[] p= vertices[polygon];
-    int lenP = p.length/2;
+    float[][] p= vertices[polygon];
+    int lenP = p.length;
     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];
+    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/2;
+        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[2*j  ];
-          float y1 = v[2*j+1];
-          float x2 = v[2*n  ];
-          float y2 = v[2*n+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;
           }
@@ -82,27 +82,27 @@ public class MeshMultigon extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private static float[] detectFirstOuterVertex(float[][] vertices)
+  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/2;
+      float[][] v = vertices[i];
+      int num = v.length;
 
       for(int j=0; j<num; j++)
-        if(v[2*j]>X)
+        if( v[j][0]>X )
           {
-          X = v[2*j];
+          X = v[j][0];
           I = i;
           J = j;
           }
       }
 
-    float[] v = vertices[I];
-    return new float[] {v[2*J],v[2*J+1]};
+    float[] v = vertices[I][J];
+    return new float[] {v[0],v[1]};
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -115,7 +115,7 @@ public class MeshMultigon extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private static float[] detectNextOuterVertex(float[][] vertices, float[] curr, float[] vect, int[][] edgesUp)
+  private static float[] detectNextOuterVertex(float[][][] vertices, float[] curr, float[] vect, int[][] edgesUp)
     {
     double maxAngle = 0;
     float x=0, y=0;
@@ -123,19 +123,19 @@ public class MeshMultigon extends MeshBase
 
     for( int c=0; c<numC; c++ )
       {
-      float[] vert = vertices[c];
-      int numV = vert.length/2;
+      float[][] vert = vertices[c];
+      int numV = vert.length;
 
       for( int v=0; v<numV; v++)
         {
-        float xc = vert[2*v];
-        float yc = vert[2*v+1];
+        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[2*n];
-          float yn = vert[2*n+1];
+          float xn = vert[n][0];
+          float yn = vert[n][1];
 
           double angle = computeAngle(vect[0], vect[1], xn-xc, yn-yc);
 
@@ -156,17 +156,17 @@ public class MeshMultigon extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private static int getNextIndex(float[][] vertices, int[][] unclaimedEdges, int currIndex, int numHoleVerts)
+  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/2;
+    float[][] polygon = vertices[currP];
+    int numV = polygon.length;
     int nextE= currE<numV-1 ? currE+1 : 0;
 
-    float x = polygon[2*nextE];
-    float y = polygon[2*nextE+1];
+    float x = polygon[nextE][0];
+    float y = polygon[nextE][1];
 
     for(int e=0; e<numHoleVerts; e++)
       {
@@ -177,8 +177,8 @@ public class MeshMultigon extends MeshBase
         int po = edge[0];
         int ed = edge[1];
 
-        float cx = vertices[po][2*ed];
-        float cy = vertices[po][2*ed+1];
+        float cx = vertices[po][ed][0];
+        float cy = vertices[po][ed][1];
 
         if( isSame(cx-x,cy-y) )
           {
@@ -193,7 +193,7 @@ public class MeshMultigon extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private static int generateHole(float[][] vertices, int[][] unclaimedEdges, float[][] output, int[][] edgesUp, int holeNumber, int numHoleVerts)
+  private static int generateHole(float[][][] vertices, int[][] unclaimedEdges, float[][] output, int[][] edgesUp, int holeNumber, int numHoleVerts)
     {
     int firstIndex=-1;
 
@@ -217,9 +217,9 @@ public class MeshMultigon extends MeshBase
       edgesUp[p][v] = -holeNumber-2;
       currIndex = nextIndex;
       int[] e = unclaimedEdges[nextIndex];
-      float[] polygon = vertices[e[0]];
-      output[numAdded][0] = polygon[2*e[1]];
-      output[numAdded][1] = polygon[2*e[1]+1];
+      float[] ve = vertices[e[0]][e[1]];
+      output[numAdded][0] = ve[0];
+      output[numAdded][1] = ve[1];
       numAdded++;
       }
 
@@ -238,7 +238,7 @@ public class MeshMultigon extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private static float[][][] computeHoles(float[][] vertices, int[][] edgesUp, float[][] outer, int numHoleVerts)
+  private static float[][][] computeHoles(float[][][] vertices, int[][] edgesUp, float[][] outer, int numHoleVerts)
     {
     int[][] unclaimedEdges = new int[numHoleVerts][];
     int index = 0;
@@ -246,18 +246,18 @@ public class MeshMultigon extends MeshBase
 
     for(int p=0; p<numPoly; p++)
       {
-      float[] ve = vertices[p];
-      int numEdges = ve.length/2;
+      float[][] ve = vertices[p];
+      int numEdges = ve.length;
 
       for(int e=0; e<numEdges; e++)
         if( edgesUp[p][e]<0 )
           {
-          float x1 = ve[2*e];
-          float y1 = ve[2*e+1];
+          float x1 = ve[e][0];
+          float y1 = ve[e][1];
 
           int n = e<numEdges-1 ? e+1 : 0;
-          float x2 = ve[2*n];
-          float y2 = ve[2*n+1];
+          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:
@@ -315,13 +315,13 @@ public class MeshMultigon extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private float[] produceNormalVector(float[][] verts, float xs, float ys)
+  private float[] produceNormalVector(float[][] outerAndHole, float xs, float ys)
     {
-    int vCurr,len = verts.length;
+    int vCurr,len = outerAndHole.length;
 
     for(vCurr=0; vCurr<len; vCurr++)
       {
-      float[] vs = verts[vCurr];
+      float[] vs = outerAndHole[vCurr];
       if( isSame(vs[0]-xs,vs[1]-ys) ) break;
       }
 
@@ -329,59 +329,59 @@ public class MeshMultigon extends MeshBase
 
     int vPrev = vCurr==0 ? len-1 : vCurr-1;
     int vNext = vCurr>=len-1 ? 0 : vCurr+1;
-    float[] vp = verts[vPrev];
-    float[] vn = verts[vNext];
+    float[] vp = outerAndHole[vPrev];
+    float[] vn = outerAndHole[vNext];
 
     return new float[] { vp[1]-vn[1], vn[0]-vp[0] };
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private float[] produceNormalVector(float[][] verts, float xs, float ys, float xe, float ye)
+  private float[] produceNormalVector(float[][] outerAndHole, float xs, float ys, float xe, float ye)
     {
-    int vCurr,len = verts.length;
+    int vCurr,len = outerAndHole.length;
 
     for(vCurr=0; vCurr<len; vCurr++)
       {
-      float[] vs = verts[vCurr];
+      float[] vs = outerAndHole[vCurr];
 
       if( isSame(vs[0]-xs,vs[1]-ys) )
         {
         int vNext = vCurr==len-1 ? 0 : vCurr+1;
-        float[] ve = verts[vNext];
+        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 = verts[vPrev];
-    float[] vn = verts[vNext];
+    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)
+  private void computeEdgeVectors(float[][][] vertices, int[][] edgesUp)
     {
-    int numComponents = vertices.length;
-    mEdgeVectors = new float[numComponents][][];
+    int numPoly = vertices.length;
+    mEdgeVectors = new float[numPoly][][];
 
-    for(int c=0; c<numComponents; c++)
+    for(int c=0; c<numPoly; c++)
       {
-      float[] polygon = vertices[c];
-      int numV = polygon.length/2;
+      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[2*v];
-        float ys = polygon[2*v+1];
+        float xs = polygon[v][0];
+        float ys = polygon[v][1];
         int n = v==numV-1 ? 0 : v+1;
-        float xe = polygon[2*n];
-        float ye = polygon[2*n+1];
+        float xe = polygon[n][0];
+        float ye = polygon[n][1];
 
         if( edgeUp<0 ) // external edge, normal vector
           {
@@ -432,15 +432,15 @@ public class MeshMultigon extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private boolean[][] computeVertsUp(float[][] vertices)
+  private boolean[][] computeVertsUp(float[][][] vertices)
     {
-    int num = vertices.length;
-    boolean[][] up = new boolean[num][];
+    int numPoly = vertices.length;
+    boolean[][] up = new boolean[numPoly][];
 
-    for(int i=0; i<num; i++)
+    for(int i=0; i<numPoly; i++)
       {
-      float[] v = vertices[i];
-      int len = v.length/2;
+      float[][] v = vertices[i];
+      int len = v.length;
       up[i] = new boolean[len];
 
       for(int j=0; j<len; j++)
@@ -455,15 +455,15 @@ public class MeshMultigon extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private float[] computeCenter(float[] vertices)
+  private float[] computeCenter(float[][] vertices)
     {
-    int num = vertices.length/2;
+    int num = vertices.length;
     float[] ret = new float[2];
 
-    for(int i=0; i<num; i++)
+    for(float[] vertex : vertices)
       {
-      ret[0] += vertices[2*i];
-      ret[1] += vertices[2*i+1];
+      ret[0] += vertex[0];
+      ret[1] += vertex[1];
       }
 
     ret[0] /= num;
@@ -474,7 +474,7 @@ public class MeshMultigon extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private float[][] computeCenters(float[][] vertices)
+  private float[][] computeCenters(float[][][] vertices)
     {
     int num = vertices.length;
     float[][] ret = new float[num][];
@@ -485,21 +485,21 @@ public class MeshMultigon extends MeshBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   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)
+                          int[][] edgesUp, boolean[][] vertsUp, float[][][] vertices, float[][] centers, int component, int curr)
     {
-    float[] v = vertices[component];
+    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 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[2*curr];
-      vL[1] = v[2*curr+1];
-      vR[0] = v[2*next];
-      vR[1] = v[2*next+1];
+      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];
 
@@ -520,25 +520,25 @@ public class MeshMultigon extends MeshBase
 
         if( eupp<0 )
           {
-          normL[0]=vL[0]-vT[0];
-          normL[1]=vL[1]-vT[1];
+          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];
+          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];
+          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];
+          int nnxt= next==numPoly-1 ? 0 : next+1;
+          normR[0]= v[next][0] - v[nnxt][0];
+          normR[1]= v[next][1] - v[nnxt][1];
           }
         }
 
@@ -550,8 +550,8 @@ public class MeshMultigon extends MeshBase
       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];
+      vT[0] = v[curr][0];
+      vT[1] = v[curr][1];
 
       boolean vup = vertsUp[component][curr];
 
@@ -577,8 +577,8 @@ public class MeshMultigon extends MeshBase
           }
         else
           {
-          float dx = v[2*next  ]-v[2*curr  ];
-          float dy = v[2*next+1]-v[2*curr+1];
+          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;
@@ -594,18 +594,16 @@ public class MeshMultigon extends MeshBase
 // PUBLIC API
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public static int[][] computeEdgesUp(float[][] vertices)
+  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/2;
+      int numEdges = vertices[p].length;
       up[p] = new int[numEdges];
-
-      for(int e=0; e<numEdges; e++)
-        up[p][e] = isUp(vertices,p,e);
+      for(int e=0; e<numEdges; e++) up[p][e] = isUp(vertices,p,e);
       }
 
     return up;
@@ -613,7 +611,7 @@ public class MeshMultigon extends MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public static float[][][] computeOuterAndHoleVertices(float[][] vertices, int[][] edgesUp)
+  public static float[][][] computeOuterAndHoleVertices(float[][][] vertices, int[][] edgesUp)
     {
     ArrayList<float[]> tmp = new ArrayList<>();
 
@@ -653,17 +651,17 @@ public class MeshMultigon extends MeshBase
  * 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 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)
+  public MeshMultigon(float[][][] vertices, float[] band, int exBands, int exVertices)
     {
     super();
 
     int numTriangles=0;
-    for(float[] vertex : vertices) numTriangles+=vertex.length/2;
+    for(float[][] vertex : vertices) numTriangles+=vertex.length;
     MeshBandedTriangle[] triangles = new MeshBandedTriangle[numTriangles];
 
     int[][] edgesUp = computeEdgesUp(vertices);
@@ -684,7 +682,7 @@ public class MeshMultigon extends MeshBase
 
     for(int i=0; i<len; i++)
       {
-      int num=vertices[i].length/2;
+      int num=vertices[i].length;
 
       for(int j=0; j<num; j++)
         {