/ - Diff - Distorted Android

« Previous | Next »

Revision 9829a8fd

Added by Leszek Koltunski 7 days ago

ID 9829a8fdb75895c375b4bb56ba06f7b842e62f7d
Parent d59f9e0c
Child 2885d4f1

migrate the 'effect' package.

     // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     package org.distorted.library.effect;
     package org.distorted.library.effect
     import org.distorted.library.effectqueue.EffectQueue;
     import org.distorted.library.main.DistortedLibrary;
     import org.distorted.library.main.InternalStackFrameList;
     import org.distorted.library.message.EffectListener;
     import java.lang.reflect.Method;
     import java.util.ArrayList;
     import org.distorted.library.effectqueue.EffectQueue
     import org.distorted.library.main.DistortedLibrary
     import org.distorted.library.main.InternalStackFrameList
     import org.distorted.library.message.EffectListener
     import java.lang.reflect.Method
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Abstract Effect of any type.
      */
     public abstract class Effect
+      {
       private final static int MAX_UNITY_DIM = 4;
       private final static int NUM_EFFECTS = EffectName.LENGTH;
       private final long mID;
       private final EffectType mType;
       private final EffectName mName;
       private final int mDimension;
       private final int mRegionDim;
       private final int mCenterDim;
       private ArrayList<EffectListener> mListeners =null;
       private int mNumListeners=0;  // ==mListeners.length(), but we only create mListeners if the first one gets added
       private final static float[] mUnity= new float[MAX_UNITY_DIM*NUM_EFFECTS];
       private final static int[]   mUnityDim = new int[NUM_EFFECTS];
       int mAndAssociation;
       int mEquAssociation;
       static boolean[] mEnabled = new boolean[NUM_EFFECTS];
       static
+        {
         for(int i=0; i<NUM_EFFECTS; i++) mEnabled[i] = false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public abstract void addQueue(EffectQueue queue);
       public abstract void remQueue(EffectQueue queue);
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       Effect(EffectName name)
+        {
         mName      = name;
         mType      = name.getType();
         mDimension = name.getEffectDimension();
         mCenterDim = name.getCenterDimension();
         mRegionDim = name.getRegionDimension();
         mAndAssociation = 0xffffffff;
         mEquAssociation = 0;
         int n = name.ordinal();
         float[] u = name.getUnity();
         int l = u.length;
         System.arraycopy(u, 0, mUnity, MAX_UNITY_DIM*n, l);
         mUnityDim[n] = l;
         mID = (InternalStackFrameList.getNextEffectID()<<EffectType.LENGTH) + mType.ordinal();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static void onPause()
+        {
         for(int i=0; i<NUM_EFFECTS; i++) mEnabled[i] = false;
         MatrixEffect.destroyStatics();
         VertexEffect.destroyStatics();
         FragmentEffect.destroyStatics();
         PostprocessEffect.destroyStatics();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public abstract boolean compute(float[] uniforms, int index, long currentDuration, long step );
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public int getNumListeners()
+        {
         return mNumListeners;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public EffectListener removeFirstListener()
+        {
         if( mNumListeners>0 )
+          {
           mNumListeners--;
           return mListeners.remove(0);
+          }
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public void writeAssociations(int[] intUniforms, int index1, int index2)
+        {
         intUniforms[index1] = mAndAssociation;
         intUniforms[index2] = mEquAssociation;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Do the set of Uniforms written in buffer[index], buffer[index+1], etc represent a Unity, i.e a
      * null Effect?
      */
       public boolean isUnity(float[] buffer, int index)
+        {
         int name = mName.ordinal();
         switch(mUnityDim[name])
+          {
           case 0: return true;
           case 1: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ];
           case 2: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
                          buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1];
           case 3: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
                          buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&
                          buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2];
           case 4: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
                          buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&
                          buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2] &&
                          buffer[index+3]==mUnity[MAX_UNITY_DIM*name+3];
+          }
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // this will enable() all Fragment Effects twice (once for smooth variant, once for non-smooth)
     // but this shouldn't matter.
     /**
      * Enable all effects of a given type.
+     *
      * @param type EffectType to enable.
      */
       public static void enableEffects(EffectType type)
+        {
         Method method;
     abstract class Effect internal constructor (val name: EffectName)
+    {
         val iD: Long                                     // unique ID of this Effect.
         val type: EffectType = name.type                 // EffectType enum corresponding to this Effect.
         val effectDimension: Int = name.effectDimension  // number of Uniforms needed to describe this effect.
         val regionDimension: Int = name.regionDimension  // dimension of the Region supported by this effect (0- no region supported at all).
         val centerDimension: Int = name.centerDimension  // dimension of the Center supported by this effect (0- no center supported at all).
         var numListeners: Int = 0                        // ==mListeners.length(), but we only create mListeners if the first one gets added
             private set
         val string: String get() = name.name             // printable name of this Effect.
         var mAndAssociation: Int = -0x1
         var mEquAssociation: Int = 0
         private var mListeners: ArrayList<EffectListener>? = null
         companion object
+        {
             private const val MAX_UNITY_DIM = 4
             private val NUM_EFFECTS: Int = EffectName.LENGTH
             private val mUnity = FloatArray(MAX_UNITY_DIM*NUM_EFFECTS)
             private val mUnityDim = IntArray(NUM_EFFECTS)
             var mEnabled: BooleanArray = BooleanArray(NUM_EFFECTS)
             init
+            {
                 for (i in 0 until NUM_EFFECTS) mEnabled[i] = false
+            }
         for(EffectName name: EffectName.values())
+          {
           if( name.getType() == type )
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             /**
              * Only for use by the library itself.
+             *
              * @y.exclude
              */
             @JvmStatic
             fun onPause()
+            {
             Class<? extends Effect> cls = name.getEffectClass();
                 for (i in 0 until NUM_EFFECTS) mEnabled[i] = false
             try
+              {
               method = cls.getMethod("enable");  // getMethod and NOT getDeclaredMethod because enable()
                                                  // is public
+              }
             catch(NoSuchMethodException ex)
+              {
               DistortedLibrary.logMessage("Effect: exception getting method: "+ex.getMessage());
               method = null;
+              }
                 MatrixEffect.destroyStatics()
                 VertexEffect.destroyStatics()
                 FragmentEffect.destroyStatics()
                 PostprocessEffect.destroyStatics()
+            }
             try
+              {
               if( method!=null ) method.invoke(null);
+              }
             catch(Exception ex)
+              {
               DistortedLibrary.logMessage("Effect: exception invoking method: "+ex.getMessage());
+              }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             // this will enable() all Fragment Effects twice (once for smooth variant, once for non-smooth)
             // but this shouldn't matter.
             /**
              * Enable all effects of a given type.
+             *
              * @param type EffectType to enable.
              */
             @JvmStatic
             fun enableEffects(type: EffectType)
+            {
                 var method: Method?
                 for (name in EffectName.entries)
+                {
                     if (name.type==type)
+                    {
                         val cls = name.effectClass
                         try
+                        {
                             method = cls.getMethod("enable") // getMethod and NOT getDeclaredMethod because enable() is public
+                        }
                         catch (ex: NoSuchMethodException)
+                        {
                             DistortedLibrary.logMessage("Effect: exception getting method: "+ex.message)
                             method = null
+                        }
                         try
+                        {
                             method?.invoke(null)
+                        }
                         catch (ex: Exception)
+                        {
                             DistortedLibrary.logMessage("Effect: exception invoking method: "+ex.message)
+                        }
+                    }
+                }
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the EffectType enum corresponding to this Effect.
+     *
      * @see EffectType
      */
       public EffectType getType()
+        {
         return mType;
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         abstract fun addQueue(queue: EffectQueue)
         abstract fun remQueue(queue: EffectQueue)
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         init
+        {
             val n = name.ordinal
             val u = name.unity
             val l = u.size
             System.arraycopy(u, 0, mUnity, MAX_UNITY_DIM*n, l)
             mUnityDim[n] = l
             iD = (InternalStackFrameList.getNextEffectID() shl EffectType.LENGTH)+type.ordinal
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Only for use by the library itself.
+         *
          * @y.exclude
          */
         abstract fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Only for use by the library itself.
+         *
          * @y.exclude
          */
         fun removeFirstListener(): EffectListener?
+        {
             if (numListeners>0)
+            {
                 numListeners--
                 return mListeners!!.removeAt(0)
+            }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the EffectName enum corresponding to this Effect.
+     *
      * @see EffectName
      */
       public EffectName getName()
+        {
         return mName;
             return null
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the unique ID of this Effect.
      */
       public long getID()
+        {
         return mID;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return a printable name of this Effect.
      */
       public String getString()
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Only for use by the library itself.
+         *
          * @y.exclude
          */
         fun writeAssociations(intUniforms: IntArray, index1: Int, index2: Int)
+        {
         return mName.name();
             intUniforms[index1] = mAndAssociation
             intUniforms[index2] = mEquAssociation
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the dimension of the Center supported by this effect (0- no center supported at all).
      */
       public int getCenterDimension()
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         // PUBLIC API
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Do the set of Uniforms written in buffer[i+(0..dim)] represent a Unity, i.e a null Effect?
          */
         fun isUnity(buffer: FloatArray, i: Int): Boolean
+        {
         return mCenterDim;
+        }
             val n = name.ordinal
             val d = MAX_UNITY_DIM*n
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the dimension of the Region supported by this effect (0- no region supported at all).
      */
       public int getRegionDimension()
+        {
         return mRegionDim;
+        }
             when (mUnityDim[n])
+            {
 -> return true
 -> return buffer[i]==mUnity[d]
 -> return buffer[i]==mUnity[d] && buffer[i+1]==mUnity[d+1]
 -> return buffer[i]==mUnity[d] && buffer[i+1]==mUnity[d+1] && buffer[i+2]==mUnity[d+2]
 -> return buffer[i]==mUnity[d] && buffer[i+1]==mUnity[d+1] && buffer[i+2]==mUnity[d+2] && buffer[i+3]==mUnity[d+3]
+            }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the number of Uniforms needed to describe this effect.
      */
       public int getEffectDimension()
+        {
         return mDimension;
             return false
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Adds the calling class to the list of Listeners that get notified when this Effect gets 'finished'
      * i.e. when the Dynamic inside this Effect reaches its final point and stops moving. This will be sent
      * only once, on the first time the Dynamic reaches its final point.
+     *
      * If there's no Dynamic, ths message will never be sent.
+     *
      * @param el A class implementing the EffectListener interface that wants to get notifications.
      */
       public void notifyWhenFinished(EffectListener el)
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Adds the calling class to the list of Listeners that get notified when this Effect gets 'finished'
          * i.e. when the Dynamic inside this Effect reaches its final point and stops moving. This will be sent
          * only once, on the first time the Dynamic reaches its final point.
+         *
          * If there's no Dynamic, ths message will never be sent.
+         *
          * @param el A class implementing the EffectListener interface that wants to get notifications.
          */
         fun notifyWhenFinished(el: EffectListener)
+        {
         if( mListeners==null ) mListeners = new ArrayList<>();
             if (mListeners==null) mListeners = ArrayList()
         if( !mListeners.contains(el) )
+          {
           mListeners.add(el);
           mNumListeners++;
+          }
             if (!mListeners!!.contains(el))
+            {
                 mListeners!!.add(el)
                 numListeners++
+            }
+        }
+      }
+    }

     // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     package org.distorted.library.effect;
     package org.distorted.library.effect
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Names of Effects one can add to the DistortedEffects queues.
      * <p>
      * Effect's 'Type' is one of the constants defined in {@link EffectType}.
      * </p>
      * <p>
+     *
      * Effect's 'Type' is one of the constants defined in [EffectType].
+     *
      * Effect's 'Uniforms' are a vector of 7 (matrix effects) 12 (vertex) or 8 (fragment) floats, which
      * together form full information how to compute a given effect.
      * Typically, some of those values will be Interpolated in CPU (by one of the 'EffectQueueX.compute()'
      * methods) and the effect of such Interpolation sent to the Shaders.
      * </p>
      * <p>
+     *
      * Effect's 'Unity' is such a particular vector of its 'interpolated values' which makes the
      * effect NULL. For example, if the effect is 'MOVE' by a 3-dimensional vector, then a 'NULL
      * MOVE' is a MOVE by vector (0,0,0), thus (0,0,0) is the unity of the MOVE effect.
      * This is used by the EffectQueue classes to decide if the final form of the Effect is NULL - and
      * thus if it can safely be removed from Effect Queues without affecting the visual in any way.
      * </p>
      */
     public enum EffectName
+      {
       // EFFECT NAME /////// EFFECT TYPE ////////// EFFECT UNITY //////////// DIM REGION CENTER // CLASS
       ROTATE           ( EffectType.MATRIX  ,   new float[] {0.0f}           , 4, 0,     3    , MatrixEffectRotate.class       ),
       QUATERNION       ( EffectType.MATRIX  ,   new float[] {0.0f,0.0f,0.0f} , 4, 0,     3    , MatrixEffectQuaternion.class   ),
       MOVE             ( EffectType.MATRIX  ,   new float[] {0.0f,0.0f,0.0f} , 3, 0,     0    , MatrixEffectMove.class         ),
       SCALE            ( EffectType.MATRIX  ,   new float[] {1.0f,1.0f,1.0f} , 3, 0,     0    , MatrixEffectScale.class        ),
       SHEAR            ( EffectType.MATRIX  ,   new float[] {0.0f,0.0f,0.0f} , 3, 0,     3    , MatrixEffectShear.class        ),
       DISTORT          ( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 3, 4,     3    , VertexEffectDistort.class      ),
       DEFORM           ( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 4, 4,     3    , VertexEffectDeform.class       ),
       SINK             ( EffectType.VERTEX  ,   new float[] {1.0f}           , 1, 4,     3    , VertexEffectSink.class         ),
       PINCH            ( EffectType.VERTEX  ,   new float[] {1.0f}           , 3, 4,     3    , VertexEffectPinch.class        ),
       SWIRL            ( EffectType.VERTEX  ,   new float[] {0.0f}           , 1, 4,     3    , VertexEffectSwirl.class        ),
       WAVE             ( EffectType.VERTEX  ,   new float[] {0.0f}           , 5, 4,     3    , VertexEffectWave.class         ),
       DISAPPEAR        ( EffectType.VERTEX  ,   new float[] {}               , 0, 0,     0    , VertexEffectDisappear.class    ),
       PIPE             ( EffectType.VERTEX  ,   new float[] {1,0f}           , 5, 0,     3    , VertexEffectPipe.class         ),
       VERTEX_MOVE      ( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 3, 0,     0    , VertexEffectMove.class         ),
       VERTEX_QUATERNION( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 4, 0,     3    , VertexEffectQuaternion.class   ),
       VERTEX_ROTATE    ( EffectType.VERTEX  ,   new float[] {0.0f}           , 4, 0,     3    , VertexEffectRotate.class       ),
       VERTEX_SCALE     ( EffectType.VERTEX  ,   new float[] {1.0f,1.0f,1.0f} , 3, 0,     0    , VertexEffectScale.class        ),
       VERTEX_SHEAR     ( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 3, 0,     3    , VertexEffectShear.class        ),
       ALPHA            ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, 3,     3    , FragmentEffectAlpha.class      ),
       SMOOTH_ALPHA     ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, 3,     3    , FragmentEffectAlpha.class      ),
       CHROMA           ( EffectType.FRAGMENT,   new float[] {0.0f}           , 4, 3,     3    , FragmentEffectChroma.class     ),
       SMOOTH_CHROMA    ( EffectType.FRAGMENT,   new float[] {0.0f}           , 4, 3,     3    , FragmentEffectChroma.class     ),
       BRIGHTNESS       ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, 3,     3    , FragmentEffectBrightness.class ),
       SMOOTH_BRIGHTNESS( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, 3,     3    , FragmentEffectBrightness.class ),
       SATURATION       ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, 3,     3    , FragmentEffectSaturation.class ),
       SMOOTH_SATURATION( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, 3,     3    , FragmentEffectSaturation.class ),
       CONTRAST         ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, 3,     3    , FragmentEffectContrast.class   ),
       SMOOTH_CONTRAST  ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, 3,     3    , FragmentEffectContrast.class   ),
       BLUR             ( EffectType.POSTPROCESS,new float[] {0.0f}           , 2, 0,     0    , PostprocessEffectBlur.class    ),
       GLOW             ( EffectType.POSTPROCESS,new float[] {0.0f}           , 6, 0,     0    , PostprocessEffectGlow.class    ),
       BORDER           ( EffectType.POSTPROCESS,new float[] {0.0f}           , 5, 0,     0    , PostprocessEffectBorder.class  ),
+      ;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static final int LENGTH = values().length;
       private final EffectType type;
       private final float[] unity;
       private final int dimension;
       private final int regionDim;
       private final int centerDim;
       private final Class<? extends Effect> effectClass;
       private static final int[] dimensions;
       private static final int[] regionDimension;
       private static final int[] centerDimension;
       private static final EffectName[] names;  // copy the values() to a local variable so that we
                                                 // don't have to keep recreating the array every time
       static
     enum class EffectName( type: EffectType, unity: FloatArray, dim: Int, regionDim: Int, centerDim: Int, effectClass: Class<out Effect?>)
+    {
         // EFFECT NAME /////// EFFECT TYPE ////////// EFFECT UNITY //////////// DIM REGION CENTER // CLASS
         ROTATE           (EffectType.MATRIX,      floatArrayOf(0.0f),             4, 0, 3, MatrixEffectRotate::class.java),
         QUATERNION       (EffectType.MATRIX,      floatArrayOf(0.0f, 0.0f, 0.0f), 4, 0, 3, MatrixEffectQuaternion::class.java),
         MOVE             (EffectType.MATRIX,      floatArrayOf(0.0f, 0.0f, 0.0f), 3, 0, 0, MatrixEffectMove::class.java),
         SCALE            (EffectType.MATRIX,      floatArrayOf(1.0f, 1.0f, 1.0f), 3, 0, 0, MatrixEffectScale::class.java),
         SHEAR            (EffectType.MATRIX,      floatArrayOf(0.0f, 0.0f, 0.0f), 3, 0, 3, MatrixEffectShear::class.java),
         DISTORT          (EffectType.VERTEX,      floatArrayOf(0.0f, 0.0f, 0.0f), 3, 4, 3, VertexEffectDistort::class.java),
         DEFORM           (EffectType.VERTEX,      floatArrayOf(0.0f, 0.0f, 0.0f), 4, 4, 3, VertexEffectDeform::class.java),
         SINK             (EffectType.VERTEX,      floatArrayOf(1.0f),             1, 4, 3, VertexEffectSink::class.java),
         PINCH            (EffectType.VERTEX,      floatArrayOf(1.0f),             3, 4, 3, VertexEffectPinch::class.java),
         SWIRL            (EffectType.VERTEX,      floatArrayOf(0.0f),             1, 4, 3, VertexEffectSwirl::class.java),
         WAVE             (EffectType.VERTEX,      floatArrayOf(0.0f),             5, 4, 3, VertexEffectWave::class.java),
         DISAPPEAR        (EffectType.VERTEX,      floatArrayOf(),                 0, 0, 0, VertexEffectDisappear::class.java),
         PIPE             (EffectType.VERTEX,      floatArrayOf(1f, 0f),           5, 0, 3, VertexEffectPipe::class.java),
         VERTEX_MOVE      (EffectType.VERTEX,      floatArrayOf(0.0f, 0.0f, 0.0f), 3, 0, 0, VertexEffectMove::class.java),
         VERTEX_QUATERNION(EffectType.VERTEX,      floatArrayOf(0.0f, 0.0f, 0.0f), 4, 0, 3, VertexEffectQuaternion::class.java),
         VERTEX_ROTATE    (EffectType.VERTEX,      floatArrayOf(0.0f),             4, 0, 3, VertexEffectRotate::class.java),
         VERTEX_SCALE     (EffectType.VERTEX,      floatArrayOf(1.0f, 1.0f, 1.0f), 3, 0, 0, VertexEffectScale::class.java),
         VERTEX_SHEAR     (EffectType.VERTEX,      floatArrayOf(0.0f, 0.0f, 0.0f), 3, 0, 3, VertexEffectShear::class.java),
         ALPHA            (EffectType.FRAGMENT,    floatArrayOf(1.0f),             1, 3, 3, FragmentEffectAlpha::class.java),
         SMOOTH_ALPHA     (EffectType.FRAGMENT,    floatArrayOf(1.0f),             1, 3, 3, FragmentEffectAlpha::class.java),
         CHROMA           (EffectType.FRAGMENT,    floatArrayOf(0.0f),             4, 3, 3, FragmentEffectChroma::class.java),
         SMOOTH_CHROMA    (EffectType.FRAGMENT,    floatArrayOf(0.0f),             4, 3, 3, FragmentEffectChroma::class.java),
         BRIGHTNESS       (EffectType.FRAGMENT,    floatArrayOf(1.0f),             1, 3, 3, FragmentEffectBrightness::class.java),
         SMOOTH_BRIGHTNESS(EffectType.FRAGMENT,    floatArrayOf(1.0f),             1, 3, 3, FragmentEffectBrightness::class.java),
         SATURATION       (EffectType.FRAGMENT,    floatArrayOf(1.0f),             1, 3, 3, FragmentEffectSaturation::class.java),
         SMOOTH_SATURATION(EffectType.FRAGMENT,    floatArrayOf(1.0f),             1, 3, 3, FragmentEffectSaturation::class.java),
         CONTRAST         (EffectType.FRAGMENT,    floatArrayOf(1.0f),             1, 3, 3, FragmentEffectContrast::class.java),
         SMOOTH_CONTRAST  (EffectType.FRAGMENT,    floatArrayOf(1.0f),             1, 3, 3, FragmentEffectContrast::class.java),
         BLUR             (EffectType.POSTPROCESS, floatArrayOf(0.0f),             2, 0, 0, PostprocessEffectBlur::class.java),
         GLOW             (EffectType.POSTPROCESS, floatArrayOf(0.0f),             6, 0, 0, PostprocessEffectGlow::class.java),
         BORDER           (EffectType.POSTPROCESS, floatArrayOf(0.0f),             5, 0, 0, PostprocessEffectBorder::class.java),
+        ;
         ///////////////////////////////////////////////////////////////////////////////////////////////
         val type: EffectType
         val unity: FloatArray
         private val dimension: Int
         private val regionDim: Int
         private val centerDim: Int
         val effectClass: Class<out Effect?>
         val effectDimension: Int get() = dimensions[ordinal]
         val regionDimension: Int get() = Companion.regionDimension[ordinal]
         val centerDimension: Int get() = Companion.centerDimension[ordinal]
         companion object
+        {
         int i=0;
         dimensions      = new int[LENGTH];
         regionDimension = new int[LENGTH];
         centerDimension = new int[LENGTH];
         names           = new EffectName[LENGTH];
         for(EffectName name: EffectName.values())
+          {
           dimensions[i]      = name.dimension;
           regionDimension[i] = name.regionDim;
           centerDimension[i] = name.centerDim;
           names[i]           = name;
           i++;
+          }
             val LENGTH: Int = entries.size
             private val dimensions: IntArray
             private val regionDimension: IntArray
             private val centerDimension: IntArray
             private val names: Array<EffectName?> // copy the values() to a local variable so that we
                                                   // don't have to keep recreating the array every time
             init
+            {
                 dimensions      = IntArray(LENGTH)
                 regionDimension = IntArray(LENGTH)
                 centerDimension = IntArray(LENGTH)
                 names           = arrayOfNulls(LENGTH)
                 for ( (i,name) in entries.withIndex() )
+                {
                     dimensions[i]      = name.dimension
                     regionDimension[i] = name.regionDim
                     centerDimension[i] = name.centerDim
                     names[i]           = name
+                }
+            }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float[] getUnity()
+        {
         return unity;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       EffectName(EffectType type, float[] unity, int dimension, int regionDim,
                  int centerDim, Class<? extends Effect> effectClass )
         ///////////////////////////////////////////////////////////////////////////////////////////////
         init
+        {
         this.type        = type;
         this.unity       = unity;
         this.dimension   = dimension;
         this.regionDim   = regionDim;
         this.centerDim   = centerDim;
         this.effectClass = effectClass;
             this.type        = type
             this.unity       = unity
             this.dimension   = dim
             this.regionDim   = regionDim
             this.centerDim   = centerDim
             this.effectClass = effectClass
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns the Type of an individual Effect. For example, EffectName.ROTATE.getType() will
      * return EffectType.MATRIX.
      * @return type of the effect.
      */
       public EffectType getType()
+        {
         return type;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns the Class of an individual Effect. For example, EffectName.ROTATE.getEffectClass()
      * returns MatrixEffectRotate.class.
      * @return effect class.
      */
       public Class<? extends Effect> getEffectClass()
+        {
         return effectClass;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns the i-th EffectName.
      * <p>
      * If you want to loop over all possible Effects, you need this.
      */
       public static EffectName getName(int ordinal)
+        {
         return names[ordinal];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns the dimension of an Effect (in other words, the number of interpolated values).
      * @return dimension of the Effect.
      */
       public int getEffectDimension() { return dimensions[ordinal()]; }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * What is the dimension of the Region supported by this effect?
      * @return Dimension of the Region supported (0-region not supported at all).
      */
       public int getRegionDimension() { return regionDimension[ordinal()]; }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * What is the dimension of the Center supported by this effect?
      * @return Dimension of the Center supported (0-center not supported at all).
      */
       public int getCenterDimension() { return centerDimension[ordinal()]; }
+      }
         ///////////////////////////////////////////////////////////////////////////////////////////////
         fun getName(ordinal: Int): EffectName? = names[ordinal]
+    }

     // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     package org.distorted.library.effect;
     package org.distorted.library.effect
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     import org.distorted.library.main.DistortedEffects;
     /**
      * A list of quality levels.
      * <p>
+     *
      * One can set quality of a Postprocessing Effect to one of those. The lower the quality, the faster
      * the rendering will be.
+     *
      * @see DistortedEffects
      */
     public enum EffectQuality
+      {
       HIGHEST  ( 0, 1.000f ),   // has to start from 0
       HIGH     ( 1, 0.500f ),
       MEDIUM   ( 2, 0.250f ),
       LOW      ( 3, 0.125f );
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Numof of possible qualities.
      */
       public static final int LENGTH = values().length;
       private final int level;
       private final float mipmap;
       private static final EffectQuality[] qualities;
       static
     enum class EffectQuality(val level: Int, private val mipmap: Float)
+    {
         HIGHEST(0, 1.000f),  // has to start from 0
         HIGH   (1, 0.500f),
         MEDIUM (2, 0.250f),
         LOW    (3, 0.125f);
         companion object
+        {
         int i=0;
         qualities= new EffectQuality[LENGTH];
         for(EffectQuality q: EffectQuality.values()) qualities[i++] = q;
+        }
             @JvmField val LENGTH: Int = entries.size
             private val qualities: Array<EffectQuality?>
     ///////////////////////////////////////////////////////////////////////////////////////////////////
             init
+            {
                 var i=0
                 qualities = arrayOfNulls(LENGTH)
                 for (q in entries) qualities[i++] = q
+            }
       EffectQuality(int level, float mipmap)
+        {
         this.level = level;
         this.mipmap= mipmap;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public int getLevel()
+        {
         return level;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static float getMipmap(int quality)
+        {
         return qualities[quality].mipmap;
             @JvmStatic fun getMipmap(quality: Int): Float = qualities[quality]!!.mipmap
+        }
+      }
+    }

     // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     package org.distorted.library.effect;
     package org.distorted.library.effect
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Types of Effects one can add to the DistortedEffects queues.
      * <p>
+     *
      * Each effect type goes to an independent queue; the queues get executed one-by-one
      * and are each a class descendant from EffectQueue.
      */
     public enum EffectType
+      {
       /**
        * Effects that change the ModelView matrix: Rotations, Moves, Shears, Scales.
        */
       MATRIX,
       /**
        * Effects that get executed in the Vertex shader: various distortions of the vertices.
        */
       VERTEX,
       /**
        * Effects executed in the Fragment shader: changes of color, hue, transparency levels, etc.
        */
       FRAGMENT,
       /**
        * Postprocessing effects done to the texture the first stage fragment shader created
        */
       POSTPROCESS;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Number of effect types.
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static final int LENGTH = values().length;
     /**
      * Needed when we do bitwise operations on Effect Types.
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static final int MASK= (1<<LENGTH)-1;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static void reset(int[] maxtable)
     enum class EffectType
+    {
         MATRIX,      // Effects that change the ModelView matrix: Rotations, Moves, Shears, Scales.
         VERTEX,      // Effects that get executed in the Vertex shader: various distortions of the vertices.
         FRAGMENT,    // Effects executed in the Fragment shader: changes of color, hue, transparency levels, etc.
         POSTPROCESS; // Postprocessing effects done to the texture the first stage fragment shader created
         companion object
+        {
         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
                            // to EffectQueueMatrix.setMax(int)
         maxtable[1] = 30;  // Max 30 VERTEX Effects
         maxtable[2] =  5;  // Max 5 FRAGMENT Effects
         maxtable[3] =  3;  // Max 3 POSTPROCESSING Effects
             @JvmField val LENGTH: Int = entries.size
             @JvmField val MASK: Int = (1 shl LENGTH)-1
             @JvmStatic 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
                                   // to EffectQueueMatrix.setMax(int)
                 maxtable[1] = 30  // Max 30 VERTEX Effects
                 maxtable[2] = 5   // Max 5 FRAGMENT Effects
                 maxtable[3] = 3   // Max 3 POSTPROCESSING Effects
+            }
             fun getType(ordinal: Int): EffectType = entries[ordinal]
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns the i-th EffectType.
      * <p>
      * If you want to loop over all possible effect types, you need this.
      */
       public static EffectType getType(int ordinal)
+        {
         return values()[ordinal];
+        }
+      }
+    }

     // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     package org.distorted.library.effect;
     package org.distorted.library.effect
     import org.distorted.library.effectqueue.EffectQueue;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.effectqueue.EffectQueue
     import org.distorted.library.type.Static3D
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Abstract class that represents an Effect that works by injecting certain code into the main Fragment shader.
      */
     public abstract class FragmentEffect extends Effect
+      {
       /**
        * 12: 4-per effect interpolated values, 3 dimensional Center (+padding), 3 dimensional Region (+padding).
        */
       public static final int NUM_FLOAT_UNIFORMS = 12;
       /**
        * 4: the name, unused, unused, unused
        */
       public static final int NUM_INT_UNIFORMS = 4;
     abstract class FragmentEffect internal constructor(name: EffectName) : Effect(name)
+    {
         override fun addQueue(queue: EffectQueue) { /* NO OP */ }
         override fun remQueue(queue: EffectQueue) { /* NO OP */ }
       static final int CENTER_OFFSET = 5;
       static final int REGION_OFFSET = 8;
       private static String mGLSL = "";
       private static int mNumEnabled = 0;
       final static Static3D MAX_REGION = new Static3D(1000000,1000000,1000000);
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       FragmentEffect(EffectName name)
+        {
         super(name);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // prepare code to be injected into the 'main_fragment_shader' main() function.
       static void addEffect(EffectName not_smooth, EffectName yes_smooth, String code)
+        {
         int effect1 = not_smooth.ordinal();
         int effect2 = yes_smooth.ordinal();
         if( mEnabled[effect1] ) return;
         mEnabled[effect1] = true;
         mNumEnabled ++;
         mGLSL +=
              "if( fProperties[i].x =="+effect1+")\n"
             +  "{\n"
             +  "degree = sign(degree); \n"
             +   code +"\n"
             +  "}\n"
             +"else\n"
             +"if( fProperties[i].x =="+effect2+")\n"
             +  "{\n"
             +   code +"\n"
             +  "}\n"
             +"else\n";
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static String getGLSL()
+        {
         return mGLSL + "{}";
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static void destroyStatics()
+        {
         mNumEnabled = 0;
         mGLSL = "";
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public void addQueue(EffectQueue queue)
+        {
         // NO OP
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public void remQueue(EffectQueue queue)
+        {
         // NO OP
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the number of Fragment effects enabled.
      */
       public static int getNumEnabled()
         companion object
+        {
         return mNumEnabled;
             const val NUM_FLOAT_UNIFORMS: Int = 12 // 4-per effect interpolated values, 3 dimensional Center (+padding), 3 dimensional Region (+padding).
             const val NUM_INT_UNIFORMS  : Int = 4  // the name, unused, unused, unused
             const val CENTER_OFFSET: Int = 5
             const val REGION_OFFSET: Int = 8
             private var mGLSL = ""
             private var numEnabled: Int = 0  //  number of Fragment effects enabled.
             val MAX_REGION: Static3D = Static3D(1000000f, 1000000f, 1000000f)
             @JvmStatic val gLSL: String get() = mGLSL+"{}"
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             // prepare code to be injected into the 'main_fragment_shader' main() function.
             fun addEffect(notSmooth: EffectName, yesSmooth: EffectName, code: String)
+            {
                 val effect1 = notSmooth.ordinal
                 val effect2 = yesSmooth.ordinal
                 if (mEnabled[effect1]) return
                 mEnabled[effect1] = true
                 numEnabled++
                 mGLSL +=
                     ("""
                         if( fProperties[i].x ==$effect1)
+                        {
                         degree = sign(degree);
                         $code
+                        }
                         else
                         if( fProperties[i].x ==$effect2)
+                        {
                         $code
+                        }
                         else
                         """.trimIndent())
+            }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             fun destroyStatics()
+            {
                 numEnabled = 0
                 mGLSL = ""
+            }
+        }
+      }
+    }

     // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     package org.distorted.library.effect;
     package org.distorted.library.effect
     import org.distorted.library.type.Data1D;
     import org.distorted.library.type.Data3D;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Data1D
     import org.distorted.library.type.Data3D
     import org.distorted.library.type.Static3D
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Make a certain Region change its transparency level.
      */
     public class FragmentEffectAlpha extends FragmentEffect
+      {
       private final Data1D mAlpha;
       private final Data3D mCenter;
       private final Data3D mRegion;
     class FragmentEffectAlpha : FragmentEffect
+    {
         private val mAlpha: Data1D
         private val mCenter: Data3D
         private val mRegion: Data3D
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
         companion object
+        {
         mCenter.get(uniforms, index+CENTER_OFFSET, currentDuration, step);
         mRegion.get(uniforms, index+REGION_OFFSET, currentDuration, step);
         return mAlpha.get(uniforms,index, currentDuration, step);
             /**
              * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
              */
             @JvmStatic
             fun enable()
+            {
                 addEffect(EffectName.ALPHA, EffectName.SMOOTH_ALPHA,
                     "color.a *= (degree*(fUniforms[effect].x-1.0)+1.0);")
+            }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * @param alpha  level of transparency we want to have at any given moment: pixel.a *= alpha.
      *               Valid range: <0,1>
      * @param center center of the Effect (point in 3D).
      * @param region Region this Effect is limited to (3 radii defining an ellipsoid).
      * @param smooth If true, the level of 'alpha' will smoothly fade out towards the edges of the region.
      */
       public FragmentEffectAlpha(Data1D alpha, Data3D center, Data3D region, boolean smooth)
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Only for use by the library itself.
+         *
          * @y.exclude
          */
         override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
+        {
         super(smooth? EffectName.SMOOTH_ALPHA:EffectName.ALPHA);
         mAlpha  = alpha;
         mCenter = center;
         mRegion = (region==null ? MAX_REGION : region);
             mCenter.get(uniforms, index+CENTER_OFFSET, currentDuration, step)
             mRegion.get(uniforms, index+REGION_OFFSET, currentDuration, step)
             return mAlpha.get(uniforms, index, currentDuration, step)
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Object smoothly change its transparency level.
+     *
      * @param alpha  level of transparency we want to have at any given moment: pixel.a *= alpha.
      *               Valid range: <0,1>
      */
       public FragmentEffectAlpha(Data1D alpha)
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         // PUBLIC API
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Makes a certain sub-region of the Object smoothly change its transparency level.
+         *
          * @param alpha  level of transparency we want to have at any given moment: pixel.a *= alpha.
          * Valid range: <0,1>
          * @param center center of the Effect (point in 3D).
          * @param region Region this Effect is limited to (3 radii defining an ellipsoid).
          * @param smooth If true, the level of 'alpha' will smoothly fade out towards the edges of the region.
          */
         constructor(alpha: Data1D, center: Data3D, region: Data3D?, smooth: Boolean) : super(if (smooth) EffectName.SMOOTH_ALPHA else EffectName.ALPHA)
+        {
         super(EffectName.ALPHA);
         mAlpha  = alpha;
         mCenter = new Static3D(0,0,0);
         mRegion = MAX_REGION;
             mAlpha = alpha
             mCenter = center
             mRegion = (region ?: MAX_REGION)
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
      */
       public static void enable()
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Makes the whole Object smoothly change its transparency level.
+         *
          * @param alpha  level of transparency we want to have at any given moment: pixel.a *= alpha.
          * Valid range: <0,1>
          */
         constructor(alpha: Data1D) : super(EffectName.ALPHA)
+        {
         addEffect( EffectName.ALPHA,EffectName.SMOOTH_ALPHA,
                    "color.a *= (degree*(fUniforms[effect].x-1.0)+1.0);" );
             mAlpha = alpha
             mCenter = Static3D(0f,0f,0f)
             mRegion = MAX_REGION
+        }
+      }
+    }

     // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     package org.distorted.library.effect;
     package org.distorted.library.effect
     import org.distorted.library.type.Data1D;
     import org.distorted.library.type.Data3D;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Data1D
     import org.distorted.library.type.Data3D
     import org.distorted.library.type.Static3D
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Make a certain Region change its brightness level.
      */
     public class FragmentEffectBrightness extends FragmentEffect
+      {
       private final Data1D mBrightness;
       private final Data3D mCenter;
       private final Data3D mRegion;
     class FragmentEffectBrightness : FragmentEffect
+    {
         private val mBrightness: Data1D
         private val mCenter: Data3D
         private val mRegion: Data3D
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
         companion object
+        {
         mCenter.get(uniforms, index+CENTER_OFFSET, currentDuration, step);
         mRegion.get(uniforms, index+REGION_OFFSET, currentDuration, step);
         return mBrightness.get(uniforms,index,currentDuration,step);
             /**
              * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
              */
             @JvmStatic
             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 );")
+            }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
+     *
      * @param brightness level of brightness we want to have at any given moment. Valid range: <0,infinity)
      * @param center center of the Effect (point in 3D).
      * @param region Region this Effect is limited to (3 radii defining an ellipsoid).
      * @param smooth     If true, the level of 'brightness' will smoothly fade out towards the edges of the region.
      */
       public FragmentEffectBrightness(Data1D brightness, Data3D center, Data3D region, boolean smooth)
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Only for use by the library itself.
+         *
          * @y.exclude
          */
         override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
+        {
         super(smooth?EffectName.SMOOTH_BRIGHTNESS:EffectName.BRIGHTNESS);
         mBrightness = brightness;
         mCenter = center;
         mRegion = (region==null ? MAX_REGION : region);
             mCenter.get(uniforms, index+CENTER_OFFSET, currentDuration, step)
             mRegion.get(uniforms, index+REGION_OFFSET, currentDuration, step)
             return mBrightness.get(uniforms, index, currentDuration, step)
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Object smoothly change its brightness level.
+     *
      * @param brightness level of brightness we want to have at any given moment. Valid range: <0,infinity)
      */
       public FragmentEffectBrightness(Data1D brightness)
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         // PUBLIC API
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Makes a certain sub-region of the Object smoothly change its brightness level.
+         *
          * @param brightness level of brightness we want to have at any given moment. Valid range: <0,infinity)
          * @param center center of the Effect (point in 3D).
          * @param region Region this Effect is limited to (3 radii defining an ellipsoid).
          * @param smooth     If true, the level of 'brightness' will smoothly fade out towards the edges of the region.
          */
         constructor(brightness: Data1D, center: Data3D, region: Data3D?, smooth: Boolean) : super(if (smooth) EffectName.SMOOTH_BRIGHTNESS else EffectName.BRIGHTNESS)
+        {
         super(EffectName.BRIGHTNESS);
         mBrightness = brightness;
         mCenter = new Static3D(0,0,0);
         mRegion = MAX_REGION;
             mBrightness = brightness
             mCenter = center
             mRegion = (region ?: MAX_REGION)
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
      */
       public static void enable()
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Makes the whole Object smoothly change its brightness level.
+         *
          * @param brightness level of brightness we want to have at any given moment. Valid range: <0,infinity)
          */
         constructor(brightness: Data1D) : super(EffectName.BRIGHTNESS)
+        {
         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 );" );
             mBrightness = brightness
             mCenter = Static3D(0f,0f,0f)
             mRegion = MAX_REGION
+        }
+      }
+    }

     // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     package org.distorted.library.effect;
     package org.distorted.library.effect
     import org.distorted.library.type.Data1D;
     import org.distorted.library.type.Data3D;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Data1D
     import org.distorted.library.type.Data3D
     import org.distorted.library.type.Static3D
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Make a certain Region change its color.
      */
     public class FragmentEffectChroma extends FragmentEffect
+      {
       private final Data1D mBlend;
       private final Data3D mColor;
       private final Data3D mCenter;
       private final Data3D mRegion;
     class FragmentEffectChroma : FragmentEffect
+    {
         private val mBlend: Data1D
         private val mColor: Data3D
         private val mCenter: Data3D
         private val mRegion: Data3D
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
         companion object
+        {
         mColor.get(uniforms,index+1,currentDuration,step);
         mCenter.get(uniforms,index+CENTER_OFFSET,currentDuration,step);
         mRegion.get(uniforms,index+REGION_OFFSET,currentDuration,step);
         return mBlend.get(uniforms,index,currentDuration,step);
             /**
              * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
              */
             fun enable()
+            {
                 addEffect(EffectName.CHROMA, EffectName.SMOOTH_CHROMA,
                     "color.rgb = mix(color.rgb, fUniforms[effect].yzw, degree*fUniforms[effect].x);")
+            }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * @param blend  level of blend a given pixel will be mixed with the next parameter 'color':
      *               pixel = (1-level)*pixel + level*color.
      *               Valid range: <0,1>
      * @param color  Color to mix. (1,0,0) is RED.
      * @param center center of the Effect (point in 3D).
      * @param region Region this Effect is limited to (3 radii defining an ellipsoid).
      * @param smooth If true, the level of 'blend' will smoothly fade out towards the edges of the region.
      */
       public FragmentEffectChroma(Data1D blend, Data3D color, Data3D center, Data3D region, boolean smooth)
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Only for use by the library itself.
+         *
          * @y.exclude
          */
         override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean
+        {
         super(smooth?EffectName.SMOOTH_CHROMA:EffectName.CHROMA);
         mBlend  = blend;
         mColor  = color;
         mCenter = center;
         mRegion = (region==null ? MAX_REGION : region);
             mColor.get(uniforms, index+1, currentDuration, step)
             mCenter.get(uniforms, index+CENTER_OFFSET, currentDuration, step)
             mRegion.get(uniforms, index+REGION_OFFSET, currentDuration, step)
             return mBlend.get(uniforms, index, currentDuration, step)
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Object smoothly change all three of its RGB components.
+     *
      * @param blend  level of blend a given pixel will be mixed with the next parameter 'color':

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision 9829a8fd

Added by Leszek Koltunski 7 days ago