commit 0bff60a4a58158fc649d446eb4dac3ee4f432a30
Author: LeszekKoltunski <leszek@koltunski.pl>
Date:   Fri Jun 6 15:14:32 2025 +0200

    remove all @Jvm's

diff --git a/src/main/java/org/distorted/library/effect/Effect.kt b/src/main/java/org/distorted/library/effect/Effect.kt
index 8ca9314..4d90424 100644
--- a/src/main/java/org/distorted/library/effect/Effect.kt
+++ b/src/main/java/org/distorted/library/effect/Effect.kt
@@ -64,7 +64,6 @@ abstract class Effect internal constructor (val name: EffectName)
          *
          * @y.exclude
          */
-        @JvmStatic
         fun onPause()
         {
             for (i in 0 until NUM_EFFECTS) mEnabled[i] = false
@@ -83,7 +82,6 @@ abstract class Effect internal constructor (val name: EffectName)
          *
          * @param type EffectType to enable.
          */
-        @JvmStatic
         fun enableEffects(type: EffectType)
         {
             var method: Method?
diff --git a/src/main/java/org/distorted/library/effect/EffectQuality.kt b/src/main/java/org/distorted/library/effect/EffectQuality.kt
index a79074a..0bd064d 100644
--- a/src/main/java/org/distorted/library/effect/EffectQuality.kt
+++ b/src/main/java/org/distorted/library/effect/EffectQuality.kt
@@ -38,7 +38,7 @@ enum class EffectQuality(val level: Int, private val mipmap: Float)
 
     companion object
     {
-        @JvmField val LENGTH: Int = entries.size
+        val LENGTH: Int = entries.size
         private val qualities: Array<EffectQuality?>
 
         init
@@ -48,7 +48,7 @@ enum class EffectQuality(val level: Int, private val mipmap: Float)
             for (q in entries) qualities[i++] = q
         }
 
-        @JvmStatic fun getMipmap(quality: Int): Float = qualities[quality]!!.mipmap
+        fun getMipmap(quality: Int): Float = qualities[quality]!!.mipmap
     }
 }
 
