/ - Diff - Distorted Android

« Previous | Next »

Revision 2fce34f4

Added by Leszek Koltunski over 9 years ago

ID 2fce34f4faa05b2817b9e1ba91a55cebee1b9474
Parent 568b29d8
Child f2fe7e28

Major push towards simplifying DistortedObject's public API.
All Fragment effects are using the new API - the 'DataND' marker interfaces.

         return mM.add(EffectNames.SCALE,scale);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Scales the Object by one uniform factor in all 3 dimensions. Convenience function.
+     *
      * @param scale The factor to scale all 3 dimensions with.
      * @return      ID of the effect added, or -1 if we failed to add one.
      */
     public long scale(float scale)
+      {
       return mM.add(EffectNames.SCALE, new Static3D(scale,scale,scale));
+      }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object by 'angle' degrees around the center.
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object by 'angle' degrees around the center.
      * Static axis of rotation is given by the last parameter.
      * Here both angle and axis can dynamically change.
+     *
      * @param center    Coordinates of the Point we are rotating around.
      * @param angleaxis Combined 4-tuple representing the (angle,axisX,axisY,axisZ).
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Fragment-based effects
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // MACROBLOCK
     /**
      * Creates macroblocks at and around point defined by the Dynamic2D and the Region.
      * Size of the macroblocks at any given time is returned by the Dynamic1D.
      * Creates macroblocks at and around point defined by the Region.
+     *
      * @param size   1-dimensional Dynamic which, at any given time, returns the size of the macroblocks.
      * @param region Region this Effect is limited to.
      *               Null here means 'apply the effect to the whole Object'.
      * @param center 2-dimensional Dynamic which, at any given time, returns a Static2D representing the
      *               current center of the effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long macroblock(Dynamic1D size, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.MACROBLOCK, size, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Creates macroblocks at and around point defined by the Point2D and the Region.
      * Size of the macroblocks at any given time is returned by the Dynamic1D.
      * <p>
      * The difference between this and the previous method is that here the center of the Effect stays constant.
+     *
      * @param size   1-dimensional Dynamic which, at any given time, returns the size of the macroblocks.
      * @param region Region this Effect is limited to.
      *               Null here means 'apply the effect to the whole Object'.
      * @param center Center of the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long macroblock(Dynamic1D size, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.MACROBLOCK, size, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Creates macroblocks at and around point defined by the Dynamic2D and the Region.
      * <p>
      * The macroblocks change in size; at time 0 there are none, and after 'duration/2' milliseconds
      * they are of (pixels X pixels) size; after 'duration' milliseconds there are again none (i.e. their
      * size is 1X1, i.e. 1 pixel).
+     *
      * @param pixels   Maximum size, in pixels, of the Macroblocks we want to see.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the effect to the whole Object'.
      * @param center   2-dimensional Dynamic which, at any given time, returns a Static2D representing the
      *                 current center of the effect.
      * @param duration Time, in milliseconds, it takes to do one full interpolation.
      * @param count    Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long macroblock(int pixels, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(pixels));
         return mF.add(EffectNames.MACROBLOCK, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Creates macroblocks at and around point defined by the Point2D and the Region.
      * <p>
      * The macroblocks change in size; at time 0 there are none, and after 'duration/2' milliseconds
      * they are of (pixels X pixels) size; after 'duration' milliseconds there are again none (i.e. their
      * size is 1X1, i.e. 1 pixel).
      * <p>
      * The difference between this and the previous method is that here the center of the Effect stays constant.
+     *
      * @param pixels   Maximum size, in pixels, of the Macroblocks we want to see.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the effect to the whole Object'.
      * @param center   Center of the Effect.
      * @param duration Time, in milliseconds, it takes to do one full interpolation.
      * @param count    Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return         ID of the effect added, or -1 if we failed to add one.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long macroblock(int pixels, Static4D region, Static2D center, int duration, float count)
       public long macroblock(Data1D size, Data4D region)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(pixels));
         return mF.add(EffectNames.MACROBLOCK, di, region, center);
         return mF.add(EffectNames.MACROBLOCK, size, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Creates macroblocks on the whole Object.
      * <p>
      * The macroblocks change in size; at time 0 there are none, and after 'duration/2' milliseconds
      * they are of (pixels X pixels) size; after 'duration' milliseconds there are again none (i.e. their
      * size is 1X1, i.e. 1 pixel).
      * <p>
      * The difference between this and the previous method is that here there is no masking Region; thus
      * there is also no center of the Effect.
+     *
      * @param pixels   Maximum size, in pixels, of the Macroblocks we want to see.
      * @param duration Time, in milliseconds, it takes to do one full interpolation.
      * @param count    Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return         ID of the effect added, or -1 if we failed to add one.
+     *
      * @param size   1-dimensional Data which, at any given time, returns the size of the macroblocks.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long macroblock(int pixels, int duration, float count)
       public long macroblock(Data1D size)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(pixels));
         return mF.add(EffectNames.MACROBLOCK, di, null, mZero2D);
         return mF.add(EffectNames.MACROBLOCK, size);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // CHROMA
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * @param blend  1-dimensional Dynamic that returns the level of blend a given pixel will be
      * @param blend  1-dimensional Data that returns the level of blend a given pixel will be
      *               mixed with the next parameter 'color': pixel = (1-level)*pixel + level*color
      * @param color  Color to mix. (1,0,0) is RED.
      * @param region Region this Effect is limited to.
      *               Null here means 'apply the Effect to the whole Object'.
      * @param center 2-dimensional Dynamic which, at any given time, returns a Static2D representing
      *               the current center of the effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      * @param region Region this Effect is limited to.
      * @param smooth If true, the level of 'blend' will smoothly fade out towards the edges of the region.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long chroma(Dynamic1D blend, Static3D color, Static4D region, Dynamic2D center)
       public long chroma(Data1D blend, Static3D color, Data4D region, boolean smooth)
+        {
         return mF.add(EffectNames.CHROMA, blend, color, region, center);
         return mF.add( smooth? EffectNames.SMOOTH_CHROMA:EffectNames.CHROMA, blend, color, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param blend  1-dimensional Dynamic that returns the level of blend a given pixel will be
      * Makes the whole Object smoothly change all three of its RGB components.
+     *
      * @param blend  1-dimensional Data that returns the level of blend a given pixel will be
      *               mixed with the next parameter 'color': pixel = (1-level)*pixel + level*color
      * @param color  Color to mix. (1,0,0) is RED.
      * @param region Region this Effect is limited to.
      *               Null here means 'apply the Effect to the whole Object'.
      * @param center Center of the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long chroma(Dynamic1D blend, Static3D color, Static4D region, Static2D center)
       public long chroma(Data1D blend, Static3D color)
+        {
         return mF.add(EffectNames.CHROMA, blend, color, region, center);
         return mF.add(EffectNames.CHROMA, blend, color);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * 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-t)*pixel + t*color
      * @param color  Color to mix. (1,0,0) is RED.
      * @param blendcolor  4-dimensional Data returning the 4-tuple (blend,R,G,B).
      *                    Level of blend a given pixel will be mixed with the next parameter 'color':
      *                    pixel = (1-t)*pixel + t*color
      * @param region Region this Effect is limited to.
      *               Null here means 'apply the Effect to the whole Object'.
      * @param center 2-dimensional Dynamic which, at any given time, returns a Static2D representing the
      *               current center of the effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long chroma(float blend, Static3D color, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.CHROMA, blend, color, region, center);
+        }
     ///// //////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param blend  Level of blend a given pixel will be mixed with the next parameter 'color':
      *               pixel = (1-t)*pixel + t*color
      * @param color  Color to mix. (1,0,0) is RED.
      * @param region The Region this Effect is limited to.
      *               Null here means 'apply the Effect to the whole Object'.
      * @param center Center of the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long chroma(float blend, Static3D color, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.CHROMA, blend, color, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
      * <p>
      * Here the Effect applies to the whole Object.
+     *
      * @param blend Level of blend a given pixel will be mixed with the next parameter 'color':
      *              pixel = (1-t)*pixel + t*color
      * @param color Color to mix. (1,0,0) is RED.
      * @return      ID of the effect added, or -1 if we failed to add one.
      */
       public long chroma(float blend, Static3D color)
