/ - Diff - Distorted Android

« Previous | Next »

Revision 568b29d8

Added by Leszek Koltunski over 9 years ago

ID 568b29d8ff88078479ee5a1db1b2e91dc4e9113e
Parent cdd6333d
Child 2fce34f4

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

     import android.opengl.GLUtils;
     import org.distorted.library.message.EffectListener;
     import org.distorted.library.type.Float1D;
     import org.distorted.library.type.Float2D;
     import org.distorted.library.type.Float3D;
     import org.distorted.library.type.Float4D;
     import org.distorted.library.type.Interpolator;
     import org.distorted.library.type.Interpolator1D;
     import org.distorted.library.type.Interpolator2D;
     import org.distorted.library.type.Interpolator3D;
     import org.distorted.library.type.Interpolator4D;
     import org.distorted.library.type.InterpolatorQuat;
     import org.distorted.library.type.Data1D;
     import org.distorted.library.type.Data3D;
     import org.distorted.library.type.Data4D;
     import org.distorted.library.type.Dynamic;
     import org.distorted.library.type.Dynamic1D;
     import org.distorted.library.type.Dynamic2D;
     import org.distorted.library.type.Dynamic3D;
     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;
     import org.distorted.library.type.DynamicQuat;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
-...
      */
     public abstract class DistortedObject