diff --git a/src/main/java/org/distorted/library/effect/EffectType.kt b/src/main/java/org/distorted/library/effect/EffectType.kt
index 22d55b3..7d74b57 100644
--- a/src/main/java/org/distorted/library/effect/EffectType.kt
+++ b/src/main/java/org/distorted/library/effect/EffectType.kt
@@ -36,9 +36,9 @@ enum class EffectType
 
     companion object
     {
-        @JvmField val LENGTH: Int = entries.size
-        @JvmField val MASK: Int = (1 shl LENGTH)-1
-        @JvmStatic fun reset(maxtable: IntArray)
+        val LENGTH: Int = entries.size
+        val MASK: Int = (1 shl LENGTH)-1
+        fun reset(maxtable: IntArray)
         {
             maxtable[0] = 100 // By default, there can be a maximum 100 MATRIX effects in a single
                               // EffectQueueMatrix at any given time. This can be changed with a call
@@ -48,6 +48,6 @@ enum class EffectType
             maxtable[3] = 3   // Max 3 POSTPROCESSING Effects
         }
 
-        @JvmStatic fun getType(ordinal: Int): EffectType = entries[ordinal]
+        fun getType(ordinal: Int): EffectType = entries[ordinal]
     }
 }
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffect.kt b/src/main/java/org/distorted/library/effect/FragmentEffect.kt
index bd94ad3..dc23ae3 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffect.kt
+++ b/src/main/java/org/distorted/library/effect/FragmentEffect.kt
@@ -43,10 +43,10 @@ abstract class FragmentEffect internal constructor(name: EffectName) : Effect(na
         val MAX_REGION: Static3D = Static3D(1000000f, 1000000f, 1000000f)
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun getGLSL(): String = mGLSL+"{}"
+        fun getGLSL(): String = mGLSL+"{}"
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun getNumEnabled(): Int = numEnabled
+        fun getNumEnabled(): Int = numEnabled
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         // prepare code to be injected into the 'main_fragment_shader' main() function.
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectAlpha.kt b/src/main/java/org/distorted/library/effect/FragmentEffectAlpha.kt
index b30ed0d..bb58d34 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectAlpha.kt
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectAlpha.kt
@@ -39,7 +39,7 @@ class FragmentEffectAlpha : FragmentEffect
         /**
          * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
          */
-        @JvmStatic fun enable()
+        fun enable()
         {
             addEffect(EffectName.ALPHA, EffectName.SMOOTH_ALPHA,
                 "color.a *= (degree*(fUniforms[effect].x-1.0)+1.0);")
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectBrightness.kt b/src/main/java/org/distorted/library/effect/FragmentEffectBrightness.kt
index 588a682..d08fcfa 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectBrightness.kt
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectBrightness.kt
@@ -39,7 +39,7 @@ class FragmentEffectBrightness : FragmentEffect
         /**
          * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
          */
-        @JvmStatic fun enable()
+        fun enable()
         {
             addEffect(EffectName.BRIGHTNESS, EffectName.SMOOTH_BRIGHTNESS,
                 "color.rgb = mix(vec3(0.0,0.0,0.0), color.rgb, degree*(fUniforms[effect].x-1.0)+1.0 );")
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectChroma.kt b/src/main/java/org/distorted/library/effect/FragmentEffectChroma.kt
index a4f42fe..13f58b1 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectChroma.kt
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectChroma.kt
@@ -40,7 +40,7 @@ class FragmentEffectChroma : FragmentEffect
         /**
          * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
          */
-        @JvmStatic fun enable()
+        fun enable()
         {
             addEffect(EffectName.CHROMA, EffectName.SMOOTH_CHROMA,
                 "color.rgb = mix(color.rgb, fUniforms[effect].yzw, degree*fUniforms[effect].x);")
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectContrast.kt b/src/main/java/org/distorted/library/effect/FragmentEffectContrast.kt
index bb6b9d3..ecdb513 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectContrast.kt
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectContrast.kt
@@ -38,7 +38,7 @@ class FragmentEffectContrast : FragmentEffect
         /**
          * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
          */
-        @JvmStatic fun enable()
+        fun enable()
         {
             addEffect(EffectName.CONTRAST, EffectName.SMOOTH_CONTRAST,
                 "color.rgb = mix(vec3(0.5,0.5,0.5), color.rgb, degree*(fUniforms[effect].x-1.0)+1.0 );")
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectSaturation.kt b/src/main/java/org/distorted/library/effect/FragmentEffectSaturation.kt
index 5fd14ee..466fa48 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectSaturation.kt
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectSaturation.kt
@@ -39,7 +39,7 @@ class FragmentEffectSaturation : FragmentEffect
         /**
          * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
          */
-        @JvmStatic fun enable()
+        fun enable()
         {
             addEffect(EffectName.SATURATION, EffectName.SMOOTH_SATURATION,
                 """
diff --git a/src/main/java/org/distorted/library/effect/PostprocessEffect.kt b/src/main/java/org/distorted/library/effect/PostprocessEffect.kt
index eb3b14b..9636ee2 100644
--- a/src/main/java/org/distorted/library/effect/PostprocessEffect.kt
+++ b/src/main/java/org/distorted/library/effect/PostprocessEffect.kt
@@ -102,7 +102,7 @@ abstract class PostprocessEffect internal constructor(name: EffectName) : Effect
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun createPrograms(GLSL: Int)
+        fun createPrograms(GLSL: Int)
         {
             var source: Source
             val len = mSources.size
diff --git a/src/main/java/org/distorted/library/effect/PostprocessEffectBlur.kt b/src/main/java/org/distorted/library/effect/PostprocessEffectBlur.kt
index 887ca18..2e770cd 100644
--- a/src/main/java/org/distorted/library/effect/PostprocessEffectBlur.kt
+++ b/src/main/java/org/distorted/library/effect/PostprocessEffectBlur.kt
@@ -37,12 +37,11 @@ class PostprocessEffectBlur(haloAndRadius: Data2D) : PostprocessEffectBlurred(Ef
         /**
          * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
          */
-        @JvmStatic fun enable() = enable("BLUR1", "BLUR2")
+        fun enable() = enable("BLUR1", "BLUR2")
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         // Clean up of static variables on exit. Called by reflection from super class.
         @Suppress("unused")
-        @JvmStatic
         fun destroyStatics() = PostprocessEffectBlurred.destroyStatics()
     }
 
diff --git a/src/main/java/org/distorted/library/effect/PostprocessEffectBlurred.kt b/src/main/java/org/distorted/library/effect/PostprocessEffectBlurred.kt
index 964a124..e064441 100644
--- a/src/main/java/org/distorted/library/effect/PostprocessEffectBlurred.kt
+++ b/src/main/java/org/distorted/library/effect/PostprocessEffectBlurred.kt
@@ -206,7 +206,7 @@ abstract class PostprocessEffectBlurred(name: EffectName) : PostprocessEffect(na
         private var mIndex2 = 0
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun destroyStatics()
+        fun destroyStatics()
         {
             mProgram1 = null
             mProgram2 = null
@@ -221,7 +221,7 @@ abstract class PostprocessEffectBlurred(name: EffectName) : PostprocessEffect(na
         /**
          * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
          */
-        @JvmStatic fun enable(prog1: String, prog2: String)
+        fun enable(prog1: String, prog2: String)
         {
             val vertex =
                 """ precision lowp float;     
diff --git a/src/main/java/org/distorted/library/effect/PostprocessEffectBorder.kt b/src/main/java/org/distorted/library/effect/PostprocessEffectBorder.kt
index 2ed892d..7a78627 100644
--- a/src/main/java/org/distorted/library/effect/PostprocessEffectBorder.kt
+++ b/src/main/java/org/distorted/library/effect/PostprocessEffectBorder.kt
@@ -39,11 +39,11 @@ class PostprocessEffectBorder(halo: Data1D, color: Data4D) : PostprocessEffect(E
     {
         ///////////////////////////////////////////////////////////////////////////////////////////
         // Clean up of static variables on exit. Called by reflection from super class.
-        @Suppress("unused") @JvmStatic fun destroyStatics() { }
+        @Suppress("unused") fun destroyStatics() { }
         /**
          * No local programs; we do not postprocess anything here. No need to do anything
          */
-        @JvmStatic fun enable() { }
+        fun enable() { }
     }
     ///////////////////////////////////////////////////////////////////////////////////////////////
     override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
diff --git a/src/main/java/org/distorted/library/effect/PostprocessEffectGlow.kt b/src/main/java/org/distorted/library/effect/PostprocessEffectGlow.kt
index b36ecdf..109f851 100644
--- a/src/main/java/org/distorted/library/effect/PostprocessEffectGlow.kt
+++ b/src/main/java/org/distorted/library/effect/PostprocessEffectGlow.kt
@@ -38,11 +38,11 @@ class PostprocessEffectGlow(haloAndRadius: Data2D, color: Data4D) : PostprocessE
         /**
          * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
          */
-        @JvmStatic fun enable() = enable("GLOW1", "GLOW2")
+        fun enable() = enable("GLOW1", "GLOW2")
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         // Clean up of static variables on exit. Called by reflection from super class.
-        @Suppress("unused") @JvmStatic fun destroyStatics() = PostprocessEffectBlurred.destroyStatics()
+        @Suppress("unused")  fun destroyStatics() = PostprocessEffectBlurred.destroyStatics()
     }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
diff --git a/src/main/java/org/distorted/library/effect/VertexEffect.kt b/src/main/java/org/distorted/library/effect/VertexEffect.kt
index ddeffe9..bcab5f1 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffect.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffect.kt
@@ -52,7 +52,7 @@ abstract class VertexEffect internal constructor(name: EffectName) : Effect(name
 
         val MAX_REGION: Static4D = Static4D(0f,0f,0f,1000000f)
 
-        @JvmStatic val allGLSL: String
+        val allGLSL: String
             get()
             {
                 if (!mFullPrepared)
@@ -63,7 +63,7 @@ abstract class VertexEffect internal constructor(name: EffectName) : Effect(name
 
                 return mFullGLSL+"{}"
             }
-        @JvmStatic val allEnabled: Int
+        val allEnabled: Int
             get()
             {
                 if (!mFullPrepared)
@@ -76,10 +76,10 @@ abstract class VertexEffect internal constructor(name: EffectName) : Effect(name
             }
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun getNumEnabled(): Int = numEnabled
+        fun getNumEnabled(): Int = numEnabled
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun getGLSL(): String = mGLSL+"{}"
+        fun getGLSL(): String = mGLSL+"{}"
 
         ///////////////////////////////////////////////////////////////////////////////////////////
         private fun retSection(effect: Int, code: String?): String
@@ -160,7 +160,6 @@ abstract class VertexEffect internal constructor(name: EffectName) : Effect(name
         /**
          * Return a constructed VertexEffect based on its name, the 5 variables, center & region.
          */
-        @JvmStatic
         fun constructEffect(name: String, vars: FloatArray, center: FloatArray, region: FloatArray): VertexEffect?
         {
             val staCenter = Static3D(center[0], center[1], center[2])
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectDeform.kt b/src/main/java/org/distorted/library/effect/VertexEffectDeform.kt
index 4e81e59..6c5f7b0 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectDeform.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectDeform.kt
@@ -95,7 +95,7 @@ class VertexEffectDeform : VertexEffect
         ///////////////////////////////////////////////////////////////////////////////////////////
         // 2020-05-03: replaced vec3 'u_Bounding' with a uniform 'vUniforms[effect].w' (i.e. mRadius)
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun code(): String
+        fun code(): String
         {
             return ("""
                      const vec3 ONE = vec3(1.0,1.0,1.0);                                 
@@ -135,7 +135,7 @@ class VertexEffectDeform : VertexEffect
         /**
          * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
          */
-        @JvmStatic fun enable() = addEffect(NAME, code())
+        fun enable() = addEffect(NAME, code())
     }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectDisappear.kt b/src/main/java/org/distorted/library/effect/VertexEffectDisappear.kt
index 33ddee7..38a0378 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectDisappear.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectDisappear.kt
@@ -29,8 +29,8 @@ class VertexEffectDisappear : VertexEffect(NAME)
     companion object
     {
         private val NAME = EffectName.DISAPPEAR
-        @JvmStatic fun code(): String = "v = vec3(0.0, 0.0, 0.0);"
-        @JvmStatic fun enable() = addEffect(NAME, code())
+        fun code(): String = "v = vec3(0.0, 0.0, 0.0);"
+        fun enable() = addEffect(NAME, code())
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectDistort.kt b/src/main/java/org/distorted/library/effect/VertexEffectDistort.kt
index 7c09c4a..dd3a980 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectDistort.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectDistort.kt
@@ -111,7 +111,7 @@ class VertexEffectDistort : VertexEffect
         // which makes Vrot = (a+n.y*c , b-n.y*c , v*n) where
         // a = vx*nz-vz*nx , b = vy*nz-vz*ny , c = (vx*ny-vy*nx)/(1+nz)    (unless n=(0,0,-1))
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun code(): String
+        fun code(): String
         {
             return (""" vec3 ps = vUniforms[effect+1].yzw - v;                        
                         vec3 force = vUniforms[effect].xyz;                           
@@ -138,7 +138,7 @@ class VertexEffectDistort : VertexEffect
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun enable() =addEffect(NAME, code())
+        fun enable() =addEffect(NAME, code())
     }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectMove.kt b/src/main/java/org/distorted/library/effect/VertexEffectMove.kt
index dc69165..f617a82 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectMove.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectMove.kt
@@ -33,8 +33,8 @@ class VertexEffectMove(vector: Data3D) : VertexEffect(NAME)
     companion object
     {
         private val NAME = EffectName.VERTEX_MOVE
-        @JvmStatic fun code(): String = "v += vUniforms[effect].xyz;"
-        @JvmStatic fun enable() = addEffect(NAME, code())
+        fun code(): String = "v += vUniforms[effect].xyz;"
+        fun enable() = addEffect(NAME, code())
     }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectPinch.kt b/src/main/java/org/distorted/library/effect/VertexEffectPinch.kt
index 120f84f..fefde92 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectPinch.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectPinch.kt
@@ -49,7 +49,7 @@ class VertexEffectPinch : VertexEffect
         // when h>1 we are pushing points away from S: P' = P + (1/h-1)*dist(line to P)
         // (where 'line' above passes through the center point and goes along the vector)
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun code(): String
+        fun code(): String
         {
             return ("""
                      vec3 ps = vUniforms[effect+1].yzw -v;               
@@ -78,7 +78,7 @@ class VertexEffectPinch : VertexEffect
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun enable() = addEffect(NAME, code())
+        fun enable() = addEffect(NAME, code())
     }
     ///////////////////////////////////////////////////////////////////////////////////////////////
     override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectPipe.kt b/src/main/java/org/distorted/library/effect/VertexEffectPipe.kt
index 207b0d1..8062b3d 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectPipe.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectPipe.kt
@@ -43,7 +43,7 @@ class VertexEffectPipe(pipe: Data5D, center: Data3D) : VertexEffect(NAME)
         // line defined by 'center' and 'vect' (so 'ps' is very small)
         // Then by means of some miracle we have
         // dot_ps>0, (sign_ps-1.0)==0.0 and dot_ps-(sign_ps-1.0) == 0.0 !! so n_ps - undef.
-        @JvmStatic fun code(): String
+        fun code(): String
         {
             return ("""
                      vec3 pc = vUniforms[effect+1].yzw - v;            
@@ -70,7 +70,7 @@ class VertexEffectPipe(pipe: Data5D, center: Data3D) : VertexEffect(NAME)
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun enable() = addEffect(NAME, code())
+        fun enable() = addEffect(NAME, code())
     }
     ///////////////////////////////////////////////////////////////////////////////////////////////
     override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectQuaternion.kt b/src/main/java/org/distorted/library/effect/VertexEffectQuaternion.kt
index 65b728b..1098675 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectQuaternion.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectQuaternion.kt
@@ -37,7 +37,7 @@ class VertexEffectQuaternion(quaternion: Data4D, center: Data3D) : VertexEffect(
         private val NAME = EffectName.VERTEX_QUATERNION
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun code(): String
+        fun code(): String
         {
             return ("""
                      float qx = vUniforms[effect].x;               
@@ -66,7 +66,7 @@ class VertexEffectQuaternion(quaternion: Data4D, center: Data3D) : VertexEffect(
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun enable() = addEffect(NAME, code())
+        fun enable() = addEffect(NAME, code())
     }
     ///////////////////////////////////////////////////////////////////////////////////////////////
     override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectRotate.kt b/src/main/java/org/distorted/library/effect/VertexEffectRotate.kt
index 1534842..66b8ebd 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectRotate.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectRotate.kt
@@ -39,7 +39,7 @@ class VertexEffectRotate(angle: Data1D, axis: Data3D, center: Data3D) : VertexEf
         private val NAME = EffectName.VERTEX_ROTATE
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun code(): String
+        fun code(): String
         {
             return ("""
                      float angle = vUniforms[effect].x*3.14159265/360.0;
@@ -71,7 +71,7 @@ class VertexEffectRotate(angle: Data1D, axis: Data3D, center: Data3D) : VertexEf
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun enable() = addEffect(NAME, code())
+        fun enable() = addEffect(NAME, code())
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectScale.kt b/src/main/java/org/distorted/library/effect/VertexEffectScale.kt
index 3291206..3d1b83c 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectScale.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectScale.kt
@@ -36,7 +36,7 @@ class VertexEffectScale : VertexEffect
         private val NAME = EffectName.VERTEX_SCALE
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun code(): String
+        fun code(): String
         {
             return """
                  v *= vUniforms[effect].xyz;                        
@@ -49,7 +49,7 @@ class VertexEffectScale : VertexEffect
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun enable() = addEffect(NAME, code())
+        fun enable() = addEffect(NAME, code())
     }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectShear.kt b/src/main/java/org/distorted/library/effect/VertexEffectShear.kt
index ff65bcf..7e0ebb3 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectShear.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectShear.kt
@@ -37,7 +37,7 @@ class VertexEffectShear(shear: Data3D, center: Data3D) : VertexEffect(NAME)
 
         ///////////////////////////////////////////////////////////////////////////////////////////
         // For explanation (esp. about the way we modify vectors n and i) see MatrixEffectShear.
-        @JvmStatic fun code(): String
+        fun code(): String
         {
             return ("""
                      float sx = vUniforms[effect].x;                  
@@ -62,7 +62,7 @@ class VertexEffectShear(shear: Data3D, center: Data3D) : VertexEffect(NAME)
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun enable() = addEffect(NAME, code())
+        fun enable() = addEffect(NAME, code())
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectSink.kt b/src/main/java/org/distorted/library/effect/VertexEffectSink.kt
index 41fa13c..c3ff29e 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectSink.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectSink.kt
@@ -45,7 +45,7 @@ class VertexEffectSink : VertexEffect
         // Changed to the four complicated lines because the previous Sink effect fails to fully inflate the
         // Masterball.
         // Current function inflates and deflates much more as H is at the extremes (close to 0 and inf)
-        @JvmStatic fun code(): String
+        fun code(): String
         {
             return ("""
                      vec3 ps = vUniforms[effect+1].yzw - v;            
@@ -69,7 +69,7 @@ class VertexEffectSink : VertexEffect
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun enable() = addEffect(NAME, code())
+        fun enable() = addEffect(NAME, code())
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectSwirl.kt b/src/main/java/org/distorted/library/effect/VertexEffectSwirl.kt
index 2d647be..cf6d384 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectSwirl.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectSwirl.kt
@@ -48,7 +48,7 @@ class VertexEffectSwirl : VertexEffect
         // This effect rotates the current vertex V by vInterpolated.x radians clockwise around the circle dilated
         // by (1-d) around the center of the effect S.
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun code(): String
+        fun code(): String
         {
             return ("""
                      vec3 center = vUniforms[effect+1].yzw;                             
@@ -67,7 +67,7 @@ class VertexEffectSwirl : VertexEffect
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun enable() = addEffect(NAME, code())
+        fun enable() = addEffect(NAME, code())
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectWave.kt b/src/main/java/org/distorted/library/effect/VertexEffectWave.kt
index 8aa0872..467a531 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectWave.kt
+++ b/src/main/java/org/distorted/library/effect/VertexEffectWave.kt
@@ -106,7 +106,7 @@ class VertexEffectWave : VertexEffect
         //
         // Generally speaking I'd keep to amplitude < length, as the opposite case has some other problems as well.
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun code(): String
+        fun code(): String
         {
             return ("""
                      vec3 center     = vUniforms[effect+1].yzw;                   
@@ -157,7 +157,7 @@ class VertexEffectWave : VertexEffect
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun enable() = addEffect(NAME, code())
+        fun enable() = addEffect(NAME, code())
     }
     ///////////////////////////////////////////////////////////////////////////////////////////////
     override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
diff --git a/src/main/java/org/distorted/library/effectqueue/EffectQueue.kt b/src/main/java/org/distorted/library/effectqueue/EffectQueue.kt
index 355b87a..f08cf12 100644
--- a/src/main/java/org/distorted/library/effectqueue/EffectQueue.kt
+++ b/src/main/java/org/distorted/library/effectqueue/EffectQueue.kt
@@ -64,7 +64,6 @@ abstract class EffectQueue : Slave
         private const val DETALL = 3
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic
         fun createQueues() : Array<EffectQueue>
         {
             val queues: Array<EffectQueue?> = arrayOfNulls(EffectType.LENGTH)
@@ -78,7 +77,6 @@ abstract class EffectQueue : Slave
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic
         fun createQueues(from: Array<EffectQueue>, flags: Int) : Array<EffectQueue>
         {
             val queues: Array<EffectQueue?> = arrayOfNulls(EffectType.LENGTH)
@@ -92,7 +90,6 @@ abstract class EffectQueue : Slave
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic
         fun compute(queues: Array<EffectQueue>, currTime: Long, step: Long)
         {
             (queues[0] as EffectQueueMatrix     ).compute(currTime, step)
@@ -102,7 +99,6 @@ abstract class EffectQueue : Slave
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic
         fun send(queues: Array<EffectQueue>, programH: Int, distance: Float, mipmap: Float,
                  projection: FloatArray, inflate: Float, variant: Int)
         {
@@ -113,7 +109,6 @@ abstract class EffectQueue : Slave
 
         ///////////////////////////////////////////////////////////////////////////////////////////
         // variant: 0 --> MAIN  1 --> OIT  2 --> prePOST  3 --> FULL
-        @JvmStatic
         fun getUniforms(programH: Int, variant: Int)
         {
             EffectQueueFragment.uniforms(programH, variant)
@@ -122,14 +117,12 @@ abstract class EffectQueue : Slave
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic
         fun setMax(index: Int, m: Int): Boolean
         {
             return InternalStackFrameList.setMax(index, max(m,0) )
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic
         fun getMax(index: Int): Int = InternalStackFrameList.getMax(index)
     }
 
diff --git a/src/main/java/org/distorted/library/effectqueue/EffectQueuePostprocess.kt b/src/main/java/org/distorted/library/effectqueue/EffectQueuePostprocess.kt
index 736f182..2cba968 100644
--- a/src/main/java/org/distorted/library/effectqueue/EffectQueuePostprocess.kt
+++ b/src/main/java/org/distorted/library/effectqueue/EffectQueuePostprocess.kt
@@ -67,7 +67,7 @@ class EffectQueuePostprocess : EffectQueue
         private var mPreProgramH = 0
 
         ///////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic
+        
         fun createPrograms(vert: InputStream, frag: InputStream, GLSL: Int)
         {
             val numV = VertexEffect.getNumEnabled()
diff --git a/src/main/java/org/distorted/library/helpers/MatrixHelper.kt b/src/main/java/org/distorted/library/helpers/MatrixHelper.kt
index 7731c26..f02e48d 100644
--- a/src/main/java/org/distorted/library/helpers/MatrixHelper.kt
+++ b/src/main/java/org/distorted/library/helpers/MatrixHelper.kt
@@ -23,7 +23,7 @@ package org.distorted.library.helpers
 
 object MatrixHelper
 {
-    @JvmStatic fun setIdentity(output: FloatArray)
+    fun setIdentity(output: FloatArray)
     {
         output[ 0] = 1f
         output[ 1] = 0f
@@ -44,7 +44,6 @@ object MatrixHelper
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-    @JvmStatic
     fun multiply(output: FloatArray, m1: FloatArray, m2: FloatArray)
     {
         output[ 0] = m1[0] * m2[ 0] + m1[4] * m2[ 1] + m1[ 8] * m2[ 2] + m1[12] * m2[ 3]
@@ -69,7 +68,6 @@ object MatrixHelper
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-    @JvmStatic
     fun frustum(output: FloatArray, l: Float, r: Float, b: Float, t: Float, n: Float, f: Float)
     {
         output[ 0] = 2 * n / (r - l)
@@ -91,7 +89,6 @@ object MatrixHelper
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-    @JvmStatic
     fun ortho(output: FloatArray, l: Float, r: Float, b: Float, t: Float, n: Float, f: Float)
     {
         output[ 0] = 2 / (r - l)
@@ -124,7 +121,6 @@ object MatrixHelper
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // this is android.opengl.Matrix.rotateM(), but with pre-computed sin and cos of the angle
     // and also we have to pre-allocate and pass here two temp arrays.
-    @JvmStatic
     fun rotateSinCos(output: FloatArray, tmp1: FloatArray, tmp2: FloatArray, sin: Float, cos: Float, x: Float, y: Float, z: Float)
     {
         tmp1[ 0] = (1-cos)*x*x + cos
@@ -165,7 +161,6 @@ object MatrixHelper
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-    @JvmStatic
     fun translate(output: FloatArray, dx: Float, dy: Float, dz: Float)
     {
         output[12] += (output[0]*dx + output[4]*dy + output[ 8]*dz)
@@ -175,7 +170,6 @@ object MatrixHelper
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-    @JvmStatic
     fun scale(output: FloatArray, sx: Float, sy: Float, sz: Float)
     {
         output[ 0] *= sx
diff --git a/src/main/java/org/distorted/library/main/DistortedLibrary.kt b/src/main/java/org/distorted/library/main/DistortedLibrary.kt
index 4d58a65..68ae97b 100644
--- a/src/main/java/org/distorted/library/main/DistortedLibrary.kt
+++ b/src/main/java/org/distorted/library/main/DistortedLibrary.kt
@@ -128,7 +128,7 @@ object DistortedLibrary
      * There are only three possibilities: 300 (OpenGL ES 3.0) or 310 (at least OpenGL ES 3.1)
      * or 200 (OpenGL ES 2.0)
      */
-    @JvmStatic var gLSL: Int = 0
+     var gLSL: Int = 0
         private set
     private var mGLSL_VERSION: String? = null
     private var mOITCompilationAttempted = false
@@ -137,7 +137,7 @@ object DistortedLibrary
     /**
      * Return the maximum size of the texture supported by the driver.
      */
-    @JvmStatic var maxTextureSize: Int = Int.MAX_VALUE
+    var maxTextureSize: Int = Int.MAX_VALUE
         private set
 
     /**
@@ -1020,8 +1020,6 @@ object DistortedLibrary
      * @param user The Code which will be using this library, which must implement the LibraryUser interface.
      * @param queueSize the size of the FBO queue, a workaround for the bug on Mali drivers. Use a small integer - 1,...,4
      */
-    @JvmStatic
-    @JvmOverloads
     fun onSurfaceCreated(user: LibraryUser, queueSize: Int = 4)
     {
         mUser = user
@@ -1092,7 +1090,6 @@ object DistortedLibrary
     /**
      * Switch face culling on/off
      */
-    @JvmStatic
     fun setCull(on: Boolean)
     {
         if (on)
@@ -1114,8 +1111,6 @@ object DistortedLibrary
      * @param id id of an Activity that is using the library; anything unique so that the Library can
      * tell between Activities in case you're going to be using it from more than one.
      */
-    @JvmStatic
-    @JvmOverloads
     fun onCreate(id: Long = 0)
     {
         InternalStackFrameList.onCreate(id)
@@ -1129,8 +1124,6 @@ object DistortedLibrary
      * @param id id of an Activity that is using the library; anything unique so that the Library can
      * tell between Activities in case you're going to be using it from more than one.
      */
-    @JvmStatic
-    @JvmOverloads
     fun onResume(id: Long = 0)
     {
         InternalStackFrameList.onResume(id)
@@ -1144,8 +1137,6 @@ object DistortedLibrary
      * @param id id of an Activity that is using the library; anything unique so that the Library can
      * tell between Activities in case you're going to be using it from more than one.
      */
-    @JvmStatic
-    @JvmOverloads
     fun onPause(id: Long = 0)
     {
         InternalStackFrameList.onPause(id)
@@ -1181,8 +1172,6 @@ object DistortedLibrary
      * @param id id of an Activity that is using the library; anything unique so that the Library can
      * tell between Activities in case you're going to be using it from more than one.
      */
-    @JvmStatic
-    @JvmOverloads
     fun onDestroy(id: Long = 0)
     {
         if (isInitialized)
@@ -1197,7 +1186,6 @@ object DistortedLibrary
      * suffer from a very slow compilation of GLSL program if said program includes Transform Feedback.
      * Return true if the platform we are running on does not suffer from this problem.
      */
-    @JvmStatic
     fun fastCompilationTF(): Boolean
     {
         return mFastCompilationTF
@@ -1209,7 +1197,6 @@ object DistortedLibrary
     /**
      * Call this before calling onSurfaceCreated() if you want to access normal vectors in CPU.
      */
-    @JvmStatic
     fun needTransformFeedback()
     {
         mNeedsTransformFeedback = true
@@ -1246,7 +1233,6 @@ object DistortedLibrary
      * than Byte.MAX_VALUE
      * @return `true` if operation was successful, `false` otherwise.
      */
-    @JvmStatic
     @Suppress("unused")
     fun setMax(type: EffectType, max: Int): Boolean
     {
diff --git a/src/main/java/org/distorted/library/main/DistortedTexture.kt b/src/main/java/org/distorted/library/main/DistortedTexture.kt
index c069af8..eef8c24 100644
--- a/src/main/java/org/distorted/library/main/DistortedTexture.kt
+++ b/src/main/java/org/distorted/library/main/DistortedTexture.kt
@@ -33,7 +33,7 @@ import android.opengl.GLUtils
  * Create a Texture of arbitrary size and feed some pixels to it via the setTexture() method.
  */
 class DistortedTexture
-@JvmOverloads constructor(type: Int = TYPE_USER) : InternalSurface(NOT_CREATED_YET, 1, 1, type, STORAGE_PRIVATE)
+constructor(type: Int = TYPE_USER) : InternalSurface(NOT_CREATED_YET, 1, 1, type, STORAGE_PRIVATE)
 {
     private var mBmp: Bitmap? = null
     private var mBitmapInverted = false
diff --git a/src/main/java/org/distorted/library/main/InternalNodeData.kt b/src/main/java/org/distorted/library/main/InternalNodeData.kt
index 2a7ba6d..3e88099 100644
--- a/src/main/java/org/distorted/library/main/InternalNodeData.kt
+++ b/src/main/java/org/distorted/library/main/InternalNodeData.kt
@@ -23,17 +23,17 @@ package org.distorted.library.main
 /**
  * This is a member of DistortedNode. Makes sure two isomorphic Nodes only get rendered once.
  */
-class InternalNodeData(@JvmField val ID: Long, private val mKey: ArrayList<Long>)
+class InternalNodeData( val ID: Long, private val mKey: ArrayList<Long>)
 {
     private var numPointingNodes = 1
     private var currTime: Long
-    @JvmField var mFBO: DistortedFramebuffer? = null
+    var mFBO: DistortedFramebuffer? = null
 
     init { currTime = -1 }
 
     companion object
     {
-        @JvmStatic fun returnData(list: ArrayList<Long>): InternalNodeData
+        fun returnData(list: ArrayList<Long>): InternalNodeData
         {
             var data = InternalStackFrameList.getMapID(list)
             if (data!=null) data.numPointingNodes++
diff --git a/src/main/java/org/distorted/library/main/InternalOutputSurface.kt b/src/main/java/org/distorted/library/main/InternalOutputSurface.kt
index 055d863..3281b0b 100644
--- a/src/main/java/org/distorted/library/main/InternalOutputSurface.kt
+++ b/src/main/java/org/distorted/library/main/InternalOutputSurface.kt
@@ -38,7 +38,7 @@ import kotlin.math.tan
  */
 abstract class InternalOutputSurface
     internal constructor(var mWidth: Int, var mHeight: Int, createColor: Int, numfbos: Int, numcolors: Int,
-                         @JvmField var mDepthStencil: Int, fbo: Int, type: Int, storage: Int)
+                         var mDepthStencil: Int, fbo: Int, type: Int, storage: Int)
     : InternalSurface(createColor, numfbos, numcolors, type, storage), InternalChildrenList.Parent
 {
     var fOV: Float
@@ -57,16 +57,16 @@ abstract class InternalOutputSurface
     private val mChildren: InternalChildrenList
     private val mBufferInitialized: BooleanArray
 
-    @JvmField var mDistance: Float = 0f
-    @JvmField var mNear: Float
-    @JvmField var mMipmap: Float = 1.0f
-    @JvmField var mProjectionMatrix: FloatArray
-    @JvmField var mDepthStencilCreated: Int
-    @JvmField var mDepthStencilH: IntArray? = null
-    @JvmField var mFBOH: IntArray
-    @JvmField var mRealWidth: Int // the Surface can be backed up by a texture larger than the viewport we have to it.
-    @JvmField var mRealHeight: Int // mWidth,mHeight are the sizes of the Viewport, those - sizes of the backing up texture.
-    @JvmField var mCurrFBO: Int = 0 // internal current FBO (see DistortedLibrary.FBO_QUEUE_SIZE)
+    var mDistance: Float = 0f
+    var mNear: Float
+    var mMipmap: Float = 1.0f
+    var mProjectionMatrix: FloatArray
+    var mDepthStencilCreated: Int
+    var mDepthStencilH: IntArray? = null
+    var mFBOH: IntArray
+    var mRealWidth: Int // the Surface can be backed up by a texture larger than the viewport we have to it.
+    var mRealHeight: Int // mWidth,mHeight are the sizes of the Viewport, those - sizes of the backing up texture.
+    var mCurrFBO: Int = 0 // internal current FBO (see DistortedLibrary.FBO_QUEUE_SIZE)
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     companion object
@@ -123,7 +123,6 @@ abstract class InternalOutputSurface
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic
         @Synchronized
         fun onPause()
         {
diff --git a/src/main/java/org/distorted/library/main/InternalRenderState.kt b/src/main/java/org/distorted/library/main/InternalRenderState.kt
index 80a2154..62f489a 100644
--- a/src/main/java/org/distorted/library/main/InternalRenderState.kt
+++ b/src/main/java/org/distorted/library/main/InternalRenderState.kt
@@ -467,14 +467,14 @@ class InternalRenderState internal constructor()
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun switchOffDrawing()
+        fun switchOffDrawing()
         {
             GLES30.glEnable(GLES30.GL_SCISSOR_TEST)
             GLES30.glScissor(0, 0, 0, 0)
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic fun restoreDrawing()
+        fun restoreDrawing()
         {
             GLES30.glDisable(GLES30.GL_SCISSOR_TEST)
         }
diff --git a/src/main/java/org/distorted/library/main/InternalStackFrameList.kt b/src/main/java/org/distorted/library/main/InternalStackFrameList.kt
index 4828f1f..6954883 100644
--- a/src/main/java/org/distorted/library/main/InternalStackFrameList.kt
+++ b/src/main/java/org/distorted/library/main/InternalStackFrameList.kt
@@ -41,7 +41,6 @@ object InternalStackFrameList
     private val mFrameList = ArrayList<InternalStackFrame?>()
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-    @JvmStatic
     fun onCreate(taskId: Long)
     {
         val num = mFrameList.size
@@ -73,7 +72,6 @@ object InternalStackFrameList
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-    @JvmStatic
     fun onResume(taskId: Long)
     {
         val num = mFrameList.size
@@ -94,7 +92,6 @@ object InternalStackFrameList
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-    @JvmStatic
     fun onPause(taskId: Long)
     {
         val num = mFrameList.size
@@ -116,7 +113,6 @@ object InternalStackFrameList
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-    @JvmStatic
     fun onDestroy(taskId: Long)
     {
         val num = mFrameList.size
@@ -201,7 +197,7 @@ object InternalStackFrameList
         }
     }
 
-    @JvmStatic val nextEffectsID: Long get() = currentFrame!!.nextEffectsID
+    val nextEffectsID: Long get() = currentFrame!!.nextEffectsID
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     fun getMapID(key: ArrayList<Long>): InternalNodeData?
@@ -225,7 +221,6 @@ object InternalStackFrameList
 
     val nextEffectID: Long get() = currentFrame!!.nextEffectID
 
-    @JvmStatic
     var isInitialized: Boolean
         get() = currentFrame!!.isInitialized
         set(init)
diff --git a/src/main/java/org/distorted/library/main/InternalSurface.kt b/src/main/java/org/distorted/library/main/InternalSurface.kt
index efc2c33..c59555b 100644
--- a/src/main/java/org/distorted/library/main/InternalSurface.kt
+++ b/src/main/java/org/distorted/library/main/InternalSurface.kt
@@ -25,10 +25,10 @@ import android.opengl.GLES30
 // common parent class of Texture & OutputSurface; so that we can store either in Nodes.
 abstract class InternalSurface(create: Int, numfbos: Int, numcolors: Int, type: Int, storage: Int) : InternalObject(type, storage)
 {
-    @JvmField var mColorCreated: Int = create
-    @JvmField var mNumColors   : Int = numcolors
-    @JvmField var mNumFBOs     : Int = numfbos
-    @JvmField var mColorH      : IntArray? = null
+    var mColorCreated: Int = create
+    var mNumColors   : Int = numcolors
+    var mNumFBOs     : Int = numfbos
+    var mColorH      : IntArray? = null
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     init
diff --git a/src/main/java/org/distorted/library/mesh/DeferredJobs.kt b/src/main/java/org/distorted/library/mesh/DeferredJobs.kt
index f75ba9a..abb8bad 100644
--- a/src/main/java/org/distorted/library/mesh/DeferredJobs.kt
+++ b/src/main/java/org/distorted/library/mesh/DeferredJobs.kt
@@ -241,7 +241,6 @@ object DeferredJobs
      *
      * @y.exclude
      */
-    @JvmStatic
     fun onPause()
     {
         val num = mJobs.size
diff --git a/src/main/java/org/distorted/library/mesh/MeshBase.kt b/src/main/java/org/distorted/library/mesh/MeshBase.kt
index bc04c73..240e197 100644
--- a/src/main/java/org/distorted/library/mesh/MeshBase.kt
+++ b/src/main/java/org/distorted/library/mesh/MeshBase.kt
@@ -101,7 +101,6 @@ abstract class MeshBase
         /**
          * How many mesh components are we going to need? Call before compilation of the shaders.
          */
-        @JvmStatic
         var maxEffComponents: Int = 100
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -109,11 +108,9 @@ abstract class MeshBase
          * Are we going to need per-component centers (needed for correct postprocessing of concave meshes)
          * Switching this on allocates 16*MAX_EFFECT_COMPONENTS bytes for uniforms in the vertex shader.
          */
-        @JvmStatic
         var useCenters: Boolean = false
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic
         fun getUniforms(programH: Int, variant: Int)
         {
             mCenterBlockIndex[variant] = GLES30.glGetUniformBlockIndex(programH, "componentCenter")
diff --git a/src/main/java/org/distorted/library/mesh/MeshMultigon.kt b/src/main/java/org/distorted/library/mesh/MeshMultigon.kt
index 3463a6b..710bbe9 100644
--- a/src/main/java/org/distorted/library/mesh/MeshMultigon.kt
+++ b/src/main/java/org/distorted/library/mesh/MeshMultigon.kt
@@ -692,7 +692,6 @@ class MeshMultigon : MeshBase
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         // PUBLIC API
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic
         fun computeEdgesUp(vertices: Array<Array<FloatArray>>): Array<IntArray>
         {
             val numPoly = vertices.size
@@ -709,7 +708,6 @@ class MeshMultigon : MeshBase
         }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-        @JvmStatic
         fun computeOuterAndHoleVertices(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray>): Array<Array<FloatArray>>
         {
             val tmp = ArrayList<FloatArray>()
diff --git a/src/main/java/org/distorted/library/message/EffectMessageSender.kt b/src/main/java/org/distorted/library/message/EffectMessageSender.kt
index 7a2284b..253fbd4 100644
--- a/src/main/java/org/distorted/library/message/EffectMessageSender.kt
+++ b/src/main/java/org/distorted/library/message/EffectMessageSender.kt
@@ -75,7 +75,7 @@ private constructor() : Thread()
         private var mStartTime: Long = 0
         private var mStopTime: Long  = 0
 
-        @JvmStatic fun startSending()
+        fun startSending()
         {
             synchronized(mLock)
             {
@@ -91,7 +91,7 @@ private constructor() : Thread()
             }
         }
 
-        @JvmStatic fun stopSending()
+        fun stopSending()
         {
             synchronized(mLock)
             {
@@ -106,7 +106,7 @@ private constructor() : Thread()
             }
         }
 
-        @JvmStatic fun newMessage(effect: Effect)
+        fun newMessage(effect: Effect)
         {
             val numListeners = effect.numListeners
 
@@ -129,10 +129,10 @@ private constructor() : Thread()
             }
         }
 
-        @JvmStatic val isRunning: Boolean
+        val isRunning: Boolean
             get() = mThis!=null
 
-        @JvmStatic fun restartThread()
+        fun restartThread()
         {
             synchronized(mLock)
             {
@@ -145,7 +145,7 @@ private constructor() : Thread()
             }
         }
 
-        @JvmStatic fun reportState(): String
+        fun reportState(): String
         {
             return "running "+(mThis!=null)+" notify="+mNotify+" elements="+mList!!.size+
                     " start="+mStartTime+" stop="+mStopTime+" numStarts="+mNumStarts
diff --git a/src/main/java/org/distorted/library/program/DistortedProgram.kt b/src/main/java/org/distorted/library/program/DistortedProgram.kt
index 1fa24e6..043f947 100644
--- a/src/main/java/org/distorted/library/program/DistortedProgram.kt
+++ b/src/main/java/org/distorted/library/program/DistortedProgram.kt
@@ -49,17 +49,17 @@ class DistortedProgram
      * Pre has 3 attributes (position,texcoord,component)
      * Maybe there are other possibilities (only position and normal? 3- position,normal,texcoord?)
      */
-    @JvmField var mAttributeLayout: Int = 0
+    var mAttributeLayout: Int = 0
 
     /**
      * List of Attributes (OpenGL ES 3.0: 'in' variables), in the same order as declared in the shader source.
      */
-    @JvmField var mAttribute: IntArray? = null
+    var mAttribute: IntArray? = null
 
     /**
      * List of Uniforms, in the same order as declared in the shader source.
      */
-    @JvmField var mUniform: IntArray? = null
+    var mUniform: IntArray? = null
 
     companion object
     {
diff --git a/src/main/java/org/distorted/library/type/Dynamic.kt b/src/main/java/org/distorted/library/type/Dynamic.kt
index 002464a..6d721f8 100644
--- a/src/main/java/org/distorted/library/type/Dynamic.kt
+++ b/src/main/java/org/distorted/library/type/Dynamic.kt
@@ -117,7 +117,7 @@ abstract class Dynamic
         private const val NUM_NOISE = 5 // used iff mNoise>0.0. Number of intermediary points between each pair of adjacent vectors
         private var mPausedTime: Long = 0
 
-        @JvmStatic fun onPause() { mPausedTime = System.currentTimeMillis() }
+        fun onPause() { mPausedTime = System.currentTimeMillis() }
     }
 
     var dimension: Int = 0