/src/main/java/org/distorted/library/DistortedObject.java - Diff - Distorted Android

« Previous | Next »

Revision 2fce34f4

Added by Leszek Koltunski almost 8 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
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision 2fce34f4

Added by Leszek Koltunski almost 8 years ago