commit 61c6baa4f81644fd02b1fed38e3140d7c7923a0b
Author: leszek <leszek@koltunski.pl>
Date:   Sun Apr 20 23:13:11 2025 +0200

    transition the 'uniformblock' package

diff --git a/src/main/java/org/distorted/library/message/EffectListener.kt b/src/main/java/org/distorted/library/message/EffectListener.kt
index 973e150..96ec71f 100644
--- a/src/main/java/org/distorted/library/message/EffectListener.kt
+++ b/src/main/java/org/distorted/library/message/EffectListener.kt
@@ -21,7 +21,6 @@
 package org.distorted.library.message
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-
 /**
  * This interface lets users of the DistortedLibrary library get notified when a given effect finishes.
  * To receive the notifications, we first have to register with a call to [Effect.notifyWhenFinished].
diff --git a/src/main/java/org/distorted/library/program/DistortedProgram.kt b/src/main/java/org/distorted/library/program/DistortedProgram.kt
index 4be589f..c22abcf 100644
--- a/src/main/java/org/distorted/library/program/DistortedProgram.kt
+++ b/src/main/java/org/distorted/library/program/DistortedProgram.kt
@@ -78,9 +78,7 @@ class DistortedProgram
             if (attributes != null)
             {
                 val size = attributes.size
-
-                for (i in 0..<size)
-                    GLES30.glBindAttribLocation(programHandle, i, attributes[i])
+                for (i in 0..<size) GLES30.glBindAttribLocation(programHandle, i, attributes[i])
             }
 
             GLES30.glLinkProgram(programHandle)
diff --git a/src/main/java/org/distorted/library/uniformblock/UniformBlockAssociation.kt b/src/main/java/org/distorted/library/uniformblock/UniformBlockAssociation.kt
index c2ffe2f..d5ce29c 100644
--- a/src/main/java/org/distorted/library/uniformblock/UniformBlockAssociation.kt
+++ b/src/main/java/org/distorted/library/uniformblock/UniformBlockAssociation.kt
@@ -1,4 +1,4 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
 // Copyright 2020 Leszek Koltunski  leszek@koltunski.pl                                          //
 //                                                                                               //
 // This file is part of Distorted.                                                               //
@@ -18,155 +18,139 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-package org.distorted.library.uniformblock;
-
-import org.distorted.library.main.DistortedLibrary;
-import org.distorted.library.main.InternalBuffer;
-import org.distorted.library.mesh.MeshBase;
+package org.distorted.library.uniformblock
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Not part of public API, do not document
- *
- * @y.exclude
- */
-public class UniformBlockAssociation
-  {
-  private static final int DEFAULT_ASSOCIATION = 0x7fffffff; // all effects associated, all components affected
-  private static final int DEFAULT_STRIDE = 4;
-  private static final int LOC_AND = 0;
-  private static final int LOC_EQU = 1;
-
-  private final InternalBuffer mUBO;
-  private final int mMax;
-  private int[] mAssociations;
-  private int mStride;
+import org.distorted.library.main.DistortedLibrary
+import org.distorted.library.main.InternalBuffer
+import org.distorted.library.mesh.MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public UniformBlockAssociation()
+/** Not part of public API, do not document
+*
+* @y.exclude
+*/
+class UniformBlockAssociation
+{
+    private val mUBO: InternalBuffer
+    private val mMax: Int
+    private var mAssociations: IntArray
+    private var mStride: Int
+    val index: Int get() = mUBO.createImmediatelyInt(4*mStride*mMax, mAssociations)
+
+    companion object
     {
-    mMax = MeshBase.getMaxEffComponents();
-    mStride = DEFAULT_STRIDE;
-    mAssociations= new int[mStride*mMax];
-
-    for(int i=0; i<mMax; i++)
-      {
-      mAssociations[mStride*i+LOC_AND] = DEFAULT_ASSOCIATION;
-      mAssociations[mStride*i+LOC_EQU] = i;
-      }
-
-    mUBO = new InternalBuffer();
+        private const val DEFAULT_ASSOCIATION = 0x7fffffff // all effects associated, all components affected
+        private const val DEFAULT_STRIDE = 4
+        private const val LOC_AND = 0
+        private const val LOC_EQU = 1
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public UniformBlockAssociation(UniformBlockAssociation original)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    constructor()
     {
-    mMax = original.mMax;
-    mStride = original.mStride;
-    int size = original.mAssociations.length;
-    mAssociations= new int[size];
-    System.arraycopy(original.mAssociations, 0, mAssociations, 0, size);
+        mMax = MeshBase.getMaxEffComponents()
+        mStride = DEFAULT_STRIDE
+        mAssociations = IntArray(mStride*mMax)
 
-    mUBO = new InternalBuffer();
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// stride can be 0, if we just tried compiling a vertex shader which has NUM_VERTEX=0.
-// stride==1 we also don't like because then we have an exception ( stride*mMax-1 < stride*(mMax-1)+1 )
-
-  public void correctStride(int stride)
-    {
-    if( mStride != stride && stride>1 )
-      {
-      int[] tmp = new int[stride*mMax];
-
-      for(int i=0; i<mMax; i++)
+        for (i in 0..<mMax)
         {
-        tmp[stride*i+LOC_AND] = mAssociations[mStride*i+LOC_AND];
-        tmp[stride*i+LOC_EQU] = mAssociations[mStride*i+LOC_EQU];
+            mAssociations[mStride*i+LOC_AND] = DEFAULT_ASSOCIATION
+            mAssociations[mStride*i+LOC_EQU] = i
         }
 
-      mAssociations = tmp;
-      mStride = stride;
-      }
+        mUBO = InternalBuffer()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public boolean matchesAssociation( int comp, int andAssoc, int equAssoc)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    constructor(original: UniformBlockAssociation)
     {
-    return (andAssoc & mAssociations[mStride*comp+LOC_AND]) != 0 || (equAssoc == mAssociations[mStride*comp+LOC_EQU]);
+        mMax = original.mMax
+        mStride = original.mStride
+        val size = original.mAssociations.size
+        mAssociations = IntArray(size)
+        System.arraycopy(original.mAssociations, 0, mAssociations, 0, size)
+        mUBO = InternalBuffer()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void setEffectAssociationNow(int comp, int andAssociation, int equAssociation)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // stride can be 0, if we just tried compiling a vertex shader which has NUM_VERTEX=0.
+    // stride==1 we also don't like because then we have an exception ( stride*mMax-1 < stride*(mMax-1)+1 )
+    fun correctStride(stride: Int)
     {
-    int index = mStride*comp;
-    mAssociations[index+LOC_AND] &= (~DEFAULT_ASSOCIATION);
-    mAssociations[index+LOC_AND] += (andAssociation & DEFAULT_ASSOCIATION);
-    mAssociations[index+LOC_EQU] = equAssociation;
+        if (mStride!=stride && stride>1)
+        {
+            val tmp = IntArray(stride*mMax)
+
+            for (i in 0..<mMax)
+            {
+                tmp[stride*i+LOC_AND] = mAssociations[mStride*i+LOC_AND]
+                tmp[stride*i+LOC_EQU] = mAssociations[mStride*i+LOC_EQU]
+            }
 
-    mUBO.invalidate();
+            mAssociations = tmp
+            mStride = stride
+        }
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun matchesAssociation(comp: Int, andAssoc: Int, equAssoc: Int): Boolean
+    {
+        return (andAssoc and mAssociations[mStride*comp+LOC_AND]) != 0 || (equAssoc == mAssociations[mStride*comp+LOC_EQU])
+    }
 
-  public void setNotAffectedComponentsNow(int[] components)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun setEffectAssociationNow(comp: Int, andAssociation: Int, equAssociation: Int)
     {
-    for(int c=0; c<mMax; c++) mAssociations[mStride*c+LOC_AND] &= DEFAULT_ASSOCIATION;
+        val index = mStride*comp
 
-    if( components!=null )
-      {
-      for(int c : components) mAssociations[mStride*c+LOC_AND] |= (~DEFAULT_ASSOCIATION);
-      }
+        mAssociations[index+LOC_AND] = mAssociations[index+LOC_AND] and (DEFAULT_ASSOCIATION.inv())
+        mAssociations[index+LOC_AND] += (andAssociation and DEFAULT_ASSOCIATION)
+        mAssociations[index+LOC_EQU] = equAssociation
 
-    mUBO.invalidate();
+        mUBO.invalidate()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public int getIndex()
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun setNotAffectedComponentsNow(components: IntArray?)
     {
-    return mUBO.createImmediatelyInt( 4*mStride*mMax, mAssociations);
-    }
+        for (c in 0..<mMax)
+            mAssociations[mStride*c+LOC_AND] = mAssociations[mStride*c+LOC_AND] and DEFAULT_ASSOCIATION
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+        if (components != null)
+            for (c in components)
+                mAssociations[mStride*c+LOC_AND] = mAssociations[mStride*c+LOC_AND] or (DEFAULT_ASSOCIATION.inv())
 
-  public void copy(int compTo, UniformBlockAssociation assocFrom, int compFrom)
-    {
-    mAssociations[mStride*compTo+LOC_AND] = assocFrom.mAssociations[mStride*compFrom+LOC_AND];
-    mAssociations[mStride*compTo+LOC_EQU] = assocFrom.mAssociations[mStride*compFrom+LOC_EQU];
+        mUBO.invalidate()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void markForDeletion()
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun copy(compTo: Int, assocFrom: UniformBlockAssociation, compFrom: Int)
     {
-    mUBO.markForDeletion();
+        mAssociations[mStride*compTo+LOC_AND] = assocFrom.mAssociations[mStride*compFrom+LOC_AND]
+        mAssociations[mStride*compTo+LOC_EQU] = assocFrom.mAssociations[mStride*compFrom+LOC_EQU]
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun markForDeletion() = mUBO.markForDeletion()
 
-  public void print()
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun print()
     {
-    StringBuilder builder = new StringBuilder();
+        val builder = StringBuilder()
 
-    builder.append(mUBO.getID());
-    builder.append(' ');
+        builder.append(mUBO.id)
+        builder.append(' ')
 
-    for(int i=0; i<8; i++)
-      {
-      builder.append(mAssociations[mStride*i+LOC_AND]);
-      builder.append(' ');
-      builder.append(mAssociations[mStride*i+LOC_EQU]);
-      builder.append(' ');
-      }
+        for (i in 0..7)
+        {
+            builder.append(mAssociations[mStride*i+LOC_AND])
+            builder.append(' ')
+            builder.append(mAssociations[mStride*i+LOC_EQU])
+            builder.append(' ')
+        }
 
-    String res = builder.toString();
+        val res = builder.toString()
 
-    DistortedLibrary.logMessage("UniformBlockAssociation: "+res);
+        DistortedLibrary.logMessage("UniformBlockAssociation: $res")
     }
-  }
+}
diff --git a/src/main/java/org/distorted/library/uniformblock/UniformBlockCenter.kt b/src/main/java/org/distorted/library/uniformblock/UniformBlockCenter.kt
index f42bcaa..9745e96 100644
--- a/src/main/java/org/distorted/library/uniformblock/UniformBlockCenter.kt
+++ b/src/main/java/org/distorted/library/uniformblock/UniformBlockCenter.kt
@@ -18,93 +18,71 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-package org.distorted.library.uniformblock;
+package org.distorted.library.uniformblock
 
-import org.distorted.library.main.InternalBuffer;
-import org.distorted.library.mesh.MeshBase;
+import org.distorted.library.main.InternalBuffer
+import org.distorted.library.mesh.MeshBase
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Not part of public API, do not document
- *
- * @y.exclude
- */
-public class UniformBlockCenter
-  {
-  private final InternalBuffer mUBO;
-  private final float[] mArray;
-  private final int mMax;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public UniformBlockCenter()
+/** Not part of public API, do not document
+*
+* @y.exclude
+*/
+class UniformBlockCenter
+{
+    private val mUBO: InternalBuffer
+    private val mMax: Int
+    val backingArray: FloatArray
+    val index: Int get() = mUBO.createImmediatelyFloat(16*mMax, backingArray)
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    constructor()
     {
-    mMax  = MeshBase.getMaxEffComponents();
-    mArray= new float[4*mMax];
-    mUBO  = new InternalBuffer();
+        mMax = MeshBase.getMaxEffComponents()
+        backingArray = FloatArray(4*mMax)
+        mUBO = InternalBuffer()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public UniformBlockCenter(UniformBlockCenter original)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    constructor(original: UniformBlockCenter)
     {
-    mMax = original.mMax;
-    int size = original.mArray.length;
-    mArray= new float[size];
-    System.arraycopy(original.mArray, 0, mArray, 0, size);
-    mUBO = new InternalBuffer();
+        mMax = original.mMax
+        val size = original.backingArray.size
+        backingArray = FloatArray(size)
+        System.arraycopy(original.backingArray, 0, backingArray, 0, size)
+        mUBO = InternalBuffer()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void setEffectCenterNow(int comp, float x, float y, float z)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun setEffectCenterNow(comp: Int, x: Float, y: Float, z: Float)
     {
-    if( comp>=0 )
-      {
-      mArray[4*comp  ] = x;
-      mArray[4*comp+1] = y;
-      mArray[4*comp+2] = z;
-      }
-    else
-      {
-      for(int i=0; i<mMax; i++)
+        if (comp >= 0)
         {
-        mArray[4*i  ] = x;
-        mArray[4*i+1] = y;
-        mArray[4*i+2] = z;
+            backingArray[4*comp  ] = x
+            backingArray[4*comp+1] = y
+            backingArray[4*comp+2] = z
+        }
+        else
+        {
+            for (i in 0..<mMax)
+            {
+                backingArray[4*i  ] = x
+                backingArray[4*i+1] = y
+                backingArray[4*i+2] = z
+            }
         }
-      }
-
-    mUBO.invalidate();
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public int getIndex()
-    {
-    return mUBO.createImmediatelyFloat( 16*mMax, mArray);
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public void copy(int compTo, UniformBlockCenter blockFrom, int compFrom)
-    {
-    mArray[4*compTo  ] = blockFrom.mArray[4*compFrom  ];
-    mArray[4*compTo+1] = blockFrom.mArray[4*compFrom+1];
-    mArray[4*compTo+2] = blockFrom.mArray[4*compFrom+2];
+        mUBO.invalidate()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void markForDeletion()
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun copy(compTo: Int, blockFrom: UniformBlockCenter, compFrom: Int)
     {
-    mUBO.markForDeletion();
+        backingArray[4*compTo  ] = blockFrom.backingArray[4*compFrom  ]
+        backingArray[4*compTo+1] = blockFrom.backingArray[4*compFrom+1]
+        backingArray[4*compTo+2] = blockFrom.backingArray[4*compFrom+2]
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public float[] getBackingArray()
-    {
-    return mArray;
-    }
-  }
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun markForDeletion() = mUBO.markForDeletion()
+}
diff --git a/src/main/java/org/distorted/library/uniformblock/UniformBlockFloatUniforms.kt b/src/main/java/org/distorted/library/uniformblock/UniformBlockFloatUniforms.kt
index 6ddae5a..d3dfe64 100644
--- a/src/main/java/org/distorted/library/uniformblock/UniformBlockFloatUniforms.kt
+++ b/src/main/java/org/distorted/library/uniformblock/UniformBlockFloatUniforms.kt
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// Copyright 2021 Leszek Koltunski  leszek@koltunski.pl                                          //
+// Copyright 2020 Leszek Koltunski  leszek@koltunski.pl                                          //
 //                                                                                               //
 // This file is part of Distorted.                                                               //
 //                                                                                               //
@@ -18,130 +18,91 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-package org.distorted.library.uniformblock;
+package org.distorted.library.uniformblock
 
-import org.distorted.library.main.DistortedLibrary;
-import org.distorted.library.main.InternalBuffer;
+import org.distorted.library.main.DistortedLibrary
+import org.distorted.library.main.InternalBuffer
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Not part of public API, do not document
- *
- * @y.exclude
- */
-public class UniformBlockFloatUniforms
-  {
-  private InternalBuffer mUBO;
-  private final float[] mArray;
-  private final int mNumUniforms, mSize;
-  private final boolean mReallyUseUBO;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public UniformBlockFloatUniforms(int numUniforms, int size, boolean reallyUse)
+/** Not part of public API, do not document
+*
+* @y.exclude
+*/
+class UniformBlockFloatUniforms
+{
+    private var mUBO: InternalBuffer? = null
+    val backingArray: FloatArray
+    private val mNumUniforms: Int
+    private val mSize: Int
+    private val mReallyUseUBO: Boolean
+    val index: Int get() = mUBO!!.createImmediatelyFloat(4*mNumUniforms*mSize, backingArray)
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    constructor(numUniforms: Int, size: Int, reallyUse: Boolean)
     {
-    mNumUniforms = numUniforms;
-    mSize        = size;
-    mArray       = new float[mNumUniforms*mSize];
-    mReallyUseUBO= reallyUse;
-
-    if( mReallyUseUBO )
-      {
-      mUBO = new InternalBuffer();
-      }
+        mNumUniforms = numUniforms
+        mSize = size
+        backingArray = FloatArray(mNumUniforms*mSize)
+        mReallyUseUBO = reallyUse
+        if (mReallyUseUBO) mUBO = InternalBuffer()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public UniformBlockFloatUniforms(UniformBlockFloatUniforms original)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    constructor(original: UniformBlockFloatUniforms)
     {
-    mNumUniforms = original.mNumUniforms;
-    mSize        = original.mSize;
-    mArray       = new float[mNumUniforms*mSize];
-    mReallyUseUBO= original.mReallyUseUBO;
-
-    System.arraycopy(original.mArray, 0, mArray, 0, 3*mSize);
-
-    if( mReallyUseUBO )
-      {
-      mUBO = new InternalBuffer();
-      }
+        mNumUniforms = original.mNumUniforms
+        mSize = original.mSize
+        backingArray = FloatArray(mNumUniforms*mSize)
+        mReallyUseUBO = original.mReallyUseUBO
+        System.arraycopy(original.backingArray, 0, backingArray, 0, 3 * mSize)
+        if (mReallyUseUBO) mUBO = InternalBuffer()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public int getIndex()
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun remove(pos: Int, numEffects: Int)
     {
-    return mUBO.createImmediatelyFloat( 4*mNumUniforms*mSize, mArray);
+        System.arraycopy( backingArray, mNumUniforms*(pos+1), backingArray, mNumUniforms*pos, mNumUniforms*(numEffects-pos) )
+        if (mReallyUseUBO) mUBO!!.invalidate()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void remove(int pos, int numEffects)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun markForDeletion()
     {
-    System.arraycopy(mArray, mNumUniforms*(pos+1), mArray, mNumUniforms*pos, mNumUniforms*(numEffects-pos) );
-
-    if( mReallyUseUBO )
-      {
-      mUBO.invalidate();
-      }
+        if (mReallyUseUBO) mUBO!!.markForDeletion()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void markForDeletion()
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun invalidate()
     {
-    if( mReallyUseUBO )
-      {
-      mUBO.markForDeletion();
-      }
+        if (mReallyUseUBO) mUBO!!.invalidate()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void invalidate()
-    {
-    if( mReallyUseUBO )
-      {
-      mUBO.invalidate();
-      }
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public float[] getBackingArray()
-    {
-    return mArray;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void print(int num)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun print(num: Int)
     {
-    StringBuilder builder = new StringBuilder();
-
-    builder.append( mReallyUseUBO ? mUBO.getID() : "NOT USED");
-    builder.append(':');
-
-    for(int i=0; i<6; i++)
-      {
-      builder.append(' ');
-      builder.append(mArray[4*i  ]);
-      builder.append(' ');
-      builder.append(mArray[4*i+1]);
-      builder.append(' ');
-      builder.append(mArray[4*i+2]);
-      builder.append(',');
-      }
-
-    builder.append(' ');
-    builder.append('(');
-    builder.append(num);
-    builder.append(')');
-
-    String res = builder.toString();
-
-    DistortedLibrary.logMessage("UniformBlockFloatUniforms: "+res);
+        val builder = StringBuilder()
+
+        builder.append(if (mReallyUseUBO) mUBO!!.id else "NOT USED")
+        builder.append(':')
+
+        for (i in 0..5)
+        {
+            builder.append(' ')
+            builder.append(backingArray[4*i])
+            builder.append(' ')
+            builder.append(backingArray[4*i+1])
+            builder.append(' ')
+            builder.append(backingArray[4*i+2])
+            builder.append(',')
+        }
+
+        builder.append(' ')
+        builder.append('(')
+        builder.append(num)
+        builder.append(')')
+
+        val res = builder.toString()
+
+        DistortedLibrary.logMessage("UniformBlockFloatUniforms: $res")
     }
-  }
+}
diff --git a/src/main/java/org/distorted/library/uniformblock/UniformBlockIntUniforms.kt b/src/main/java/org/distorted/library/uniformblock/UniformBlockIntUniforms.kt
index 614ea86..46d0498 100644
--- a/src/main/java/org/distorted/library/uniformblock/UniformBlockIntUniforms.kt
+++ b/src/main/java/org/distorted/library/uniformblock/UniformBlockIntUniforms.kt
@@ -18,156 +18,107 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-package org.distorted.library.uniformblock;
+package org.distorted.library.uniformblock
 
-import org.distorted.library.effect.Effect;
-import org.distorted.library.main.DistortedLibrary;
-import org.distorted.library.main.InternalBuffer;
+import org.distorted.library.effect.Effect
+import org.distorted.library.main.DistortedLibrary
+import org.distorted.library.main.InternalBuffer
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Not part of public API, do not document
- *
- * @y.exclude
- */
-public class UniformBlockIntUniforms
-  {
-  private InternalBuffer mUBO;
-  private final int[] mArray;
-  private final int mNumUniforms, mSize;
-  private final boolean mReallyUseUBO;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public UniformBlockIntUniforms(int numUniforms, int size, boolean reallyUse)
+/** Not part of public API, do not document
+*
+* @y.exclude
+*/
+class UniformBlockIntUniforms
+{
+    private var mUBO: InternalBuffer? = null
+    val backingArray: IntArray
+    private val mNumUniforms: Int
+    private val mSize: Int
+    private val mReallyUseUBO: Boolean
+    val index: Int get() = mUBO!!.createImmediatelyInt(4*mNumUniforms*mSize, backingArray)
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    constructor(numUniforms: Int, size: Int, reallyUse: Boolean)
     {
-    mNumUniforms = numUniforms;
-    mSize        = size;
-    mArray       = new int[mNumUniforms*mSize];
-    mReallyUseUBO= reallyUse;
-
-    if( mReallyUseUBO )
-      {
-      mUBO = new InternalBuffer();
-      }
+        mNumUniforms = numUniforms
+        mSize = size
+        backingArray = IntArray(mNumUniforms * mSize)
+        mReallyUseUBO = reallyUse
+        if (mReallyUseUBO) mUBO = InternalBuffer()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public UniformBlockIntUniforms(UniformBlockIntUniforms original)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    constructor(original: UniformBlockIntUniforms)
     {
-    mNumUniforms = original.mNumUniforms;
-    mSize        = original.mSize;
-    mArray       = new int[mNumUniforms*mSize];
-    mReallyUseUBO= original.mReallyUseUBO;
-
-    System.arraycopy(original.mArray, 0, mArray, 0, mSize);
-
-    if( mReallyUseUBO )
-      {
-      mUBO = new InternalBuffer();
-      }
+        mNumUniforms = original.mNumUniforms
+        mSize = original.mSize
+        backingArray = IntArray(mNumUniforms * mSize)
+        mReallyUseUBO = original.mReallyUseUBO
+        System.arraycopy(original.backingArray, 0, backingArray, 0, mSize)
+        if (mReallyUseUBO) mUBO = InternalBuffer()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public int getIndex()
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun remove(pos: Int, numEffects: Int)
     {
-    return mUBO.createImmediatelyInt( 4*mNumUniforms*mSize, mArray);
+        System.arraycopy(backingArray, mNumUniforms*(pos+1), backingArray, mNumUniforms*pos, mNumUniforms*(numEffects-pos) )
+        if (mReallyUseUBO) mUBO!!.invalidate()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void remove(int pos, int numEffects)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun makeHole(pos: Int, numEffects: Int)
     {
-    System.arraycopy(mArray, mNumUniforms*(pos+1), mArray, mNumUniforms*pos, mNumUniforms*(numEffects-pos) );
-
-    if( mReallyUseUBO )
-      {
-      mUBO.invalidate();
-      }
+        System.arraycopy( backingArray, mNumUniforms*pos, backingArray, mNumUniforms*(pos+1), mNumUniforms*(numEffects-pos) )
+        if (mReallyUseUBO) mUBO!!.invalidate()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void makeHole(int pos, int numEffects)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun addOrdinal(pos: Int, ordinal: Int)
     {
-    System.arraycopy(mArray, mNumUniforms*pos, mArray, mNumUniforms*(pos+1), mNumUniforms*(numEffects-pos) );
-
-    if( mReallyUseUBO )
-      {
-      mUBO.invalidate();
-      }
+        backingArray[mNumUniforms*pos] = ordinal
+        if (mReallyUseUBO) mUBO!!.invalidate()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void addOrdinal(int pos, int ordinal)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun addAssociations(pos: Int, effect: Effect)
     {
-    mArray[mNumUniforms*pos] = ordinal;
-
-    if( mReallyUseUBO )
-      {
-      mUBO.invalidate();
-      }
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void addAssociations(int pos, Effect effect)
-    {
-    effect.writeAssociations(mArray, mNumUniforms*pos+1, mNumUniforms*pos+3);
-
-    if( mReallyUseUBO )
-      {
-      mUBO.invalidate();
-      }
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void markForDeletion()
-    {
-    if( mReallyUseUBO )
-      {
-      mUBO.markForDeletion();
-      }
+        effect.writeAssociations(backingArray, mNumUniforms*pos+1, mNumUniforms*pos+3)
+        if (mReallyUseUBO) mUBO!!.invalidate()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public int[] getBackingArray()
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun markForDeletion()
     {
-    return mArray;
+        if (mReallyUseUBO) mUBO!!.markForDeletion()
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void print(int num)
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    fun print(num: Int)
     {
-    StringBuilder builder = new StringBuilder();
-
-    builder.append( mReallyUseUBO ? mUBO.getID() : "NOT USED");
-    builder.append(':');
-
-    for(int i=0; i<6; i++)
-      {
-      builder.append(' ');
-      builder.append(mArray[4*i  ]);
-      builder.append(' ');
-      builder.append(mArray[4*i+1]);
-      builder.append(' ');
-      builder.append(mArray[4*i+2]);
-      builder.append(',');
-      }
-
-    builder.append(' ');
-    builder.append('(');
-    builder.append(num);
-    builder.append(')');
-
-    String res = builder.toString();
-
-    DistortedLibrary.logMessage("UniformBlockIntUniforms: "+res);
+        val builder = StringBuilder()
+
+        builder.append(if (mReallyUseUBO) mUBO!!.id else "NOT USED")
+        builder.append(':')
+
+        for (i in 0..5)
+        {
+            builder.append(' ')
+            builder.append(backingArray[4*i])
+            builder.append(' ')
+            builder.append(backingArray[4*i+1])
+            builder.append(' ')
+            builder.append(backingArray[4*i+2])
+            builder.append(',')
+        }
+
+        builder.append(' ')
+        builder.append('(')
+        builder.append(num)
+        builder.append(')')
+
+        val res = builder.toString()
+
+        DistortedLibrary.logMessage("UniformBlockIntUniforms: $res")
     }
-  }
+}