+    {
         private static final Float2D mZero2D = new Float2D(0,0);
         private static final Float3D mZero3D = new Float3D(0,0,0);
         private static final Static2D mZero2D = new Static2D(0,0);
         private static final Static3D mZero3D = new Static3D(0,0,0);
         private static float[] mViewMatrix   = new float[16];
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Matrix-based effects
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // MOVE
     /**
      * Moves the Object by a vector that changes in time as interpolated by the Interpolator.
      * Moves the Object by a vector that changes in time as interpolated by the Dynamic.
+     *
      * @param vector 3-dimensional Interpolator which at any given time will return a Float3D
      * @param vector 3-dimensional Data which at any given time will return a Static3D
      *               representing the current coordinates of the vector we want to move the Object with.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long move(Interpolator3D vector)
       public long move(Data3D vector)
+        {
         return mM.add(EffectNames.MOVE,vector);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Moves the Object by a vector that smoothly changes from (0,0,0) to (x,y,z).
+     *
      * @param x        The x-coordinate of the vector we want to move the Object with.
      * @param y        The y-coordinate of the vector we want to move the Object with.
      * @param z        The z-coordinate of the vector we want to move the Object with.
      * @param duration The time, in milliseconds, it takes to complete the movement.
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long move(float x,float y,float z, int duration)
+        {
         Interpolator3D di = new Interpolator3D();
         di.setCount(0.5f);
         di.setDuration(duration);
         di.add(new Float3D(0.0f,0.0f,0.0f));
         di.add(new Float3D(x,y,z));
         return mM.add(EffectNames.MOVE,di);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Moves the Object by vector (x,y,z) immediately.
+     *
      * @param x The x-coordinate of the vector we want to move the Object with.
      * @param y The y-coordinate of the vector we want to move the Object with.
      * @param z The z-coordinate of the vector we want to move the Object with.
      * @return  ID of the effect added, or -1 if we failed to add one.
      */
       public long move(float x,float y,float z)
+        {
         return mM.add(EffectNames.MOVE,mZero3D,x,y,z,0.0f);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // SCALE
     /**
      * Scales the Object by factors that change in time as returned by the Interpolator.
      * Scales the Object by factors that change in time as returned by the Dynamic.
+     *
      * @param scale 3-dimensional Interpolator which at any given time returns a Float3D
      * @param scale 3-dimensional Dynamic which at any given time returns a Static3D
      *              representing the current x- , y- and z- scale factors.
      * @return      ID of the effect added, or -1 if we failed to add one.
      */
       public long scale(Interpolator3D scale)
       public long scale(Data3D scale)
+        {
         return mM.add(EffectNames.SCALE,scale);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Scales the Object by a factor that smoothly changes from (1,1,1) at time 0 to (xscale,yscale,zscale)
      * after 'duration' milliseconds.
+     *
      * @param xscale   After time 'duration' passes, Object's width will get multiplied by xscale; e.g. if
      *                 xscale=2, after 'duration' milliseconds the Object will become twice broader.
      * @param yscale   Factor to scale Object's height with.
      * @param zscale   Factor to scale Object's depth with.
      * @param duration Time, in milliseconds, it takes to interpolate to the full (xscale,yscale,zscale) scaling factors.
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long scale(float xscale,float yscale,float zscale, int duration)
+        {
         Interpolator3D di = new Interpolator3D();
         di.setCount(0.5f);
         di.setDuration(duration);
         di.add(new Float3D(1.0f,1.0f,1.0f));
         di.add(new Float3D(xscale,yscale,zscale));
         return mM.add(EffectNames.SCALE,di);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Immediately scales the Object's width by (xscale,yscale,zscale).
+     *
      * @param xscale Object's width gets multiplied by this factor; e.g. if
      *               xscale=2, the Object immediately becomes twice broader.
      * @param yscale factor to scale Object's height with.
      * @param zscale factor to scale Object's depth with.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long scale(float xscale,float yscale,float zscale)
+        {
         return mM.add(EffectNames.SCALE,mZero3D,xscale,yscale,zscale,0.0f);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Convenience function - scale the Object by the same factor in all 3 dimensions.
+     *
      * @param scale all 3 Object's dimensions get multiplied by this factor; e.g. if
      *              scale=2, the Object immediately becomes twice larger.
      * @return      ID of the effect added, or -1 if we failed to add one.
      */
       public long scale(float scale)
+        {
         return mM.add(EffectNames.SCALE,mZero3D,scale,scale,scale,0.0f);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // ROTATE
     /**
      * Rotates the Object around a (possibly moving) point, with angle and axis that change in time.
+     *
      * @param center    3-dimensional Interpolator which at any given time will return the current center
      *                  of the rotation
      * @param angleAxis 4-dimensional Interpolator which at any given time will return a Float4D
      *                  representing the current rotation in the (angle,axisX,axisY,axisY) form.
      * @return          ID of the effect added, or -1 if we failed to add one.
      */
       public long rotate(Interpolator3D center, Interpolator4D angleAxis)
+        {
         return mM.add(EffectNames.ROTATE, center, angleAxis);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object around a static point, with angle and axis that change in time.
+     *
      * @param center    Center of the rotation
      * @param angleAxis 4-dimensional Interpolator which at any given time will return a Float4D
      *                  representing the current rotation in the (angle,axisX,axisY,axisY) form.
      * @return          ID of the effect added, or -1 if we failed to add one.
      */
       public long rotate(Float3D center, Interpolator4D angleAxis)
+        {
         return mM.add(EffectNames.ROTATE, center , angleAxis);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object around a static point, with angle that changes in time, around axis
      * (axisX, axisY, axisZ).
+     *
      * @param center Center of the rotation
      * @param angle  1-dimensional Interpolator which at any given time will return the current rotation
      *               angle.
      * @param axisX  Rotation vector: x-coordinate
      * @param axisY  Rotation vector: y-coordinate
      * @param axisZ  Rotation vector: z-coordinate
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long rotate(Float3D center, Interpolator1D angle, float axisX, float axisY, float axisZ)
+        {
         return mM.add(EffectNames.ROTATE, center , angle, axisX, axisY, axisZ);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object around a (possibly moving) point, with angle that changes in time.
      * Axis of rotation is the vector (0,0,1), i.e. a vector normal to the screen surface.
+     *
      * @param center 3-dimensional Interpolator which at any given time will return the current center
      *               of the rotation.
      * @param angle  1-dimensional Interpolator which returns the current rotation angle.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long rotate(Interpolator3D center, Interpolator1D angle)
+        {
         return mM.add(EffectNames.ROTATE, center, angle, 0.0f,0.0f,1.0f);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object around a constant point, with angle that changes in time.
      * Axis of rotation is the vector (0,0,1), i.e. a vector normal to the screen surface.
+     *
      * @param center   Coordinates of the Point we are rotating around.
      * @param angle    Angle that we want to rotate the Object to. Unit: degrees
      * @param duration Time, in milliseconds, it takes to complete one rotation from 0 to 'angle' degrees.
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long rotate(Float3D center, int angle, int duration)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(0.5f);
         di.setDuration(duration);
         di.add(new Float1D(    0));
         di.add(new Float1D(angle));
         return mM.add(EffectNames.ROTATE, center, di, 0.0f,0.0f,1.0f);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object immediately by 'angle' degrees around point p.
      * Axis of rotation is given by the last 3 floats.
+     *
      * Rotates the Object by 'angle' degrees around the center.
      * Static axis of rotation is given by the last parameter.
+     *
      * @param center Coordinates of the Point we are rotating around.
      * @param angle  Angle that we want to rotate the Object to. Unit: degrees
      * @param axisX  Axis of rotation: x-coordinate
      * @param axisY  Axis of rotation: y-coordinate
      * @param axisZ  Axis of rotation: z-coordinate
      * @param axis   Axis of rotation
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long rotate(Float3D center, float angle, float axisX, float axisY, float axisZ)
+        {
         return mM.add(EffectNames.ROTATE, center, angle, axisX, axisY, axisZ);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object immediately by 'angle' degrees around point p.
+     *
      * @param center Coordinates of the Point we are rotating around.
      * @param angle  The angle that we want to rotate the Object to. Unit: degrees
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long rotate(Float3D center, int angle)
       public long rotate(Data3D center, Data1D angle, Static3D axis)
+        {
         return mM.add(EffectNames.ROTATE, center, angle,0.0f,0.0f,1.0f);
         return mM.add(EffectNames.ROTATE, center, angle, axis);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // QUATERNION
     /**
      * Rotates the Object immediately by quaternion (qX,qY,qZ,qW).
+     *
      * @param center Coordinates of the Point we are rotating around.
      * @param qX     Quaternion: x-coordinate
      * @param qY     Quaternion: y-coordinate
      * @param qZ     Quaternion: z-coordinate
      * @param qW     Quaternion: w-coordinate
      * @return       ID of the effect added, or -1 if we failed to add one.
      * Rotates the Object by 'angle' degrees around the center.
      * Static axis of rotation is given by the last parameter.
+     *
      * @param center    Coordinates of the Point we are rotating around.
      * @param angleaxis Combined 4-tuple representing the (angle,axisX,axisY,axisZ).
      * @return          ID of the effect added, or -1 if we failed to add one.
      */
       public long quaternion(Float3D center, float qX, float qY, float qZ, float qW)
+        {
         return mM.add(EffectNames.QUATERNION,center,qX,qY,qZ,qW);
       public long rotate(Data3D center, Data4D angleaxis)
+        {
         return mM.add(EffectNames.ROTATE, center, angleaxis);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object by a quaternion that's at the moment returned by the InterpolatorQuat.
      * Rotates the Object by quaternion.
+     *
      * @param center Coordinates of the Point we are rotating around.
      * @param quat   Interpolator that's going to, at any given moment, return a quaternion.
      * @return       ID of the effect added, or -1 if we failed to add one.
      * @param center     Coordinates of the Point we are rotating around.
      * @param quaternion The quaternion describing the rotation.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long quaternion(Float3D center, InterpolatorQuat quat)
+        {
         return mM.add(EffectNames.QUATERNION, center, quat);
       public long quaternion(Data3D center, Data4D quaternion)
+        {
         return mM.add(EffectNames.QUATERNION,center,quaternion);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object around a moving point by a quaternion that's at the moment returned by the InterpolatorQuat.
+     *
      * @param center Interpolator that returns the current center of rotation.
      * @param quat   Interpolator that's going to, at any given moment, return a quaternion representing
      *               the current rotation.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long quaternion(Interpolator3D center, InterpolatorQuat quat)
+        {
         return mM.add(EffectNames.QUATERNION,center,quat);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // SHEAR
     /**
      * Shears the Object. If the Interpolator is 1D, it will shear along the X-axis. 2D Interpolator adds
      * shearing along the Y-axis, 3D one along Z axis.
      * Shears the Object.
+     *
      * @param center  Center of shearing, i.e. the point which stays unmoved.
      * @param shear   1- 2- or 3D Interpolator which, at any given point, returns the ordered 1-, 2-
      *                or 3-tuple of shear factors.
      * @param shear   The 3-tuple of shear factors.
      * @return        ID of the effect added, or -1 if we failed to add one.
      */
       public long shear(Float3D center, Interpolator shear)
       public long shear(Data3D center, Data3D shear)
+        {
         return mM.add(EffectNames.SHEAR, center, shear);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Shears the Object in 3D. Order: first X shearing, then Y, then Z.
+     *
      * @param center Center of shearing, i.e. the point which stays unmoved.
      * @param shear  ordered 3-tuple (x-degree, y-degree, z-degree) of shearing (tangent of the angle with
      *               which the X,Y and Z axis get slanted)
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long shear(Float3D center, Float3D shear)
+        {
         Interpolator3D di = new Interpolator3D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Float3D(0.0f,0.0f,0.0f));
         di.add(shear);
         return mM.add(EffectNames.SHEAR, center, di );
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Fragment-based effects
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // MACROBLOCK
     /**
      * Creates macroblocks at and around point defined by the Interpolator2D and the Region.
      * Size of the macroblocks at any given time is returned by the Interpolator1D.
      * 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.
+     *
      * @param size   1-dimensional Interpolator which, at any given time, returns the size of the macroblocks.
      * @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 Interpolator which, at any given time, returns a Float2D representing the
      * @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(Interpolator1D size, Float4D region, Interpolator2D center)
       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 Interpolator1D.
      * 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 Interpolator which, at any given time, returns the size of the macroblocks.
      * @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(Interpolator1D size, Float4D region, Float2D center)
       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 Interpolator2D and the Region.
      * 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
-...
      * @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 Interpolator which, at any given time, returns a Float2D representing the
      * @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 Interpolator#setCount(float)}
      * @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, Float4D region, Interpolator2D center, int duration, float count)
       public long macroblock(int pixels, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(pixels));
         di.add(new Static1D(1));
         di.add(new Static1D(pixels));
         return mF.add(EffectNames.MACROBLOCK, di, region, center);
+        }
-...
      *                 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 Interpolator#setCount(float)}
      * @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, Float4D region, Float2D center, int duration, float count)
       public long macroblock(int pixels, Static4D region, Static2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(pixels));
         di.add(new Static1D(1));
         di.add(new Static1D(pixels));
         return mF.add(EffectNames.MACROBLOCK, di, region, center);
+        }
-...
+     *
      * @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 Interpolator#setCount(float)}
      * @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, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(pixels));
         di.add(new Static1D(1));
         di.add(new Static1D(pixels));
         return mF.add(EffectNames.MACROBLOCK, di, null, mZero2D);
+        }
-...
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * @param blend  1-dimensional Interpolator that returns the level of blend a given pixel will be
      * @param blend  1-dimensional Dynamic 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 Interpolator which, at any given time, returns a Float2D representing
      * @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(Interpolator1D blend, Float3D color, Float4D region, Interpolator2D center)
       public long chroma(Dynamic1D blend, Static3D color, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.CHROMA, blend, color, region, center);
+        }
-...
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param blend  1-dimensional Interpolator that returns the level of blend a given pixel will be
      * @param blend  1-dimensional Dynamic 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.
-...
      * @param center Center of the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long chroma(Interpolator1D blend, Float3D color, Float4D region, Float2D center)
       public long chroma(Dynamic1D blend, Static3D color, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.CHROMA, blend, color, region, center);
+        }
-...
      * @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 Interpolator which, at any given time, returns a Float2D representing the
      * @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, Float3D color, Float4D region, Interpolator2D center)
       public long chroma(float blend, Static3D color, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.CHROMA, blend, color, region, center);
+        }
-...
      * @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, Float3D color, Float4D region, Float2D center)
       public long chroma(float blend, Static3D color, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.CHROMA, blend, color, region, center);
+        }
-...
      * @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, Float3D color)
       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(Interpolator1D, Float3D, Float4D, Interpolator2D)}
      * See {@link #chroma(Dynamic1D, Static3D, Static4D, Dynamic2D)}
      */
       public long smooth_chroma(Interpolator1D blend, Float3D color, Float4D region, Interpolator2D center)
       public long smooth_chroma(Dynamic1D blend, Static3D color, Static4D region, Dynamic2D 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(Interpolator1D, Float3D, Float4D, Float2D)}
      * See {@link #chroma(Dynamic1D, Static3D, Static4D, Static2D)}
      */
       public long smooth_chroma(Interpolator1D blend, Float3D color, Float4D region, Float2D center)
       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, Float3D, Float4D, Interpolator2D)}
      * See {@link #chroma(float, Static3D, Static4D, Dynamic2D)}
      */
       public long smooth_chroma(float blend, Float3D color, Float4D region, Interpolator2D center)
       public long smooth_chroma(float blend, Static3D color, Static4D region, Dynamic2D 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, Float3D, Float4D, Float2D)}
      * See {@link #chroma(float, Static3D, Static4D, Static2D)}
      */
       public long smooth_chroma(float blend, Float3D color, Float4D region, Float2D center)
       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, Float3D)}
      * See {@link #chroma(float, Static3D)}
      */
       public long smooth_chroma(float blend, Float3D color)
       public long smooth_chroma(float blend, Static3D color)
+        {
         return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, null, mZero2D);
+        }
-...
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * @param alpha  1-dimensional Interpolator that returns the level of transparency we want to have at any given
      * @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 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
      * @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 alpha(Interpolator1D alpha, Float4D region, Interpolator2D center)
       public long alpha(Dynamic1D alpha, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.ALPHA, alpha, region, center);
+        }
-...
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param alpha  1-dimensional Interpolator that returns the level of transparency we want to have at any given
      * @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.
      */
       public long alpha(Interpolator1D alpha, Float4D region, Float2D center)
       public long alpha(Dynamic1D alpha, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.ALPHA, alpha, region, center);
+        }
-...
      * @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 Interpolator which, at any given time, returns a Float2D representing the
      * @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 Interpolator#setCount(float)}
      * @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, Float4D region, Interpolator2D center, int duration, float count)
       public long alpha(float alpha, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.ALPHA, di, region, center);
+        }
-...
      *                 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 Interpolator#setCount(float)}
      * @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, Float4D region, Float2D center, int duration, float count)
       public long alpha(float alpha, Static4D region, Static2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.ALPHA, di, region, center);
+        }
-...
      * @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, Float4D region, Float2D center)
       public long alpha(float alpha, Static4D region, Static2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.ALPHA, di, region, center);
+        }
-...
+     *
      * @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 Interpolator#setCount(float)}
      * @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)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         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(Interpolator1D, Float4D, Interpolator2D)}
      * See {@link #alpha(Dynamic1D, Static4D, Dynamic2D)}
      */
       public long smooth_alpha(Interpolator1D alpha, Float4D region, Interpolator2D center)
       public long smooth_alpha(Dynamic1D alpha, Static4D region, Dynamic2D 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(Interpolator1D, Float4D, Float2D)}
      * See {@link #alpha(Dynamic1D, Static4D, Static2D)}
      */
       public long smooth_alpha(Interpolator1D alpha, Float4D region, Float2D center)
       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, Float4D, Interpolator2D, int, float)}
      * See {@link #alpha(float, Static4D, Dynamic2D, int, float)}
      */
       public long smooth_alpha(float alpha, Float4D region, Interpolator2D center, int duration, float count)
       public long smooth_alpha(float alpha, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.SMOOTH_ALPHA, di, region, center);
+        }
-...
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * See {@link #alpha(float, Float4D, Float2D, int, float)}
      * See {@link #alpha(float, Static4D, Static2D, int, float)}
      */
       public long smooth_alpha(float alpha, Float4D region, Float2D center, int duration, float count)
       public long smooth_alpha(float alpha, Static4D region, Static2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.SMOOTH_ALPHA, di, region, center);
+        }
-...
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * See {@link #alpha(float, Float4D, Float2D)}
      * See {@link #alpha(float, Static4D, Static2D)}
      */
       public long smooth_alpha(float alpha, Float4D region, Float2D center)
       public long smooth_alpha(float alpha, Static4D region, Static2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         di.add(new Static1D(1));
         di.add(new Static1D(alpha));
         return mF.add(EffectNames.SMOOTH_ALPHA, di, region, center);
+        }
-...
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
+     *
      * @param brightness 1-dimensional Interpolator that returns the level of brightness we want to have
      * @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 Interpolator which, at any given time, returns a Float2D representing
      * @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(Interpolator1D brightness, Float4D region, Interpolator2D center)
       public long brightness(Dynamic1D brightness, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.BRIGHTNESS, brightness, region, center);
+        }
-...
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param brightness 1-dimensional Interpolator that returns the level of brightness we want to have
      * @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(Interpolator1D brightness, Float4D region, Float2D center)
       public long brightness(Dynamic1D brightness, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.BRIGHTNESS, brightness, region, center);
+        }
-...
      *                   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 Interpolator which, at any given time, returns a Float2D
      * @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 Interpolator#setCount(float)}
      * @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, Float4D region, Interpolator2D center, int duration, float count)
       public long brightness(float brightness, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.BRIGHTNESS, di, region, center);
+        }
-...
      *                   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 Interpolator#setCount(float)}
      * @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, Float4D region, Float2D center, int duration, float count)
       public long brightness(float brightness, Static4D region, Static2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.BRIGHTNESS, di, region, center);
+        }
-...
      * @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, Float4D region, Float2D center)
       public long brightness(float brightness, Static4D region, Static2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         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.
+     *
      * @param brightness 1-dimensional Interpolator that returns the level of brightness we want to have
      * @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 Interpolator which, at any given time, returns a Float2D
      * @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(Interpolator1D brightness, Float4D region, Interpolator2D center)
       public long smooth_brightness(Dynamic1D brightness, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, brightness, region, center);
+        }
-...
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param brightness 1-dimensional Interpolator that returns the level of brightness we want to have
      * @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(Interpolator1D brightness, Float4D region, Float2D center)
       public long smooth_brightness(Dynamic1D brightness, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, brightness, region, center);
+        }
-...
      *                   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 Interpolator which, at any given time, returns a Float2D
      * @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 Interpolator#setCount(float)}
      * @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, Float4D region, Interpolator2D center, int duration, float count)
       public long smooth_brightness(float brightness, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, center);
