commit 3bc73279c9274c43e7498a6e9fea3baeb2136ef7
Author: LeszekKoltunski <leszek@koltunski.pl>
Date:   Wed May 28 10:12:28 2025 +0200

    minor

diff --git a/src/main/java/org/distorted/library/mesh/MeshBase.kt b/src/main/java/org/distorted/library/mesh/MeshBase.kt
index 84fb4c3..c465499 100644
--- a/src/main/java/org/distorted/library/mesh/MeshBase.kt
+++ b/src/main/java/org/distorted/library/mesh/MeshBase.kt
@@ -48,8 +48,8 @@ import kotlin.math.sqrt
 abstract class MeshBase
 {
     var showNormals: Boolean // when rendering this mesh, draw normal vectors?
-    private var mVBO1: InternalBuffer? = null
-    private var mVBO2: InternalBuffer? = null
+    private lateinit var mVBO1: InternalBuffer
+    private lateinit var mVBO2: InternalBuffer
     private var mTFO: InternalBuffer // main vertex buffer and transform feedback buffer
     private var numVertices: Int = 0
     private var mVertAttribs1: FloatArray? = null // packed: PosX,PosY,PosZ, NorX,NorY,NorZ
@@ -88,11 +88,11 @@ abstract class MeshBase
         private const val OFFSET_TEX = TEX_ATTRIB*BYTES_PER_FLOAT
         private const val OFFSET_COM = COM_ATTRIB*BYTES_PER_FLOAT
 
-        private const val TRAN_SIZE = TRAN_ATTRIBS*BYTES_PER_FLOAT
+        private const val TRAN_SIZE  = TRAN_ATTRIBS*BYTES_PER_FLOAT
         private const val VERT1_SIZE = VERT1_ATTRIBS*BYTES_PER_FLOAT
         private const val VERT2_SIZE = VERT2_ATTRIBS*BYTES_PER_FLOAT
 
-        private val mCenterBlockIndex = IntArray(EffectQueue.MAIN_VARIANTS)
+        private val mCenterBlockIndex= IntArray(EffectQueue.MAIN_VARIANTS)
         private val mAssocBlockIndex = IntArray(EffectQueue.MAIN_VARIANTS)
 
         private const val TEX_COMP_SIZE = 5 // 5 four-byte entities inside the component
@@ -161,8 +161,8 @@ abstract class MeshBase
         }
     }
 
