commit 7b925f23d991122daeb8c4864600341e9f66af1f
Author: leszek <leszek@koltunski.pl>
Date:   Fri May 2 14:20:39 2025 +0200

    transition the 'mesh' package.

diff --git a/src/main/java/org/distorted/library/mesh/MeshMultigon.kt b/src/main/java/org/distorted/library/mesh/MeshMultigon.kt
index 4ab2097..e3c3725 100644
--- a/src/main/java/org/distorted/library/mesh/MeshMultigon.kt
+++ b/src/main/java/org/distorted/library/mesh/MeshMultigon.kt
@@ -86,7 +86,7 @@ class MeshMultigon : MeshBase
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-    private fun computeEdgeVectors(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray?>)
+    private fun computeEdgeVectors(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray>)
     {
         val numPoly = vertices.size
         mEdgeVectors = arrayOfNulls(numPoly)
@@ -99,7 +99,7 @@ class MeshMultigon : MeshBase
 
             for (v in 0 until numV)
             {
-                val edgeUp = edgesUp[c]!![v]
+                val edgeUp = edgesUp[c][v]
                 val xs = polygon[v][0]
                 val ys = polygon[v][1]
                 val n = if (v==numV-1) 0 else v+1
@@ -201,14 +201,15 @@ class MeshMultigon : MeshBase
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     private fun computeMode(vL: FloatArray, vR: FloatArray, vT: FloatArray, normL: FloatArray, normR: FloatArray,
-                            edgesUp: Array<IntArray?>, vertsUp: Array<BooleanArray?>, vertices: Array<Array<FloatArray>>, centers: Array<FloatArray?>, component: Int, curr: Int): Int
+                            edgesUp: Array<IntArray>, vertsUp: Array<BooleanArray?>, vertices: Array<Array<FloatArray>>,
+                            centers: Array<FloatArray?>, component: Int, curr: Int): Int
     {
         val v = vertices[component]
         val edges = edgesUp[component]
         val numPoly = v.size
         val next = if (curr==numPoly-1) 0 else curr+1
         val prev = if (curr==0) numPoly-1 else curr-1
-        val eupc = edges!![curr]
+        val eupc = edges[curr]
 
         if (eupc<0)
         {
@@ -496,7 +497,7 @@ class MeshMultigon : MeshBase
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        private fun detectNextOuterVertex(vertices: Array<Array<FloatArray>>, curr: FloatArray, vect: FloatArray, edgesUp: Array<IntArray?>): FloatArray
+        private fun detectNextOuterVertex(vertices: Array<Array<FloatArray>>, curr: FloatArray, vect: FloatArray, edgesUp: Array<IntArray>): FloatArray
         {
             var maxAngle = 0.0
             var x = 0f
@@ -513,7 +514,7 @@ class MeshMultigon : MeshBase
                     val xc = vert[v][0]
                     val yc = vert[v][1]
 
-                    if (edgesUp[c]!![v]<0&&isSame(xc-curr[0], yc-curr[1]))
+                    if (edgesUp[c][v]<0&&isSame(xc-curr[0], yc-curr[1]))
                     {
                         val n = (if (v==numV-1) 0 else v+1)
                         val xn = vert[n][0]
@@ -573,7 +574,7 @@ class MeshMultigon : MeshBase
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        private fun generateHole(vertices: Array<Array<FloatArray>>, unclaimedEdges: Array<IntArray?>, output: Array<FloatArray>, edgesUp: Array<IntArray?>, holeNumber: Int, numHoleVerts: Int): Int
+        private fun generateHole(vertices: Array<Array<FloatArray>>, unclaimedEdges: Array<IntArray?>, output: Array<FloatArray>, edgesUp: Array<IntArray>, holeNumber: Int, numHoleVerts: Int): Int
         {
             var firstIndex = -1
 
@@ -593,7 +594,7 @@ class MeshMultigon : MeshBase
 
                 val p = unclaimedEdges[nextIndex]!![0]
                 val v = unclaimedEdges[nextIndex]!![1]
-                edgesUp[p]!![v] = -holeNumber-2
+                edgesUp[p][v] = -holeNumber-2
                 currIndex = nextIndex
                 val e = unclaimedEdges[nextIndex]
                 val ve = vertices[e!![0]][e[1]]
@@ -614,7 +615,7 @@ class MeshMultigon : MeshBase
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        private fun computeHoles(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray?>, outer: Array<FloatArray>, numHoleVerts: Int): Array<Array<FloatArray?>>
+        private fun computeHoles(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray>, outer: Array<FloatArray>, numHoleVerts: Int): Array<Array<FloatArray?>>
         {
             val unclaimedEdges = arrayOfNulls<IntArray>(numHoleVerts)
             var index = 0
@@ -625,7 +626,7 @@ class MeshMultigon : MeshBase
                 val ve = vertices[p]
                 val numEdges = ve.size
 
-                for (e in 0 until numEdges) if (edgesUp[p]!![e]<0)
+                for (e in 0 until numEdges) if (edgesUp[p][e]<0)
                 {
                     val x1 = ve[e][0]
                     val y1 = ve[e][1]
@@ -639,7 +640,7 @@ class MeshMultigon : MeshBase
                     // x x x
                     // x o x
                     // o x x
-                    if (doesNotBelongToOuter(x1, y1, outer)||doesNotBelongToOuter(x2, y2, outer))
+                    if ( doesNotBelongToOuter(x1,y1,outer) || doesNotBelongToOuter(x2,y2,outer) )
                     {
                         unclaimedEdges[index] = intArrayOf(p, e, 1)
                         index++
@@ -668,8 +669,9 @@ class MeshMultigon : MeshBase
                 holes.add(hole)
             }
 
-            val ret: Array<Array<FloatArray?>> = arrayOfNulls(numHoles)
-            for (h in 0 until numHoles) ret[h] = holes.removeAt(0)
+
+            val ret = holes.toTypedArray()
+            holes.clear()
 
             return ret
         }
@@ -687,7 +689,7 @@ class MeshMultigon : MeshBase
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         // PUBLIC API
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        fun computeEdgesUp(vertices: Array<Array<FloatArray>>): Array<IntArray?>
+        fun computeEdgesUp(vertices: Array<Array<FloatArray>>): Array<IntArray>
         {
             val numPoly = vertices.size
             val up = arrayOfNulls<IntArray>(numPoly)
@@ -699,11 +701,11 @@ class MeshMultigon : MeshBase
                 for (e in 0 until numEdges) up[p]!![e] = isUp(vertices, p, e)
             }
 
-            return up
+            return up.requireNoNulls()
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        fun computeOuterAndHoleVertices(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray?>): Array<Array<FloatArray>>
+        fun computeOuterAndHoleVertices(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray>): Array<Array<FloatArray>>
         {
             val tmp = ArrayList<FloatArray>()
 
@@ -722,15 +724,15 @@ class MeshMultigon : MeshBase
             while (!isSame(next[0]-first[0], next[1]-first[1]))
 
             val numOuterVerts = tmp.size
-            val outerVertices = arrayOfNulls<FloatArray>(numOuterVerts)
-            for (i in 0 until numOuterVerts) outerVertices[i] = tmp.removeAt(0)
+            val outerVertices = tmp.toTypedArray()
+            tmp.clear()
 
             val numEdgesDown = countEdgesDown(edgesUp)
             val numHoleVerts = numEdgesDown-numOuterVerts
             var holeVertices: Array<Array<FloatArray?>>? = null
             if (numHoleVerts>0) holeVertices = computeHoles(vertices, edgesUp, outerVertices, numHoleVerts)
             val numHoles = holeVertices?.size ?: 0
-            val ret: Array<Array<FloatArray?>> = arrayOfNulls(1+numHoles)
+            val ret: Array<Array<FloatArray>> = arrayOfNulls(1+numHoles)
             ret[0] = outerVertices
             for (i in 0 until numHoles) ret[i+1] = holeVertices!![i]