+        }
-...
      *                   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 Interpolator#setCount(float)}
      * @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, Float4D region, Float2D center, int duration, float count)
       public long smooth_brightness(float brightness, Static4D region, Static2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, center);
+        }
-...
      * @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, Float4D region, Float2D center)
       public long smooth_brightness(float brightness, Static4D region, Static2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, center);
+        }
-...
      *                   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 Interpolator#setCount(float)}
      * @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)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         di.add(new Static1D(1));
         di.add(new Static1D(brightness));
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di,null, mZero2D);
+        }
-...
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
+     *
      * @param contrast 1-dimensional Interpolator that returns the level of contrast we want to have
      * @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 Interpolator which, at any given time, returns a Float2D
      * @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(Interpolator1D contrast, Float4D region, Interpolator2D center)
       public long contrast(Dynamic1D contrast, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.CONTRAST, contrast, region, center);
+        }
-...
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param contrast 1-dimensional Interpolator that returns the level of contrast we want to have
      * @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(Interpolator1D contrast, Float4D region, Float2D center)
       public long contrast(Dynamic1D contrast, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.CONTRAST, contrast, region, center);
+        }
-...
      *                 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 Interpolator which, at any given time, returns a Float2D
      * @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 Interpolator#setCount(float)}
      * @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, Float4D region, Interpolator2D center, int duration, float count)
       public long contrast(float contrast, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(contrast));
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.CONTRAST, di, region, center);
+        }
-...
      *                 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 Interpolator#setCount(float)}
      * @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, Float4D region, Float2D center, int duration, float count)
       public long contrast(float contrast, Static4D region, Static2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(contrast));
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.CONTRAST, di, region, center);
+        }
-...
      * @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, Float4D region, Float2D center)
       public long contrast(float contrast, Static4D region, Static2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Float1D(1));
         di.add(new Float1D(contrast));
         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.