-    private var mTexComponent: ArrayList<TexComponent>? = null
-    private var mEffComponent: ArrayList<Int>? = null
+    private lateinit var mTexComponent: ArrayList<TexComponent>
+    private lateinit var mEffComponent: ArrayList<Int>
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     internal constructor()
@@ -223,17 +223,17 @@ abstract class MeshBase
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     private fun shallowCopy(original: MeshBase)
     {
-        val texComSize = original.mTexComponent!!.size
+        val texComSize = original.mTexComponent.size
         mTexComponent = ArrayList()
 
         for (i in 0 until texComSize)
         {
-            val comp = TexComponent(original.mTexComponent!![i])
-            mTexComponent!!.add(comp)
+            val comp = TexComponent(original.mTexComponent[i])
+            mTexComponent.add(comp)
         }
 
         mEffComponent = ArrayList()
-        mEffComponent!!.addAll(original.mEffComponent!!)
+        mEffComponent.addAll(original.mEffComponent)
 
         mVBO2 = InternalBuffer(GLES30.GL_ARRAY_BUFFER, GLES30.GL_STATIC_DRAW)
         mVertAttribs2 = original.mVertAttribs2?.copyOf()
@@ -242,38 +242,38 @@ abstract class MeshBase
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     fun mergeTexComponentsNow()
     {
-        val num = mTexComponent!!.size
+        val num = mTexComponent.size
 
         if (num>1)
         {
-            mTexComponent!!.clear()
-            mTexComponent!!.add(TexComponent(numVertices-1))
-            mVBO2!!.invalidate()
+            mTexComponent.clear()
+            mTexComponent.add(TexComponent(numVertices-1))
+            mVBO2.invalidate()
         }
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     fun addEmptyTexComponentNow()
     {
-        mTexComponent!!.add(TexComponent(numVertices-1))
+        mTexComponent.add(TexComponent(numVertices-1))
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     fun mergeEffComponentsNow()
     {
-        val num = mEffComponent!!.size
+        val num = mEffComponent.size
 
         if (num>1)
         {
-            mEffComponent!!.clear()
-            mEffComponent!!.add(numVertices-1)
+            mEffComponent.clear()
+            mEffComponent.add(numVertices-1)
 
             for (index in 0 until numVertices)
             {
                 mVertAttribs2!![VERT2_ATTRIBS*index+COM_ATTRIB] = 0f
             }
 
-            mVBO2!!.invalidate()
+            mVBO2.invalidate()
         }
     }
 
@@ -285,16 +285,16 @@ abstract class MeshBase
         val uniforms = FloatArray(7)
         var start: Int
         var end = -1
-        val numComp = mEffComponent!!.size
+        val numComp = mEffComponent.size
 
         matrixP[15] = 1f
         matrixP[10] = matrixP[15]
-        matrixP[5] = matrixP[10]
-        matrixP[0] = matrixP[5]
+        matrixP[ 5] = matrixP[10]
+        matrixP[ 0] = matrixP[5]
         matrixV[15] = 1f
         matrixV[10] = matrixV[15]
-        matrixV[5] = matrixV[10]
-        matrixV[0] = matrixV[5]
+        matrixV[ 5] = matrixV[10]
+        matrixV[ 0] = matrixV[5]
 
         effect.compute(uniforms, 0, 0, 0)
         effect.apply(matrixP, matrixV, uniforms, 0)
@@ -302,7 +302,7 @@ abstract class MeshBase
         for (comp in 0 until numComp)
         {
             start = end+1
-            end = mEffComponent!![comp]
+            end = mEffComponent[comp]
 
             if (mUBA.matchesAssociation(comp, andAssoc, equAssoc))
             {
@@ -310,7 +310,7 @@ abstract class MeshBase
             }
         }
 
-        mVBO1!!.invalidate()
+        mVBO1.invalidate()
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -375,17 +375,17 @@ abstract class MeshBase
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // when a derived class is done computing its mesh, it has to call this method.
-    fun setAttribs(vert1Attribs: FloatArray, vert2Attribs: FloatArray?)
+    fun setAttribs(vert1Attribs: FloatArray, vert2Attribs: FloatArray)
     {
         numVertices = vert1Attribs.size/VERT1_ATTRIBS
         mVertAttribs1 = vert1Attribs
         mVertAttribs2 = vert2Attribs
 
-        mTexComponent!!.add(TexComponent(numVertices-1))
-        mEffComponent!!.add(numVertices-1)
+        mTexComponent.add(TexComponent(numVertices-1))
+        mEffComponent.add(numVertices-1)
 
-        mVBO1!!.invalidate()
-        mVBO2!!.invalidate()
+        mVBO1.invalidate()
+        mVBO2.invalidate()
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -403,18 +403,18 @@ abstract class MeshBase
 
         if (origVertices>0)
         {
-            origTexComponents = mTexComponent!!.size
+            origTexComponents = mTexComponent.size
             numVertices += (if (numVertices%2==1) 2 else 1)
-            mTexComponent!![origTexComponents-1].mEndIndex = numVertices-1
-            origEffComponents = mEffComponent!!.size
-            mEffComponent!![origEffComponents-1] = numVertices-1
+            mTexComponent[origTexComponents-1].mEndIndex = numVertices-1
+            origEffComponents = mEffComponent.size
+            mEffComponent[origEffComponents-1] = numVertices-1
         }
 
         for (i in 0 until numMeshes)
         {
             mesh = meshes[i]
-            numTexComponents = mesh.mTexComponent!!.size
-            numEffComponents = mesh.mEffComponent!!.size
+            numTexComponents = mesh.mTexComponent.size
+            numEffComponents = mesh.mEffComponent.size
             numVert = mesh.numVertices
 
             val extraVerticesBefore = if (numVertices==0) 0 else 1
@@ -422,18 +422,18 @@ abstract class MeshBase
 
             for (j in 0 until numTexComponents)
             {
-                comp = TexComponent(mesh.mTexComponent!![j])
+                comp = TexComponent(mesh.mTexComponent[j])
                 comp.mEndIndex += (extraVerticesBefore+numVertices)
                 if (j==numTexComponents-1) comp.mEndIndex += extraVerticesAfter
-                mTexComponent!!.add(comp)
+                mTexComponent.add(comp)
             }
 
             for (j in 0 until numEffComponents)
             {
-                var index = mesh.mEffComponent!![j]
+                var index = mesh.mEffComponent[j]
                 index += (extraVerticesBefore+numVertices)
                 if (j==numEffComponents-1) index += extraVerticesAfter
-                mEffComponent!!.add(index)
+                mEffComponent.add(index)
 
                 if (origEffComponents<maxEffComponents)
                 {
@@ -541,11 +541,11 @@ abstract class MeshBase
 
         var endIndex: Int
         var index = 0
-        val numEffComp = mEffComponent!!.size
+        val numEffComp = mEffComponent.size
 
         for (component in 0 until numEffComp)
         {
-            endIndex = mEffComponent!![component]
+            endIndex = mEffComponent[component]
 
             while (index<=endIndex)
             {
@@ -556,8 +556,8 @@ abstract class MeshBase
 
         mVertAttribs1 = newAttribs1
         mVertAttribs2 = newAttribs2
-        mVBO1!!.invalidate()
-        mVBO2!!.invalidate()
+        mVBO1.invalidate()
+        mVBO2.invalidate()
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -582,12 +582,12 @@ abstract class MeshBase
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     fun textureMap(maps: Array<Static4D?>, startComponent: Int)
     {
-        val num_comp = mTexComponent!!.size
+        val num_comp = mTexComponent.size
         if (startComponent>num_comp) return
 
         val num_maps = maps.size
         val min = min((num_comp-startComponent).toDouble(), num_maps.toDouble()).toInt()
-        var vertex = if (startComponent>0) mTexComponent!![startComponent-1].mEndIndex+1 else 0
+        var vertex = if (startComponent>0) mTexComponent[startComponent-1].mEndIndex+1 else 0
         var newMap: Static4D?
         var oldMap: Static4D
         var comp: TexComponent
@@ -601,7 +601,7 @@ abstract class MeshBase
         for (i in 0 until min)
         {
             newMap = maps[i]
-            comp = mTexComponent!![i+startComponent]
+            comp = mTexComponent[i+startComponent]
 
             if (newMap!=null)
             {
@@ -619,7 +619,7 @@ abstract class MeshBase
                     var index = vertex*VERT2_ATTRIBS+TEX_ATTRIB
                     while (vertex<=comp.mEndIndex)
                     {
-                        mVertAttribs2!![index] = ratW*mVertAttribs2!![index]+movX
+                        mVertAttribs2!![index  ] = ratW*mVertAttribs2!![index]+movX
                         mVertAttribs2!![index+1] = ratH*mVertAttribs2!![index+1]+movY
                         vertex++
                         index += VERT2_ATTRIBS
@@ -631,7 +631,7 @@ abstract class MeshBase
             vertex = comp.mEndIndex+1
         }
 
-        mVBO2!!.invalidate()
+        mVBO2.invalidate()
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -647,7 +647,7 @@ abstract class MeshBase
 
         val feedback = buffer.order(ByteOrder.nativeOrder()).asFloatBuffer()
         feedback[mVertAttribs1, 0, VERT1_ATTRIBS*numVertices]
-        mVBO1!!.updateFloat(mVertAttribs1)
+        mVBO1.updateFloat(mVertAttribs1)
 
         GLES30.glUnmapBuffer(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER)
     }
@@ -678,10 +678,10 @@ abstract class MeshBase
      */
     fun printTexComponent(comp: Int)
     {
-        if (comp>=0&&comp<numTexComponents)
+        if( comp in 0..<numTexComponents )
         {
-            val beg = if (comp>0) mTexComponent!![comp-1].mEndIndex+1 else 0
-            val end = mTexComponent!![comp].mEndIndex
+            val beg = if (comp>0) mTexComponent[comp-1].mEndIndex+1 else 0
+            val end = mTexComponent[comp].mEndIndex
             val sb = StringBuilder()
 
             for (vert in beg..end)
@@ -799,7 +799,7 @@ abstract class MeshBase
 
         for (i in 0 until num)
         {
-            val end = mTexComponent!![i].mEndIndex
+            val end = mTexComponent[i].mEndIndex
             sb.append("\n")
 
             while (vert<=end)
@@ -846,8 +846,8 @@ abstract class MeshBase
     {
         if (mJobNode[0]!=null) mJobNode[0]!!.execute() // this will set itself to null
 
-        val index1 = mVBO1!!.createImmediatelyFloat(numVertices*VERT1_SIZE, mVertAttribs1)
-        val index2 = mVBO2!!.createImmediatelyFloat(numVertices*VERT2_SIZE, mVertAttribs2)
+        val index1 = mVBO1.createImmediatelyFloat(numVertices*VERT1_SIZE, mVertAttribs1)
+        val index2 = mVBO2.createImmediatelyFloat(numVertices*VERT2_SIZE, mVertAttribs2)
         val attr = program.mAttribute
 
         when (program.mAttributeLayout)
@@ -1002,14 +1002,14 @@ abstract class MeshBase
                 tex = TexComponent(index)
                 tex.setMap(Static4D(x, y, z, w))
 
-                mTexComponent!!.add(tex)
+                mTexComponent.add(tex)
                 texComp++
             }
 
             for (effComp in 0 until numEff)
             {
                 index = tmp[TEX_COMP_SIZE*texComp+effComp].toInt()
-                mEffComponent!!.add(index)
+                mEffComponent.add(index)
             }
 
             //////////////////////////////////////////////////////////////////////////////////////////
@@ -1024,10 +1024,10 @@ abstract class MeshBase
                     var vert = 0
                     while (vert<numVertices)
                     {
-                        mVertAttribs1!![VERT1_ATTRIBS*vert+POS_ATTRIB] = floatBuf[index+POS_ATTRIB]
+                        mVertAttribs1!![VERT1_ATTRIBS*vert+POS_ATTRIB  ] = floatBuf[index+POS_ATTRIB  ]
                         mVertAttribs1!![VERT1_ATTRIBS*vert+POS_ATTRIB+1] = floatBuf[index+POS_ATTRIB+1]
                         mVertAttribs1!![VERT1_ATTRIBS*vert+POS_ATTRIB+2] = floatBuf[index+POS_ATTRIB+2]
-                        mVertAttribs1!![VERT1_ATTRIBS*vert+NOR_ATTRIB] = floatBuf[index+NOR_ATTRIB]
+                        mVertAttribs1!![VERT1_ATTRIBS*vert+NOR_ATTRIB  ] = floatBuf[index+NOR_ATTRIB  ]
                         mVertAttribs1!![VERT1_ATTRIBS*vert+NOR_ATTRIB+1] = floatBuf[index+NOR_ATTRIB+1]
                         mVertAttribs1!![VERT1_ATTRIBS*vert+NOR_ATTRIB+2] = floatBuf[index+NOR_ATTRIB+2]
                         index += vert1InFile
@@ -1070,9 +1070,9 @@ abstract class MeshBase
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     fun getLastVertexEff(effComponent: Int): Int
     {
-        if (effComponent>=0&&effComponent<mTexComponent!!.size)
+        if (effComponent>=0&&effComponent<mTexComponent.size)
         {
-            return mEffComponent!![effComponent]
+            return mEffComponent[effComponent]
         }
 
         return 0
@@ -1081,9 +1081,9 @@ abstract class MeshBase
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     fun getLastVertexTex(texComponent: Int): Int
     {
-        if (texComponent>=0&&texComponent<mTexComponent!!.size)
+        if (texComponent>=0&&texComponent<mTexComponent.size)
         {
-            return mTexComponent!![texComponent].mEndIndex
+            return mTexComponent[texComponent].mEndIndex
         }
 
         return 0
@@ -1099,8 +1099,8 @@ abstract class MeshBase
     {
         var tex: TexComponent
 
-        val numTex = mTexComponent!!.size
-        val numEff = mEffComponent!!.size
+        val numTex = mTexComponent.size
+        val numEff = mEffComponent.size
 
         try
         {
@@ -1111,7 +1111,7 @@ abstract class MeshBase
 
             for (i in 0 until numTex)
             {
-                tex = mTexComponent!![i]
+                tex = mTexComponent[i]
 
                 stream.writeFloat(tex.mEndIndex.toFloat())
                 stream.writeFloat(tex.mTextureMap.get0())
@@ -1122,7 +1122,7 @@ abstract class MeshBase
 
             for (i in 0 until numEff)
             {
-                stream.writeFloat(mEffComponent!![i].toFloat())
+                stream.writeFloat(mEffComponent[i].toFloat())
             }
 
             val centers = if (useCenters) mUBC!!.backingArray else FloatArray(4*numEff)
@@ -1154,14 +1154,8 @@ abstract class MeshBase
      */
     fun mergeTexComponents()
     {
-        if (mJobNode[0]==null)
-        {
-            mergeTexComponentsNow()
-        }
-        else
-        {
-            mJobNode[0] = DeferredJobs.mergeTex(this)
-        }
+        if (mJobNode[0]==null) mergeTexComponentsNow()
+        else mJobNode[0] = DeferredJobs.mergeTex(this)
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1170,15 +1164,10 @@ abstract class MeshBase
      */
     fun mergeEffComponents()
     {
-        if (mJobNode[0]==null)
-        {
-            mergeEffComponentsNow()
-        }
-        else
-        {
-            mJobNode[0] = DeferredJobs.mergeEff(this)
-        }
+        if (mJobNode[0]==null) mergeEffComponentsNow()
+        else mJobNode[0] = DeferredJobs.mergeEff(this)
     }
+
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the number of vertices in this Mesh.
@@ -1194,8 +1183,8 @@ abstract class MeshBase
         mVertAttribs1 = null
         mVertAttribs2 = null
 
-        mVBO1!!.markForDeletion()
-        mVBO2!!.markForDeletion()
+        mVBO1.markForDeletion()
+        mVBO2.markForDeletion()
         mTFO.markForDeletion()
         mUBA.markForDeletion()
 
@@ -1218,14 +1207,8 @@ abstract class MeshBase
      */
     fun apply(effect: MatrixEffect, andAssoc: Int, equAssoc: Int)
     {
-        if (mJobNode[0]==null)
-        {
-            applyMatrix(effect, andAssoc, equAssoc)
-        }
-        else
-        {
-            mJobNode[0] = DeferredJobs.matrix(this, effect, andAssoc, equAssoc)
-        }
+        if (mJobNode[0]==null) applyMatrix(effect, andAssoc, equAssoc)
+        else mJobNode[0] = DeferredJobs.matrix(this, effect, andAssoc, equAssoc)
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1241,7 +1224,7 @@ abstract class MeshBase
      */
     fun apply(effect: VertexEffect)
     {
-        mJobNode[0] = DeferredJobs.vertex(this, effect)
+        mJobNode[0] = DeferredJobs.vertex(this,effect)
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1268,14 +1251,8 @@ abstract class MeshBase
      */
     fun setTextureMap(maps: Array<Static4D?>, startComponent: Int)
     {
-        if (mJobNode[0]==null)
-        {
-            textureMap(maps, startComponent)
-        }
-        else
-        {
-            mJobNode[0] = DeferredJobs.textureMap(this, maps, startComponent)
-        }
+        if (mJobNode[0]==null) textureMap(maps, startComponent)
+        else mJobNode[0] = DeferredJobs.textureMap(this, maps, startComponent)
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1286,7 +1263,7 @@ abstract class MeshBase
      */
     fun getTextureMap(component: Int): Static4D?
     {
-        return if ((component>=0&&component<mTexComponent!!.size)) mTexComponent!![component].mTextureMap else null
+        return if ((component>=0&&component<mTexComponent.size)) mTexComponent[component].mTextureMap else null
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1404,7 +1381,7 @@ abstract class MeshBase
      *
      * @return The number of Texture Components of this Mesh.
      */
-    val numTexComponents: Int get() = mTexComponent!!.size
+    val numTexComponents: Int get() = mTexComponent.size
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
@@ -1413,7 +1390,7 @@ abstract class MeshBase
      *
      * @return The number of Effect Components of this Mesh.
      */
-    val numEffComponents: Int get() = mEffComponent!!.size
+    val numEffComponents: Int get() = mEffComponent.size
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**