+        {
         return mF.add(EffectNames.CHROMA, blend, color, null, mZero2D);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * See {@link #chroma(Dynamic1D, Static3D, Static4D, Dynamic2D)}
      * @param smooth If true, the level of 'blend' will smoothly fade out towards the edges of the region.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_chroma(Dynamic1D blend, Static3D color, Static4D region, Dynamic2D center)
       public long chroma(Data4D blendcolor, Data4D region, boolean smooth )
+        {
         return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, region, center);
         return mF.add( smooth? EffectNames.SMOOTH_CHROMA:EffectNames.CHROMA, blendcolor, region );
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * See {@link #chroma(Dynamic1D, Static3D, Static4D, Static2D)}
      */
       public long smooth_chroma(Dynamic1D blend, Static3D color, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * See {@link #chroma(float, Static3D, Static4D, Dynamic2D)}
      * Makes the whole Object smoothly change all three of its RGB components.
+     *
      * @param blendcolor  4-dimensional Data returning the 4-tuple (blend,R,G,B).
      *                    Level of blend a given pixel will be mixed with the next parameter 'color':
      *                    pixel = (1-t)*pixel + t*color
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_chroma(float blend, Static3D color, Static4D region, Dynamic2D center)
       public long chroma(Data4D blendcolor)
+        {
         return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, region, center);
         return mF.add(EffectNames.CHROMA, blendcolor);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * See {@link #chroma(float, Static3D, Static4D, Static2D)}
      */
       public long smooth_chroma(float blend, Static3D color, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * See {@link #chroma(float, Static3D)}
      */
       public long smooth_chroma(float blend, Static3D color)
+        {
         return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, null, mZero2D);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // ALPHA
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * @param alpha  1-dimensional Dynamic that returns the level of transparency we want to have at any given
      * @param alpha  1-dimensional Data that returns the level of transparency we want to have at any given
      *               moment.
      * @param region Region this Effect is limited to.
      *               Null here means 'apply the Effect to the whole Object'.
      * @param center 2-dimensional Dynamic which, at any given time, returns a Static2D representing the
      *               current center of the effect.
      * @param smooth If true, the level of 'alpha' will smoothly fade out towards the edges of the region.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long alpha(Dynamic1D alpha, Static4D region, Dynamic2D center)
       public long alpha(Data1D alpha, Data4D region, boolean smooth)
+        {
         return mF.add(EffectNames.ALPHA, alpha, region, center);
         return mF.add( smooth? EffectNames.SMOOTH_ALPHA:EffectNames.ALPHA, alpha, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param alpha  1-dimensional Dynamic that returns the level of transparency we want to have at any given
      *               moment.
      * @param region Region this Effect is limited to.
      *               Null here means 'apply the Effect to the whole Object'.
      * @param center Center of the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      * Makes the whole Object smoothly change its transparency level.
+     *
      * @param alpha  1-dimensional Data that returns the level of transparency we want to have at any
      *               given moment.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long alpha(Dynamic1D alpha, Static4D region, Static2D center)
       public long alpha(Data1D alpha)
+        {
         return mF.add(EffectNames.ALPHA, alpha, region, center);
         return mF.add(EffectNames.ALPHA, alpha);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
      * Makes a certain sub-region of the Object smoothly change its brightness level.
+     *
      * @param alpha  Level of Alpha (between 0 and 1) we want to interpolate to.
      * @param region Region this Effect is limited to.
      *               Null here means 'apply the Effect to the whole Object'.
      * @param center 2-dimensional Dynamic which, at any given time, returns a Static2D representing the
      *               current center of the effect.
      * @param duration Time, in milliseconds, it takes to do one full interpolation.
      * @param count  Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return       ID of the effect added, or -1 if we failed to add one.
      * @param brightness 1-dimensional Data that returns the level of brightness we want to have
      *                   at any given moment.
      * @param region     Region this Effect is limited to.
      * @param smooth     If true, the level of 'brightness' will smoothly fade out towards the edges of the region.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long alpha(float alpha, Static4D region, Dynamic2D center, int duration, float count)
       public long brightness(Data1D brightness, Data4D region, boolean smooth)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.ALPHA, di, region, center);
         return mF.add( smooth ? EffectNames.SMOOTH_BRIGHTNESS: EffectNames.BRIGHTNESS, brightness, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param alpha    Level of Alpha (between 0 and 1) we want to interpolate to.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   Center of the Effect.
      * @param duration Time, in milliseconds, it takes to do one full interpolation.
      * @param count    Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return         ID of the effect added, or -1 if we failed to add one.
      * Makes the whole Object smoothly change its brightness level.
+     *
      * @param brightness 1-dimensional Data that returns the level of brightness we want to have
      *                   at any given moment.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long alpha(float alpha, Static4D region, Static2D center, int duration, float count)
       public long brightness(Data1D brightness)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.ALPHA, di, region, center);
         return mF.add(EffectNames.BRIGHTNESS, brightness);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
      * <p>
      * Here the center of the Effect stays constant and the effect for now change in time.
+     *
      * @param alpha  Level of Alpha (between 0 and 1) we want to interpolate to.
      * @param region Region this Effect is limited to.
      *               Null here means 'apply the Effect to the whole Object'.
      * @param center Center of the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long alpha(float alpha, Static4D region, Static2D center)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.ALPHA, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Object change its transparency level.
+     *
      * @param alpha    Level of Alpha (between 0 and 1) we want to interpolate to.
      * @param duration Time, in milliseconds, it takes to do one full interpolation.
      * @param count    Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long alpha(float alpha, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.ALPHA, di,null, mZero2D);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * See {@link #alpha(Dynamic1D, Static4D, Dynamic2D)}
      * Makes a certain sub-region of the Object smoothly change its contrast level.
+     *
      * @param contrast 1-dimensional Data that returns the level of contrast we want to have
      *                 at any given moment.
      * @param region   Region this Effect is limited to.
      * @param smooth   If true, the level of 'contrast' will smoothly fade out towards the edges of the region.
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_alpha(Dynamic1D alpha, Static4D region, Dynamic2D center)
       public long contrast(Data1D contrast, Data4D region, boolean smooth)
+        {
         return mF.add(EffectNames.SMOOTH_ALPHA, alpha, region, center);
         return mF.add( smooth ? EffectNames.SMOOTH_CONTRAST:EffectNames.CONTRAST, contrast, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * See {@link #alpha(Dynamic1D, Static4D, Static2D)}
      */
       public long smooth_alpha(Dynamic1D alpha, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.SMOOTH_ALPHA, alpha, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * See {@link #alpha(float, Static4D, Dynamic2D, int, float)}
      * Makes the whole Object smoothly change its contrast level.
+     *
      * @param contrast 1-dimensional Data that returns the level of contrast we want to have
      *                 at any given moment.
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_alpha(float alpha, Static4D region, Dynamic2D center, int duration, float count)
       public long contrast(Data1D contrast)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.SMOOTH_ALPHA, di, region, center);
         return mF.add(EffectNames.CONTRAST, contrast);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * See {@link #alpha(float, Static4D, Static2D, int, float)}
      * Makes a certain sub-region of the Object smoothly change its saturation level.
+     *
      * @param saturation 1-dimensional Data that returns the level of saturation we want to have
      *                   at any given moment.
      * @param region     Region this Effect is limited to.
      * @param smooth     If true, the level of 'saturation' will smoothly fade out towards the edges of the region.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_alpha(float alpha, Static4D region, Static2D center, int duration, float count)
       public long saturation(Data1D saturation, Data4D region, boolean smooth)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.SMOOTH_ALPHA, di, region, center);
         return mF.add( smooth ? EffectNames.SMOOTH_SATURATION:EffectNames.SATURATION, saturation, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * See {@link #alpha(float, Static4D, Static2D)}
      * Makes the whole Object smoothly change its saturation level.
+     *
      * @param saturation 1-dimensional Data that returns the level of saturation we want to have
      *                   at any given moment.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_alpha(float alpha, Static4D region, Static2D center)
       public long saturation(Data1D saturation)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.SMOOTH_ALPHA, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // BRIGHTNESS
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
+     *
      * @param brightness 1-dimensional Dynamic that returns the level of brightness we want to have
      *                   at any given moment.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     2-dimensional Dynamic which, at any given time, returns a Static2D representing
      *                   the current center of the effect.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long brightness(Dynamic1D brightness, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.BRIGHTNESS, brightness, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param brightness 1-dimensional Dynamic that returns the level of brightness we want to have
      *                   at any given moment.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     Center of the Effect.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long brightness(Dynamic1D brightness, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.BRIGHTNESS, brightness, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
+     *
      * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
      *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
      *                   anything more than 1- lighten it up.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     2-dimensional Dynamic which, at any given time, returns a Static2D
      *                   representing the current center of the effect.
      * @param duration   Time, in milliseconds, it takes to do one full interpolation.
      * @param count      Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long brightness(float brightness, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.BRIGHTNESS, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
      *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
      *                   anything more than 1 - lighten it up.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     Center of the Effect.
      * @param duration   Time, in milliseconds, it takes to do one full interpolation.
      * @param count      Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long brightness(float brightness, Static4D region, Static2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.BRIGHTNESS, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
      * <p>
      * Here the center of the Effect stays constant and the effect for now change in time.
+     *
      * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
      *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
      *                   anything more than 1 - lighten it up.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     Center of the Effect.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long brightness(float brightness, Static4D region, Static2D center)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.BRIGHTNESS, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // SMOOTH BRIGHTNESS
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
+     *
      * @param brightness 1-dimensional Dynamic that returns the level of brightness we want to have
      *                   at any given moment.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     2-dimensional Dynamic which, at any given time, returns a Static2D
      *                   representing the current center of the effect.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_brightness(Dynamic1D brightness, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, brightness, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param brightness 1-dimensional Dynamic that returns the level of brightness we want to have
      *                   at any given moment.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     Center of the Effect.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_brightness(Dynamic1D brightness, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, brightness, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
+     *
      * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
      *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
      *                   anything more than 1 - lighten it up.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     2-dimensional Dynamic which, at any given time, returns a Static2D
      *                   represention the current center of the effect.
      * @param duration   Time, in milliseconds, it takes to do one full interpolation.
      * @param count      Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_brightness(float brightness, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
      *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
      *                   anything more than 1 - lighten it up.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     Center of the Effect.
      * @param duration   Time, in milliseconds, it takes to do one full interpolation.
      * @param count      Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_brightness(float brightness, Static4D region, Static2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
      * <p>
      * Here the center of the Effect stays constant and the effect for now change in time.
+     *
      * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
      *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
      *                   anything more than 1 - lighten it up.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     Center of the Effect.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_brightness(float brightness, Static4D region, Static2D center)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Object change its brightness level.
+     *
      * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
      *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
      *                   anything more than 1- lighten it up.
      * @param duration   Time, in milliseconds, it takes to do one full interpolation.
      * @param count      Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_brightness(float brightness, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di,null, mZero2D);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // CONTRAST
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
+     *
      * @param contrast 1-dimensional Dynamic that returns the level of contrast we want to have
      *                 at any given moment.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   2-dimensional Dynamic which, at any given time, returns a Static2D
      *                 representing the current center of the effect.
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long contrast(Dynamic1D contrast, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.CONTRAST, contrast, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param contrast 1-dimensional Dynamic that returns the level of contrast we want to have
      *                 at any given moment.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center  Center of the Effect.
      * @return        ID of the effect added, or -1 if we failed to add one.
      */
       public long contrast(Dynamic1D contrast, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.CONTRAST, contrast, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
+     *
      * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
      *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
      *                 anything more than 1 - increase the contrast.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   2-dimensional Dynamic which, at any given time, returns a Static2D
      *                 represention the current center of the effect.
      * @param duration Time, in milliseconds, it takes to do one full interpolation.
      * @param count    Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long contrast(float contrast, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.CONTRAST, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
      *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
      *                 anything more than 1 -increase the contrast.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   Center of the Effect.
      * @param duration Time, in milliseconds, it takes to do one full interpolation.
      * @param count    Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long contrast(float contrast, Static4D region, Static2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.CONTRAST, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
      * <p>
      * Here the center of the Effect stays constant and the effect for now change in time.
+     *
      * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
      *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
      *                 anything more than 1 - increase the contrast.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   Center of the Effect.
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long contrast(float contrast, Static4D region, Static2D center)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.CONTRAST, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // SMOOTH CONTRAST
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
+     *
      * @param contrast 1-dimensional Dynamic that returns the level of contrast we want to have
      *                 at any given moment.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   2-dimensional Dynamic which, at any given time, returns a Static2D
      *                 representing the current center of the effect.
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_contrast(Dynamic1D contrast, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.SMOOTH_CONTRAST, contrast, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param contrast 1-dimensional Dynamic that returns the level of contrast we want to have
      *                 at any given moment.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   Center of the Effect.
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_contrast(Dynamic1D contrast, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.SMOOTH_CONTRAST, contrast, region, center);
         return mF.add(EffectNames.SATURATION, saturation);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
+     *
      * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
      *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
      *                 anything more than 1 - increase the contrast.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   2-dimensional Dynamic which, at any given time, returns a Static2D
      *                 representing the current center of the effect.
      * @param duration Time, in milliseconds, it takes to do one full interpolation.
      * @param count    Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_contrast(float contrast, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
      *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
      *                 anything more than 1 - increase the contrast.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   Center of the Effect.
      * @param duration Time, in milliseconds, it takes to do one full interpolation.
      * @param count    Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_contrast(float contrast, Static4D region, Static2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
      * <p>
      * Here the center of the Effect stays constant and the effect for now change in time.
+     *
      * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
      *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
      *                 anything more than 1 - increase the contrast.
      * @param region   Region this Effect is limited to.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   Center of the Effect.
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_contrast(float contrast, Static4D region, Static2D center)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Object change its contrast level.
+     *
      * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
      *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
      *                 anything more than 1 - increase the contrast.
      * @param duration Time, in milliseconds, it takes to do one full interpolation.
      * @param count    Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_contrast(float contrast, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.SMOOTH_CONTRAST, di,null, mZero2D);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // SATURATION
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
+     *
      * @param saturation 1-dimensional Dynamic that returns the level of saturation we want to have
      *                   at any given moment.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     2-dimensional Dynamic which, at any given time, returns a Static2D
      *                   representing the current center of the effect.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long saturation(Dynamic1D saturation, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.SATURATION, saturation, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param saturation 1-dimensional Dynamic that returns the level of saturation we want to have
      *                   at any given moment.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     Center of the Effect.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long saturation(Dynamic1D saturation, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.SATURATION, saturation, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
+     *
      * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
      *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
      *                   anything more than 1 - increase the saturation.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     2-dimensional Dynamic which, at any given time, returns a Static2D
      *                   representing the current center of the effect.
      * @param duration   Time, in milliseconds, it takes to do one full interpolation.
      * @param count      Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long saturation(float saturation, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(saturation));
         return mF.add(EffectNames.SATURATION, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
      *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
      *                   anything more than 1 - increase the saturation.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     Center of the Effect.
      * @param duration   Time, in milliseconds, it takes to do one full interpolation.
      * @param count      Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long saturation(float saturation, Static4D region, Static2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(saturation));
         return mF.add(EffectNames.SATURATION, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
      * <p>
      * Here the center of the Effect stays constant and the effect for now change in time.
+     *
      * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
      *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
      *                   anything more than 1- increase the saturation.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     Center of the Effect.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long saturation(float saturation, Static4D region, Static2D center)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Static1D(1));
         di.add(new Static1D(saturation));
         return mF.add(EffectNames.SATURATION, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // SMOOTH_SATURATION
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
+     *
      * @param saturation 1-dimensional Dynamic that returns the level of saturation we want to have
      *                   at any given moment.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     2-dimensional Dynamic which, at any given time, returns a Static2D
      *                   representing the current center of the effect.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_saturation(Dynamic1D saturation, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.SMOOTH_SATURATION, saturation, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param saturation 1-dimensional Dynamic that returns the level of saturation we want to have
      *                   at any given moment.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     Center of the Effect.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_saturation(Dynamic1D saturation, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.SMOOTH_SATURATION, saturation, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
+     *
      * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
      *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
      *                   anything more than 1 -increase the saturation.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     2-dimensional Dynamic which, at any given time, returns a Static2D
      *                   representing the current center of the effect.
      * @param duration   Time, in milliseconds, it takes to do one full interpolation.
      * @param count      Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_saturation(float saturation, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(saturation));
         return mF.add(EffectNames.SMOOTH_SATURATION, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
      *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
      *                   anything more than 1 - increase the saturation.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     Center of the Effect.
      * @param duration   Time, in milliseconds, it takes to do one full interpolation.
      * @param count      Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_saturation(float saturation, Static4D region, Static2D center, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(saturation));
         return mF.add(EffectNames.SMOOTH_SATURATION, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
      * <p>
      * Here the center of the Effect stays constant and the effect for now change in time.
+     *
      * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
      *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
      *                   anything more than 1 - increase the saturation.
      * @param region     Region this Effect is limited to.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     Center of the Effect.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_saturation(float saturation, Static4D region, Static2D center)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Static1D(1));
         di.add(new Static1D(saturation));
         return mF.add(EffectNames.SMOOTH_SATURATION, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Object change its saturation level.
+     *
      * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
      *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
      *                   anything more than 1 - increase the saturation.
      * @param duration   Time, in milliseconds, it takes to do one full interpolation.
      * @param count      Controls how many interpolations we want to do. See {@link Dynamic#setCount(float)}
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long smooth_saturation(float saturation, int duration, float count)
+        {
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Static1D(1));
         di.add(new Static1D(saturation));
         return mF.add(EffectNames.SMOOTH_SATURATION, di,null, mZero2D);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Vertex-based effects
     ///////////////////////////////////////////////////////////////////////////////////////////////////

           mType            = new int[mMax[mMaxIndex]];
           mUniforms        = new float[numUniforms*mMax[mMaxIndex]];
           mInterI          = new Dynamic[mMax[mMaxIndex]];
           mInterP          = new Dynamic2D[mMax[mMaxIndex]];
           mInterP          = new Dynamic[mMax[mMaxIndex]];
           mCurrentDuration = new long[mMax[mMaxIndex]];
           mID              = new long[mMax[mMaxIndex]];
           mIDIndex         = new byte[mMax[mMaxIndex]];

     import android.opengl.GLES20;
     import org.distorted.library.message.EffectMessage;
     import org.distorted.library.type.Data1D;
     import org.distorted.library.type.Data4D;
     import org.distorted.library.type.Dynamic1D;
     import org.distorted.library.type.Dynamic4D;
     import org.distorted.library.type.Static1D;
     import org.distorted.library.type.Static2D;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Static4D;
-...
     class EffectQueueFragment extends EffectQueue
+      {
       private static final int NUM_UNIFORMS = 9;
       private static final int NUM_UNIFORMS = 8;
       private static final int INDEX = EffectTypes.FRAGMENT.ordinal();
       private float[] mBuf;
       private static int mNumEffectsH;
-...
         if( mNumEffects>0 )
+          {
           GLES20.glUniform1iv( mTypeH    ,  mNumEffects, mType    ,0);
           GLES20.glUniform3fv( mUniformsH,3*mNumEffects, mUniforms,0);
           GLES20.glUniform4fv( mUniformsH,2*mNumEffects, mUniforms,0);
+          }
+        }
-...
+            {
             tx = mBuf[4*i  ]-mObjHalfX; // we have to invert y and move everything by (half of bmp width, half of bmp height)
             ty =-mBuf[4*i+1]+mObjHalfY; //
             mUniforms[NUM_UNIFORMS*i+4] = w*mBuf[4*i+2];                                  // in fragment shader rx and ry radii are the second and third values of the Region thus 9*i+4 and 9*i+5
             mUniforms[NUM_UNIFORMS*i+5] = h*mBuf[4*i+3];                                  //
          // mUniforms[NUM_UNIFORMS*i+6] =                                                 // this value is not used in Fragment Shader
             mUniforms[NUM_UNIFORMS*i+7] = MVmatrix[0]*tx + MVmatrix[4]*ty + MVmatrix[12]; // multiply the ModelView matrix times the (x,y,0,1) point, i.e. the (x,y) point on the surface of the bitmap.
             mUniforms[NUM_UNIFORMS*i+8] = MVmatrix[1]*tx + MVmatrix[5]*ty + MVmatrix[13]; //
             mUniforms[NUM_UNIFORMS*i+4] = MVmatrix[0]*tx + MVmatrix[4]*ty + MVmatrix[12]; // multiply the ModelView matrix times the (x,y,0,1) point, i.e. the (x,y) point on the surface of the bitmap.
             mUniforms[NUM_UNIFORMS*i+5] = MVmatrix[1]*tx + MVmatrix[5]*ty + MVmatrix[13]; //
             mUniforms[NUM_UNIFORMS*i+6] = w*mBuf[4*i+2];                                  // in fragment shader rx and ry radii are the last two values of the second vec4
             mUniforms[NUM_UNIFORMS*i+7] = h*mBuf[4*i+3];                                  //
             if( mType[i]==EffectNames.MACROBLOCK.ordinal() ) // fill up the .y and .z components of the Interpolated values already to avoid having to compute this in the fragment shader
+              {
               mUniforms[NUM_UNIFORMS*i+1] = 2.0f*mObjHalfX/mUniforms[NUM_UNIFORMS*i];
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       synchronized long add(EffectNames eln, Dynamic inter, Static4D region, Dynamic2D point)
     // macroblock, alpha, brightness, contrast, saturation
       synchronized long add(EffectNames eln, Data1D data)
+        {
         if( mMax[INDEX]>mNumEffects )
+          {
           EffectNames.fillWithUnities(eln.ordinal(), mUniforms, NUM_UNIFORMS*mNumEffects);
           mInterI[mNumEffects] = inter;
           mInterP[mNumEffects] = point;
           if( region==null )
           if( data instanceof Dynamic1D)
             mInterI[mNumEffects] = (Dynamic1D)data;
           else if( data instanceof Static1D )
+            {
             mBuf[4*mNumEffects+2] = 1000*mObjHalfX;
             mBuf[4*mNumEffects+3] = 1000*mObjHalfY;
             mInterI[mNumEffects] = null;
             mUniforms[NUM_UNIFORMS*mNumEffects] = ((Static1D)data).getX();
+            }
           else
+            {
             float z = region.getZ();
             float w = region.getW();
           else return -1;
             mBuf[4*mNumEffects+2] = z<=0.0f ? 1000*mObjHalfX : z;
             mBuf[4*mNumEffects+3] = w<=0.0f ? 1000*mObjHalfY : w;
+            }
           mInterP[mNumEffects] = null;
           mBuf[4*mNumEffects+2] = 1000*mObjHalfX;
           mBuf[4*mNumEffects+3] = 1000*mObjHalfY;
           return addBase(eln);
+          }
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // macroblock, alpha, brightness, contrast, saturation
       synchronized long add(EffectNames eln, Dynamic inter, Static4D region, Static2D point)
       synchronized long add(EffectNames eln, Data1D data, Data4D region)
+        {
         if( mMax[INDEX]>mNumEffects )
+          {
           EffectNames.fillWithUnities(eln.ordinal(), mUniforms, NUM_UNIFORMS*mNumEffects);
           mInterI[mNumEffects] = inter;
           mInterP[mNumEffects] = null;
           mBuf[4*mNumEffects  ] = point.getX();
           mBuf[4*mNumEffects+1] = point.getY();
           EffectNames.fillWithUnities(eln.ordinal(), mUniforms, NUM_UNIFORMS*mNumEffects);
           if( region==null )
           if( data instanceof Dynamic1D)
             mInterI[mNumEffects] = (Dynamic1D)data;
           else if( data instanceof Static1D )
+            {
             mBuf[4*mNumEffects+2] = 1000*mObjHalfX;
             mBuf[4*mNumEffects+3] = 1000*mObjHalfY;
             mInterI[mNumEffects] = null;

... 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 2fce34f4

Added by Leszek Koltunski over 9 years ago