+     *
      * @param contrast 1-dimensional Interpolator that returns the level of contrast we want to have
      * @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 Interpolator which, at any given time, returns a Float2D
      * @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(Interpolator1D contrast, Float4D region, Interpolator2D center)
       public long smooth_contrast(Dynamic1D contrast, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.SMOOTH_CONTRAST, contrast, region, center);
+        }
-...
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param contrast 1-dimensional Interpolator that returns the level of contrast we want to have
      * @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(Interpolator1D contrast, Float4D region, Float2D center)
       public long smooth_contrast(Dynamic1D contrast, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.SMOOTH_CONTRAST, contrast, region, center);
+        }
-...
      *                 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 Interpolator which, at any given time, returns a Float2D
      * @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 Interpolator#setCount(float)}
      * @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, Float4D region, Interpolator2D center, int duration, float count)
       public long smooth_contrast(float contrast, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(contrast));
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, center);
+        }
-...
      *                 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 Interpolator#setCount(float)}
      * @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, Float4D region, Float2D center, int duration, float count)
       public long smooth_contrast(float contrast, Static4D region, Static2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(contrast));
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, center);
+        }
-...
      * @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, Float4D region, Float2D center)
       public long smooth_contrast(float contrast, Static4D region, Static2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Float1D(1));
         di.add(new Float1D(contrast));
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, center);
+        }
-...
      *                 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 Interpolator#setCount(float)}
      * @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)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(contrast));
         di.add(new Static1D(1));
         di.add(new Static1D(contrast));
         return mF.add(EffectNames.SMOOTH_CONTRAST, di,null, mZero2D);
+        }
-...
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
+     *
      * @param saturation 1-dimensional Interpolator that returns the level of saturation we want to have
      * @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 Interpolator which, at any given time, returns a Float2D
      * @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(Interpolator1D saturation, Float4D region, Interpolator2D center)
       public long saturation(Dynamic1D saturation, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.SATURATION, saturation, region, center);
+        }
-...
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param saturation 1-dimensional Interpolator that returns the level of saturation we want to have
      * @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(Interpolator1D saturation, Float4D region, Float2D center)
       public long saturation(Dynamic1D saturation, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.SATURATION, saturation, region, center);
+        }
-...
      *                   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 Interpolator which, at any given time, returns a Float2D
      * @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 Interpolator#setCount(float)}
      * @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, Float4D region, Interpolator2D center, int duration, float count)
       public long saturation(float saturation, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(saturation));
         di.add(new Static1D(1));
         di.add(new Static1D(saturation));
         return mF.add(EffectNames.SATURATION, di, region, center);
+        }
-...
      *                   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 Interpolator#setCount(float)}
      * @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, Float4D region, Float2D center, int duration, float count)
       public long saturation(float saturation, Static4D region, Static2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(saturation));
         di.add(new Static1D(1));
         di.add(new Static1D(saturation));
         return mF.add(EffectNames.SATURATION, di, region, center);
+        }
-...
      * @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, Float4D region, Float2D center)
       public long saturation(float saturation, Static4D region, Static2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Float1D(1));
         di.add(new Float1D(saturation));
         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.
+     *
      * @param saturation 1-dimensional Interpolator that returns the level of saturation we want to have
      * @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 Interpolator which, at any given time, returns a Float2D
      * @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(Interpolator1D saturation, Float4D region, Interpolator2D center)
       public long smooth_saturation(Dynamic1D saturation, Static4D region, Dynamic2D center)
+        {
         return mF.add(EffectNames.SMOOTH_SATURATION, saturation, region, center);
+        }
-...
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param saturation 1-dimensional Interpolator that returns the level of saturation we want to have
      * @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(Interpolator1D saturation, Float4D region, Float2D center)
       public long smooth_saturation(Dynamic1D saturation, Static4D region, Static2D center)
+        {
         return mF.add(EffectNames.SMOOTH_SATURATION, saturation, region, center);
+        }
-...
      *                   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 Interpolator which, at any given time, returns a Float2D
      * @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 Interpolator#setCount(float)}
      * @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, Float4D region, Interpolator2D center, int duration, float count)
       public long smooth_saturation(float saturation, Static4D region, Dynamic2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(saturation));
         di.add(new Static1D(1));
         di.add(new Static1D(saturation));
         return mF.add(EffectNames.SMOOTH_SATURATION, di, region, center);
+        }
-...
      *                   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 Interpolator#setCount(float)}
      * @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, Float4D region, Float2D center, int duration, float count)
       public long smooth_saturation(float saturation, Static4D region, Static2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();
         di.setCount(count);
         di.setDuration(duration);
         di.add(new Float1D(1));
         di.add(new Float1D(saturation));
         di.add(new Static1D(1));
         di.add(new Static1D(saturation));
         return mF.add(EffectNames.SMOOTH_SATURATION, di, region, center);
+        }
-...
      * @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, Float4D region, Float2D center)
       public long smooth_saturation(float saturation, Static4D region, Static2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         Dynamic1D di = new Dynamic1D();

... 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 568b29d8

Added by Leszek Koltunski over 9 years ago