commit e0a168740a05d5d6eccae412808b34bebd887f90 Author: Leszek Koltunski Date: Wed Jun 15 12:18:06 2016 +0100 cleanup in DistortedObject's methods. diff --git a/src/main/java/org/distorted/library/DistortedObject.java b/src/main/java/org/distorted/library/DistortedObject.java index 85dc907..f7329f6 100644 --- a/src/main/java/org/distorted/library/DistortedObject.java +++ b/src/main/java/org/distorted/library/DistortedObject.java @@ -29,7 +29,10 @@ import android.opengl.GLUtils; */ public abstract class DistortedObject { - private static float[] mViewMatrix = new float[16]; + private static final Float2D mZero2D = new Float2D(0,0); + private static final Float3D mZero3D = new Float3D(0,0,0); + + private static float[] mViewMatrix = new float[16]; protected EffectQueueMatrix mM; protected EffectQueueFragment mF; @@ -468,18 +471,18 @@ public abstract class DistortedObject /** * Moves the Object by a vector that changes in time as interpolated by the Interpolator. * - * @param di 3-dimensional Interpolator which at any given time will return a Float3D - * 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. + * @param vector 3-dimensional Interpolator which at any given time will return a Float3D + * 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 di) + public long move(Interpolator3D vector) { - return mM.add(EffectNames.MOVE,null,di); + return mM.add(EffectNames.MOVE,vector); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Moves the Bitmap by a vector that smoothly changes from (0,0,0) to (x,y,z). + * 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. @@ -495,12 +498,12 @@ public abstract class DistortedObject di.add(new Float3D(0.0f,0.0f,0.0f)); di.add(new Float3D(x,y,z)); - return mM.add(EffectNames.MOVE,null,di); + return mM.add(EffectNames.MOVE,di); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Moves the Bitmap by vector (x,y,z) immediately. + * 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. @@ -509,7 +512,7 @@ public abstract class DistortedObject */ public long move(float x,float y,float z) { - return mM.add(EffectNames.MOVE,0.0f,0.0f,0.0f,x,y,z,0.0f); + return mM.add(EffectNames.MOVE,mZero3D,x,y,z,0.0f); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -517,13 +520,13 @@ public abstract class DistortedObject /** * Scales the Object by factors that change in time as returned by the Interpolator. * - * @param di 3-dimensional Interpolator which at any given time returns a Float3D - * representing the current x- , y- and z- scale factors. - * @return ID of the effect added, or -1 if we failed to add one. + * @param scale 3-dimensional Interpolator which at any given time returns a Float3D + * 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 di) + public long scale(Interpolator3D scale) { - return mM.add(EffectNames.SCALE,null,di); + return mM.add(EffectNames.SCALE,scale); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -546,7 +549,7 @@ public abstract class DistortedObject di.add(new Float3D(1.0f,1.0f,1.0f)); di.add(new Float3D(xscale,yscale,zscale)); - return mM.add(EffectNames.SCALE,null,di); + return mM.add(EffectNames.SCALE,di); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -561,7 +564,7 @@ public abstract class DistortedObject */ public long scale(float xscale,float yscale,float zscale) { - return mM.add(EffectNames.SCALE,0.0f,0.0f,0.0f,xscale,yscale,zscale,0.0f); + return mM.add(EffectNames.SCALE,mZero3D,xscale,yscale,zscale,0.0f); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -574,7 +577,7 @@ public abstract class DistortedObject */ public long scale(float scale) { - return mM.add(EffectNames.SCALE,0.0f,0.0f,0.0f,scale,scale,scale,0.0f); + return mM.add(EffectNames.SCALE,mZero3D,scale,scale,scale,0.0f); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -582,29 +585,29 @@ public abstract class DistortedObject /** * Rotates the Object around a (possibly moving) point, with angle and axis that change in time. * - * @param i 3-dimensional Interpolator which at any given time will return the current center of - * the rotation - * @param v 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. + * @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 i, Interpolator4D v) + public long rotate(Interpolator3D center, Interpolator4D angleAxis) { - return mM.add(EffectNames.ROTATE, i, v); + return mM.add(EffectNames.ROTATE, center, angleAxis); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** * Rotates the Object around a static point, with angle and axis that change in time. * - * @param point Center of the rotation - * @param v 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. + * @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 point, Interpolator4D v) + public long rotate(Float3D center, Interpolator4D angleAxis) { - return mM.add(EffectNames.ROTATE, point.x, point.y, point.z , v); + return mM.add(EffectNames.ROTATE, center , angleAxis); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -612,17 +615,17 @@ public abstract class DistortedObject * Rotates the Object around a static point, with angle that changes in time, around axis * (axisX, axisY, axisZ). * - * @param point Center of the rotation - * @param v 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 point, Interpolator1D v, float axisX, float axisY, float 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, point.x, point.y, point.z , v, axisX, axisY, axisZ); + return mM.add(EffectNames.ROTATE, center , angle, axisX, axisY, axisZ); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -630,14 +633,14 @@ public abstract class DistortedObject * 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 i 3-dimensional Interpolator which at any given time will return the current center - * of the rotation. - * @param a 1-dimensional Interpolator which returns the current rotation angle. - * @return ID of the effect added, or -1 if we failed to add one. + * @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 i, Interpolator1D a) + public long rotate(Interpolator3D center, Interpolator1D angle) { - return mM.add(EffectNames.ROTATE, i, a, 0.0f,0.0f,1.0f); + return mM.add(EffectNames.ROTATE, center, angle, 0.0f,0.0f,1.0f); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -645,12 +648,12 @@ public abstract class DistortedObject * 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 point Coordinates of the Point we are rotating around. + * @param center Coordinates of the Point we are rotating around. * @param angle Angle that we want to rotate the Bitmap 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 point, int angle, int duration) + public long rotate(Float3D center, int angle, int duration) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); @@ -658,7 +661,7 @@ public abstract class DistortedObject di.add(new Float1D( 0)); di.add(new Float1D(angle)); - return mM.add(EffectNames.ROTATE,point.x,point.y,point.z, di, 0.0f,0.0f,1.0f); + return mM.add(EffectNames.ROTATE, center, di, 0.0f,0.0f,1.0f); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -666,29 +669,29 @@ public abstract class DistortedObject * Rotates the Object immediately by 'angle' degrees around point p. * Axis of rotation is given by the last 3 floats. * - * @param point Coordinates of the Point we are rotating around. - * @param angle Angle that we want to rotate the Bitmap to. Unit: degrees - * @param axisX Axis of rotation: x-coordinate - * @param axisY Axis of rotation: y-coordinate - * @param axisZ Axis of rotation: z-coordinate - * @return ID of the effect added, or -1 if we failed to add one. - */ - public long rotate(Float3D point, float angle, float axisX, float axisY, float axisZ) + * @param center Coordinates of the Point we are rotating around. + * @param angle Angle that we want to rotate the Bitmap to. Unit: degrees + * @param axisX Axis of rotation: x-coordinate + * @param axisY Axis of rotation: y-coordinate + * @param axisZ Axis of rotation: z-coordinate + * @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, point.x, point.y, point.z, angle, axisX, axisY, axisZ); + return mM.add(EffectNames.ROTATE, center, angle, axisX, axisY, axisZ); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** * Rotates the Object immediately by 'angle' degrees around point p. * - * @param point Coordinates of the Point we are rotating around. + * @param center Coordinates of the Point we are rotating around. * @param angle The angle that we want to rotate the Bitmap to. Unit: degrees * @return ID of the effect added, or -1 if we failed to add one. */ - public long rotate(Float3D point, int angle) + public long rotate(Float3D center, int angle) { - return mM.add(EffectNames.ROTATE,point.x,point.y,point.z,angle,0.0f,0.0f,1.0f); + return mM.add(EffectNames.ROTATE, center, angle,0.0f,0.0f,1.0f); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -696,42 +699,43 @@ public abstract class DistortedObject /** * Rotates the Object immediately by quaternion (qX,qY,qZ,qW). * - * @param point 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. - */ - public long quaternion(Float3D point, float qX, float qY, float qZ, float 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. + */ + public long quaternion(Float3D center, float qX, float qY, float qZ, float qW) { - return mM.add(EffectNames.QUATERNION,point.x,point.y,point.z,qX,qY,qZ,qW); + return mM.add(EffectNames.QUATERNION,center,qX,qY,qZ,qW); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** * Rotates the Object by a quaternion that's at the moment returned by the InterpolatorQuat. * - * @param point Coordinates of the Point we are rotating around. - * @param iq 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 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. */ - public long quaternion(Float3D point, InterpolatorQuat iq) + public long quaternion(Float3D center, InterpolatorQuat quat) { - return mM.add(EffectNames.QUATERNION,point.x,point.y,point.z,iq); + return mM.add(EffectNames.QUATERNION, center, quat); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** * Rotates the Object around a moving point by a quaternion that's at the moment returned by the InterpolatorQuat. * - * @param i Interpolator that returns the current center of rotation. - * @param iq 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. + * @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 i, InterpolatorQuat iq) + public long quaternion(Interpolator3D center, InterpolatorQuat quat) { - return mM.add(EffectNames.QUATERNION,i,iq); + return mM.add(EffectNames.QUATERNION,center,quat); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -740,34 +744,34 @@ public abstract class DistortedObject * 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. * - * @param point Center of shearing, i.e. the point which stays unmoved. - * @param di 1- 2- or 3D Interpolator which, at any given point, returns the ordered 1-, 2- - * or 3-tuple of shear factors. - * @return ID of the effect added, or -1 if we failed to add one. + * @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. + * @return ID of the effect added, or -1 if we failed to add one. */ - public long shear(Float3D point, Interpolator di) + public long shear(Float3D center, Interpolator shear) { - return mM.add(EffectNames.SHEAR, point.x, point.y, point.z, di); + return mM.add(EffectNames.SHEAR, center, shear); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** * Shears the Object in 3D. Order: first X shearing, then Y, then Z. * - * @param point Center of shearing, i.e. the point which stays unmoved. - * @param vector ordered 3-tuple (x-degree, y-degree, z-degree) of shearing (tangent of the angle with + * @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 point, Float3D vector) + 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(vector); + di.add(shear); - return mM.add(EffectNames.SHEAR, point.x, point.y, point.z, di ); + return mM.add(EffectNames.SHEAR, center, di ); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -778,16 +782,16 @@ public abstract class DistortedObject * 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. * - * @param a 1-dimensional Interpolator which, at any given time, returns the size of the macroblocks. + * @param size 1-dimensional Interpolator 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the + * @param center 2-dimensional Interpolator which, at any given time, returns a Float2D 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 a, Float4D region, Interpolator2D i) + public long macroblock(Interpolator1D size, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.MACROBLOCK, a, region, i); + return mF.add(EffectNames.MACROBLOCK, size, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -797,15 +801,15 @@ public abstract class DistortedObject *

* The difference between this and the previous method is that here the center of the Effect stays constant. * - * @param a 1-dimensional Interpolator which, at any given time, returns the size of the macroblocks. + * @param size 1-dimensional Interpolator 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 Bitmap'. - * @param point Center of the Effect. + * @param center Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long macroblock(Interpolator1D a, Float4D region, Float2D point) + public long macroblock(Interpolator1D size, Float4D region, Float2D center) { - return mF.add(EffectNames.MACROBLOCK, a, region, point.x, point.y); + return mF.add(EffectNames.MACROBLOCK, size, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -819,13 +823,13 @@ public abstract class DistortedObject * @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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the + * @param center 2-dimensional Interpolator which, at any given time, returns a Float2D 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long macroblock(int pixels, Float4D region, Interpolator2D i, int duration, float count) + public long macroblock(int pixels, Float4D region, Interpolator2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -833,7 +837,7 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(pixels)); - return mF.add(EffectNames.MACROBLOCK, di, region, i); + return mF.add(EffectNames.MACROBLOCK, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -849,12 +853,12 @@ public abstract class DistortedObject * @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 Bitmap'. - * @param point Center of the Effect. + * @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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long macroblock(int pixels, Float4D region, Float2D point, int duration, float count) + public long macroblock(int pixels, Float4D region, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -862,12 +866,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(pixels)); - return mF.add(EffectNames.MACROBLOCK, di, region, point.x, point.y); + return mF.add(EffectNames.MACROBLOCK, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Creates macroblocks on the whole Bitmap. + * Creates macroblocks on the whole Object. *

* 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 @@ -889,207 +893,207 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(pixels)); - return mF.add(EffectNames.MACROBLOCK, di, null, 0.0f, 0.0f); + return mF.add(EffectNames.MACROBLOCK, di, null, mZero2D); } /////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// // CHROMA /** - * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components. + * Makes a certain sub-region of the Object smoothly change all three of its RGB components. * - * @param t 1-dimensional Interpolator that returns the level of blend a given pixel will be + * @param blend 1-dimensional Interpolator 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing + * @param center 2-dimensional Interpolator which, at any given time, returns a Float2D 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 t, Float3D color, Float4D region, Interpolator2D i) + public long chroma(Interpolator1D blend, Float3D color, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.CHROMA, t, color, region, i); + return mF.add(EffectNames.CHROMA, blend, color, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components. + * Makes a certain sub-region of the Object smoothly change all three of its RGB components. *

* Here the center of the Effect stays constant. * - * @param t 1-dimensional Interpolator that returns the level of blend a given pixel will be + * @param blend 1-dimensional Interpolator 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 Bitmap'. - * @param point Center of the Effect. + * @param center Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long chroma(Interpolator1D t, Float3D color, Float4D region, Float2D point) + public long chroma(Interpolator1D blend, Float3D color, Float4D region, Float2D center) { - return mF.add(EffectNames.CHROMA, t, color, region, point.x, point.y); + return mF.add(EffectNames.CHROMA, blend, color, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components. + * Makes a certain sub-region of the Object smoothly change all three of its RGB components. * - * @param t Level of blend a given pixel will be mixed with the next parameter 'color': + * @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 Region this Effect is limited to. * Null here means 'apply the Effect to the whole Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the + * @param center 2-dimensional Interpolator which, at any given time, returns a Float2D 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 t, Float3D color, Float4D region, Interpolator2D i) + public long chroma(float blend, Float3D color, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.CHROMA, t, color, region, i); + return mF.add(EffectNames.CHROMA, blend, color, region, center); } ///// ////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components. + * Makes a certain sub-region of the Object smoothly change all three of its RGB components. *

* Here the center of the Effect stays constant. * - * @param t Level of blend a given pixel will be mixed with the next parameter 'color': + * @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 Bitmap'. - * @param point Center of the Effect. + * @param center Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long chroma(float t, Float3D color, Float4D region, Float2D point) + public long chroma(float blend, Float3D color, Float4D region, Float2D center) { - return mF.add(EffectNames.CHROMA, t, color, region, point.x, point.y); + return mF.add(EffectNames.CHROMA, blend, color, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components. + * Makes a certain sub-region of the Object smoothly change all three of its RGB components. *

* Here the Effect applies to the whole bitmap. * - * @param t Level of blend a given pixel will be mixed with the next parameter 'color': + * @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 t, Float3D color) + public long chroma(float blend, Float3D color) { - return mF.add(EffectNames.CHROMA, t, color, null, 0, 0); + return mF.add(EffectNames.CHROMA, blend, color, null, mZero2D); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components. + * Makes a certain sub-region of the Object smoothly change all three of its RGB components. * * See {@link #chroma(Interpolator1D, Float3D, Float4D, Interpolator2D)} */ - public long smooth_chroma(Interpolator1D t, Float3D color, Float4D region, Interpolator2D i) + public long smooth_chroma(Interpolator1D blend, Float3D color, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.SMOOTH_CHROMA, t, color, region, i); + return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components. + * Makes a certain sub-region of the Object smoothly change all three of its RGB components. * * See {@link #chroma(Interpolator1D, Float3D, Float4D, Float2D)} */ - public long smooth_chroma(Interpolator1D t, Float3D color, Float4D region, Float2D point) + public long smooth_chroma(Interpolator1D blend, Float3D color, Float4D region, Float2D center) { - return mF.add(EffectNames.SMOOTH_CHROMA, t, color, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components. + * Makes a certain sub-region of the Object smoothly change all three of its RGB components. * * See {@link #chroma(float, Float3D, Float4D, Interpolator2D)} */ - public long smooth_chroma(float t, Float3D color, Float4D region, Interpolator2D i) + public long smooth_chroma(float blend, Float3D color, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.SMOOTH_CHROMA, t, color, region, i); + return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components. + * Makes a certain sub-region of the Object smoothly change all three of its RGB components. * * See {@link #chroma(float, Float3D, Float4D, Float2D)} */ - public long smooth_chroma(float t, Float3D color, Float4D region, Float2D point) + public long smooth_chroma(float blend, Float3D color, Float4D region, Float2D center) { - return mF.add(EffectNames.SMOOTH_CHROMA, t, color, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components. + * Makes a certain sub-region of the Object smoothly change all three of its RGB components. * * See {@link #chroma(float, Float3D)} */ - public long smooth_chroma(float t, Float3D color) + public long smooth_chroma(float blend, Float3D color) { - return mF.add(EffectNames.SMOOTH_CHROMA, t, color, null, 0, 0); + return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, null, mZero2D); } /////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// // ALPHA /** - * Makes a certain sub-region of the Bitmap smoothly change its transparency level. + * Makes a certain sub-region of the Object smoothly change its transparency level. * - * @param a 1-dimensional Interpolator that returns the level of transparency we want to have at any given + * @param alpha 1-dimensional Interpolator 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the + * 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 * current center of the effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long alpha(Interpolator1D a, Float4D region, Interpolator2D i) + public long alpha(Interpolator1D alpha, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.ALPHA, a, region, i); + return mF.add(EffectNames.ALPHA, alpha, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its transparency level. + * Makes a certain sub-region of the Object smoothly change its transparency level. *

* Here the center of the Effect stays constant. * - * @param a 1-dimensional Interpolator that returns the level of transparency we want to have at any given + * @param alpha 1-dimensional Interpolator 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 Bitmap'. - * @param point Center of the Effect. + * 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 a, Float4D region, Float2D point) + public long alpha(Interpolator1D alpha, Float4D region, Float2D center) { - return mF.add(EffectNames.ALPHA, a, region, point.x, point.y); + return mF.add(EffectNames.ALPHA, alpha, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its transparency level. + * Makes a certain sub-region of the Object smoothly change its transparency 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the + * 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 * 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long alpha(float alpha, Float4D region, Interpolator2D i, int duration, float count) + public long alpha(float alpha, Float4D region, Interpolator2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1097,24 +1101,24 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(alpha)); - return mF.add(EffectNames.ALPHA, di, region, i); + return mF.add(EffectNames.ALPHA, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its transparency level. + * Makes a certain sub-region of the Object smoothly change its transparency level. *

* 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 Bitmap'. - * @param point Center of the Effect. + * @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 Interpolator#setCount(float)} - * @return ID of the effect added, or -1 if we failed to add one. + * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)} + * @return ID of the effect added, or -1 if we failed to add one. */ - public long alpha(float alpha, Float4D region, Float2D point, int duration, float count) + public long alpha(float alpha, Float4D region, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1122,22 +1126,22 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(alpha)); - return mF.add(EffectNames.ALPHA, di, region, point.x, point.y); + return mF.add(EffectNames.ALPHA, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its transparency level. + * Makes a certain sub-region of the Object smoothly change its transparency level. *

* 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 Bitmap'. - * @param point Center of the Effect. + * 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, Float4D region, Float2D point) + public long alpha(float alpha, Float4D region, Float2D center) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); @@ -1145,12 +1149,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(alpha)); - return mF.add(EffectNames.ALPHA, di, region, point.x, point.y); + return mF.add(EffectNames.ALPHA, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes the whole Bitmap change its transparency level. + * 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. @@ -1165,38 +1169,38 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(alpha)); - return mF.add(EffectNames.ALPHA, di,null, 0.0f, 0.0f); + return mF.add(EffectNames.ALPHA, di,null, mZero2D); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its transparency level. + * Makes a certain sub-region of the Object smoothly change its transparency level. * * See {@link #alpha(Interpolator1D, Float4D, Interpolator2D)} */ - public long smooth_alpha(Interpolator1D a, Float4D region, Interpolator2D i) + public long smooth_alpha(Interpolator1D alpha, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.SMOOTH_ALPHA, a, region, i); + return mF.add(EffectNames.SMOOTH_ALPHA, alpha, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its transparency level. + * Makes a certain sub-region of the Object smoothly change its transparency level. * * See {@link #alpha(Interpolator1D, Float4D, Float2D)} */ - public long smooth_alpha(Interpolator1D a, Float4D region, Float2D point) + public long smooth_alpha(Interpolator1D alpha, Float4D region, Float2D center) { - return mF.add(EffectNames.SMOOTH_ALPHA, a, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_ALPHA, alpha, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its transparency level. + * Makes a certain sub-region of the Object smoothly change its transparency level. * * See {@link #alpha(float, Float4D, Interpolator2D, int, float)} */ - public long smooth_alpha(float alpha, Float4D region, Interpolator2D i, int duration, float count) + public long smooth_alpha(float alpha, Float4D region, Interpolator2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1204,16 +1208,16 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(alpha)); - return mF.add(EffectNames.SMOOTH_ALPHA, di, region, i); + return mF.add(EffectNames.SMOOTH_ALPHA, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its transparency level. + * Makes a certain sub-region of the Object smoothly change its transparency level. * * See {@link #alpha(float, Float4D, Float2D, int, float)} */ - public long smooth_alpha(float alpha, Float4D region, Float2D point, int duration, float count) + public long smooth_alpha(float alpha, Float4D region, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1221,16 +1225,16 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(alpha)); - return mF.add(EffectNames.SMOOTH_ALPHA, di, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_ALPHA, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its transparency level. + * Makes a certain sub-region of the Object smoothly change its transparency level. * * See {@link #alpha(float, Float4D, Float2D)} */ - public long smooth_alpha(float alpha, Float4D region, Float2D point) + public long smooth_alpha(float alpha, Float4D region, Float2D center) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); @@ -1238,62 +1242,62 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(alpha)); - return mF.add(EffectNames.SMOOTH_ALPHA, di, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_ALPHA, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// // BRIGHTNESS /** - * Makes a certain sub-region of the Bitmap smoothly change its brightness level. + * Makes a certain sub-region of the Object smoothly change its brightness level. * - * @param a 1-dimensional Interpolator 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the - * current center of the effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param brightness 1-dimensional Interpolator 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 + * the current center of the effect. + * @return ID of the effect added, or -1 if we failed to add one. */ - public long brightness(Interpolator1D a, Float4D region, Interpolator2D i) + public long brightness(Interpolator1D brightness, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.BRIGHTNESS, a, region, i); + return mF.add(EffectNames.BRIGHTNESS, brightness, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its brightness level. + * Makes a certain sub-region of the Object smoothly change its brightness level. *

* Here the center of the Effect stays constant. * - * @param a 1-dimensional Interpolator 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 Bitmap'. - * @param point Center of the Effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param brightness 1-dimensional Interpolator 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 a, Float4D region, Float2D point) + public long brightness(Interpolator1D brightness, Float4D region, Float2D center) { - return mF.add(EffectNames.BRIGHTNESS, a, region, point.x, point.y); + return mF.add(EffectNames.BRIGHTNESS, brightness, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its brightness level. + * 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D + * 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 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long brightness(float brightness, Float4D region, Interpolator2D i, int duration, float count) + public long brightness(float brightness, Float4D region, Interpolator2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1301,12 +1305,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(brightness)); - return mF.add(EffectNames.BRIGHTNESS, di, region, i); + return mF.add(EffectNames.BRIGHTNESS, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its brightness level. + * Makes a certain sub-region of the Object smoothly change its brightness level. *

* Here the center of the Effect stays constant. * @@ -1314,13 +1318,13 @@ public abstract class DistortedObject * 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 Bitmap'. - * @param point Center of the Effect. + * 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long brightness(float brightness, Float4D region, Float2D point, int duration, float count) + public long brightness(float brightness, Float4D region, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1328,12 +1332,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(brightness)); - return mF.add(EffectNames.BRIGHTNESS, di, region, point.x, point.y); + return mF.add(EffectNames.BRIGHTNESS, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its brightness level. + * Makes a certain sub-region of the Object smoothly change its brightness level. *

* Here the center of the Effect stays constant and the effect for now change in time. * @@ -1341,11 +1345,11 @@ public abstract class DistortedObject * 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 Bitmap'. - * @param point Center of the Effect. + * 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, Float4D region, Float2D point) + public long brightness(float brightness, Float4D region, Float2D center) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); @@ -1353,62 +1357,62 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(brightness)); - return mF.add(EffectNames.BRIGHTNESS, di, region, point.x, point.y); + return mF.add(EffectNames.BRIGHTNESS, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// // SMOOTH BRIGHTNESS /** - * Makes a certain sub-region of the Bitmap smoothly change its brightness level. + * Makes a certain sub-region of the Object smoothly change its brightness level. * - * @param a 1-dimensional Interpolator 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D - * representing the current center of the effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param brightness 1-dimensional Interpolator 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 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 a, Float4D region, Interpolator2D i) + public long smooth_brightness(Interpolator1D brightness, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.SMOOTH_BRIGHTNESS, a, region, i); + return mF.add(EffectNames.SMOOTH_BRIGHTNESS, brightness, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its brightness level. + * Makes a certain sub-region of the Object smoothly change its brightness level. *

* Here the center of the Effect stays constant. * - * @param a 1-dimensional Interpolator 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 Bitmap'. - * @param point Center of the Effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param brightness 1-dimensional Interpolator 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 a, Float4D region, Float2D point) + public long smooth_brightness(Interpolator1D brightness, Float4D region, Float2D center) { - return mF.add(EffectNames.SMOOTH_BRIGHTNESS, a, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_BRIGHTNESS, brightness, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its brightness level. + * 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D + * Null here means 'apply the Effect to the whole Object'. + * @param center 2-dimensional Interpolator which, at any given time, returns a Float2D * 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long smooth_brightness(float brightness, Float4D region, Interpolator2D i, int duration, float count) + public long smooth_brightness(float brightness, Float4D region, Interpolator2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1416,12 +1420,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(brightness)); - return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, i); + return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its brightness level. + * Makes a certain sub-region of the Object smoothly change its brightness level. *

* Here the center of the Effect stays constant. * @@ -1429,13 +1433,13 @@ public abstract class DistortedObject * 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 Bitmap'. - * @param point Center of the Effect. + * 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long smooth_brightness(float brightness, Float4D region, Float2D point, int duration, float count) + public long smooth_brightness(float brightness, Float4D region, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1443,12 +1447,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(brightness)); - return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its brightness level. + * Makes a certain sub-region of the Object smoothly change its brightness level. *

* Here the center of the Effect stays constant and the effect for now change in time. * @@ -1456,11 +1460,11 @@ public abstract class DistortedObject * 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 Bitmap'. - * @param point Center of the Effect. + * 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, Float4D region, Float2D point) + public long smooth_brightness(float brightness, Float4D region, Float2D center) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); @@ -1468,12 +1472,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(brightness)); - return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes the whole Bitmap change its brightness level. + * 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', @@ -1490,62 +1494,62 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(brightness)); - return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di,null, 0.0f, 0.0f); + return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di,null, mZero2D); } /////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// // CONTRAST /** - * Makes a certain sub-region of the Bitmap smoothly change its contrast level. + * Makes a certain sub-region of the Object smoothly change its contrast level. * - * @param a 1-dimensional Interpolator 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D - * representing the current center of the effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param contrast 1-dimensional Interpolator 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 + * 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 a, Float4D region, Interpolator2D i) + public long contrast(Interpolator1D contrast, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.CONTRAST, a, region, i); + return mF.add(EffectNames.CONTRAST, contrast, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its contrast level. + * Makes a certain sub-region of the Object smoothly change its contrast level. *

* Here the center of the Effect stays constant. * - * @param a 1-dimensional Interpolator 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 Bitmap'. - * @param point Center of the Effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param contrast 1-dimensional Interpolator 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 a, Float4D region, Float2D point) + public long contrast(Interpolator1D contrast, Float4D region, Float2D center) { - return mF.add(EffectNames.CONTRAST, a, region, point.x, point.y); + return mF.add(EffectNames.CONTRAST, contrast, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its contrast level. + * 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D + * Null here means 'apply the Effect to the whole Object'. + * @param center 2-dimensional Interpolator which, at any given time, returns a Float2D * 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long contrast(float contrast, Float4D region, Interpolator2D i, int duration, float count) + public long contrast(float contrast, Float4D region, Interpolator2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1553,12 +1557,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(contrast)); - return mF.add(EffectNames.CONTRAST, di, region, i); + return mF.add(EffectNames.CONTRAST, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its contrast level. + * Makes a certain sub-region of the Object smoothly change its contrast level. *

* Here the center of the Effect stays constant. * @@ -1566,13 +1570,13 @@ public abstract class DistortedObject * 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 Bitmap'. - * @param point Center of the Effect. + * 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long contrast(float contrast, Float4D region, Float2D point, int duration, float count) + public long contrast(float contrast, Float4D region, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1580,12 +1584,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(contrast)); - return mF.add(EffectNames.CONTRAST, di, region, point.x, point.y); + return mF.add(EffectNames.CONTRAST, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its contrast level. + * Makes a certain sub-region of the Object smoothly change its contrast level. *

* Here the center of the Effect stays constant and the effect for now change in time. * @@ -1593,11 +1597,11 @@ public abstract class DistortedObject * 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 Bitmap'. - * @param point Center of the Effect. + * 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, Float4D region, Float2D point) + public long contrast(float contrast, Float4D region, Float2D center) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); @@ -1605,62 +1609,62 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(contrast)); - return mF.add(EffectNames.CONTRAST, di, region, point.x, point.y); + return mF.add(EffectNames.CONTRAST, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// // SMOOTH CONTRAST /** - * Makes a certain sub-region of the Bitmap smoothly change its contrast level. + * Makes a certain sub-region of the Object smoothly change its contrast level. * - * @param a 1-dimensional Interpolator 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D - * representing the current center of the effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param contrast 1-dimensional Interpolator 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 + * 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 a, Float4D region, Interpolator2D i) + public long smooth_contrast(Interpolator1D contrast, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.SMOOTH_CONTRAST, a, region, i); + return mF.add(EffectNames.SMOOTH_CONTRAST, contrast, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its contrast level. + * Makes a certain sub-region of the Object smoothly change its contrast level. *

* Here the center of the Effect stays constant. * - * @param a 1-dimensional Interpolator 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 Bitmap'. - * @param point Center of the Effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param contrast 1-dimensional Interpolator 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 a, Float4D region, Float2D point) + public long smooth_contrast(Interpolator1D contrast, Float4D region, Float2D center) { - return mF.add(EffectNames.SMOOTH_CONTRAST, a, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_CONTRAST, contrast, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its contrast level. + * 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D + * 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 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long smooth_contrast(float contrast, Float4D region, Interpolator2D i, int duration, float count) + public long smooth_contrast(float contrast, Float4D region, Interpolator2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1668,12 +1672,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(contrast)); - return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, i); + return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its contrast level. + * Makes a certain sub-region of the Object smoothly change its contrast level. *

* Here the center of the Effect stays constant. * @@ -1681,13 +1685,13 @@ public abstract class DistortedObject * 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 Bitmap'. - * @param point Center of the Effect. + * 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long smooth_contrast(float contrast, Float4D region, Float2D point, int duration, float count) + public long smooth_contrast(float contrast, Float4D region, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1695,12 +1699,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(contrast)); - return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its contrast level. + * Makes a certain sub-region of the Object smoothly change its contrast level. *

* Here the center of the Effect stays constant and the effect for now change in time. * @@ -1708,11 +1712,11 @@ public abstract class DistortedObject * 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 Bitmap'. - * @param point Center of the Effect. + * 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, Float4D region, Float2D point) + public long smooth_contrast(float contrast, Float4D region, Float2D center) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); @@ -1720,16 +1724,16 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(contrast)); - return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes the whole Bitmap change its contrast level. + * 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 omre than 1 - increase the 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)} * @return ID of the effect added, or -1 if we failed to add one. @@ -1742,7 +1746,7 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(contrast)); - return mF.add(EffectNames.SMOOTH_CONTRAST, di,null, 0.0f, 0.0f); + return mF.add(EffectNames.SMOOTH_CONTRAST, di,null, mZero2D); } @@ -1750,55 +1754,55 @@ public abstract class DistortedObject /////////////////////////////////////////////////////////////////////////////////////////////////// // SATURATION /** - * Makes a certain sub-region of the Bitmap smoothly change its saturation level. + * Makes a certain sub-region of the Object smoothly change its saturation level. * - * @param a 1-dimensional Interpolator 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D - * representing the current center of the effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param saturation 1-dimensional Interpolator 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 + * 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 a, Float4D region, Interpolator2D i) + public long saturation(Interpolator1D saturation, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.SATURATION, a, region, i); + return mF.add(EffectNames.SATURATION, saturation, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its saturation level. + * Makes a certain sub-region of the Object smoothly change its saturation level. *

* Here the center of the Effect stays constant. * - * @param a 1-dimensional Interpolator 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 Bitmap'. - * @param point Center of the Effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param saturation 1-dimensional Interpolator 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 a, Float4D region, Float2D point) + public long saturation(Interpolator1D saturation, Float4D region, Float2D center) { - return mF.add(EffectNames.SATURATION, a, region, point.x, point.y); + return mF.add(EffectNames.SATURATION, saturation, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its saturation level. + * 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D + * 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 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long saturation(float saturation, Float4D region, Interpolator2D i, int duration, float count) + public long saturation(float saturation, Float4D region, Interpolator2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1806,12 +1810,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(saturation)); - return mF.add(EffectNames.SATURATION, di, region, i); + return mF.add(EffectNames.SATURATION, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its saturation level. + * Makes a certain sub-region of the Object smoothly change its saturation level. *

* Here the center of the Effect stays constant. * @@ -1819,13 +1823,13 @@ public abstract class DistortedObject * 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 Bitmap'. - * @param point Center of the Effect. + * 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long saturation(float saturation, Float4D region, Float2D point, int duration, float count) + public long saturation(float saturation, Float4D region, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1833,12 +1837,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(saturation)); - return mF.add(EffectNames.SATURATION, di, region, point.x, point.y); + return mF.add(EffectNames.SATURATION, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its saturation level. + * Makes a certain sub-region of the Object smoothly change its saturation level. *

* Here the center of the Effect stays constant and the effect for now change in time. * @@ -1846,11 +1850,11 @@ public abstract class DistortedObject * 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 Bitmap'. - * @param point Center of the Effect. + * 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, Float4D region, Float2D point) + public long saturation(float saturation, Float4D region, Float2D center) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); @@ -1858,62 +1862,62 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(saturation)); - return mF.add(EffectNames.SATURATION, di, region, point.x, point.y); + return mF.add(EffectNames.SATURATION, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// // SMOOTH_SATURATION /** - * Makes a certain sub-region of the Bitmap smoothly change its saturation level. + * Makes a certain sub-region of the Object smoothly change its saturation level. * - * @param a 1-dimensional Interpolator 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D - * representing the current center of the effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param saturation 1-dimensional Interpolator 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 + * 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 a, Float4D region, Interpolator2D i) + public long smooth_saturation(Interpolator1D saturation, Float4D region, Interpolator2D center) { - return mF.add(EffectNames.SMOOTH_SATURATION, a, region, i); + return mF.add(EffectNames.SMOOTH_SATURATION, saturation, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its saturation level. + * Makes a certain sub-region of the Object smoothly change its saturation level. *

* Here the center of the Effect stays constant. * - * @param a 1-dimensional Interpolator 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 Bitmap'. - * @param point Center of the Effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param saturation 1-dimensional Interpolator 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 a, Float4D region, Float2D point) + public long smooth_saturation(Interpolator1D saturation, Float4D region, Float2D center) { - return mF.add(EffectNames.SMOOTH_SATURATION, a, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_SATURATION, saturation, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its saturation level. + * 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 Bitmap'. - * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D + * 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 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long smooth_saturation(float saturation, Float4D region, Interpolator2D i, int duration, float count) + public long smooth_saturation(float saturation, Float4D region, Interpolator2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1921,12 +1925,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(saturation)); - return mF.add(EffectNames.SMOOTH_SATURATION, di, region, i); + return mF.add(EffectNames.SMOOTH_SATURATION, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its saturation level. + * Makes a certain sub-region of the Object smoothly change its saturation level. *

* Here the center of the Effect stays constant. * @@ -1934,13 +1938,13 @@ public abstract class DistortedObject * 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 Bitmap'. - * @param point Center of the Effect. + * 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long smooth_saturation(float saturation, Float4D region, Float2D point, int duration, float count) + public long smooth_saturation(float saturation, Float4D region, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); @@ -1948,12 +1952,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(saturation)); - return mF.add(EffectNames.SMOOTH_SATURATION, di, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_SATURATION, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes a certain sub-region of the Bitmap smoothly change its saturation level. + * Makes a certain sub-region of the Object smoothly change its saturation level. *

* Here the center of the Effect stays constant and the effect for now change in time. * @@ -1961,11 +1965,11 @@ public abstract class DistortedObject * 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 Bitmap'. - * @param point Center of the Effect. + * 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, Float4D region, Float2D point) + public long smooth_saturation(float saturation, Float4D region, Float2D center) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); @@ -1973,12 +1977,12 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(saturation)); - return mF.add(EffectNames.SMOOTH_SATURATION, di, region, point.x, point.y); + return mF.add(EffectNames.SMOOTH_SATURATION, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Makes the whole Bitmap change its saturation level. + * 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, @@ -1995,7 +1999,7 @@ public abstract class DistortedObject di.add(new Float1D(1)); di.add(new Float1D(saturation)); - return mF.add(EffectNames.SMOOTH_SATURATION, di,null, 0.0f, 0.0f); + return mF.add(EffectNames.SMOOTH_SATURATION, di,null, mZero2D); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2003,63 +2007,63 @@ public abstract class DistortedObject /////////////////////////////////////////////////////////////////////////////////////////////////// // DISTORT /** - * Distort a (possibly changing in time) part of the Bitmap by a (possibly changing in time) vector of force. + * Distort a (possibly changing in time) part of the Object by a (possibly changing in time) vector of force. * - * @param i 2- or 3-dimensional Interpolator that returns a 2- or 3-dimensional Point which + * @param vector 2- or 3-dimensional Interpolator that returns a 2- or 3-dimensional Point which * represents the vector the Center of the Effect is currently being dragged with. * @param region Region that masks the effect of the Distortion. - * @param p 2-dimensional Interpolator that, at any given time, returns a Point2D representing + * @param center 2-dimensional Interpolator that, at any given time, returns a Point2D representing * the Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long distort(Interpolator i, Float4D region, Interpolator2D p) + public long distort(Interpolator vector, Float4D region, Interpolator2D center) { - return mV.add(EffectNames.DISTORT, i, region, p); + return mV.add(EffectNames.DISTORT, vector, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Distort part of the Bitmap by a (possibly changing in time) vector of force. + * Distort part of the Object by a (possibly changing in time) vector of force. *

* Difference between this and the previous method is that here the center of the Effect stays constant. * - * @param i 2- or 3-dimensional Interpolator that returns a 2- or 3-dimensional Point which + * @param vector 2- or 3-dimensional Interpolator that returns a 2- or 3-dimensional Point which * represents the vector the Center of the Effect is currently being dragged with. * @param region Region that masks the effect of the Distortion. - * @param point Center of the Effect. + * @param center Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long distort(Interpolator i, Float4D region, Float2D point) + public long distort(Interpolator vector, Float4D region, Float2D center) { - return mV.add(EffectNames.DISTORT, i, region, point.x, point.y); + return mV.add(EffectNames.DISTORT, vector, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Distort the whole Bitmap by a (possibly changing in time) vector of force. + * Distort the whole Object by a (possibly changing in time) vector of force. * - * @param i 2- or 3-dimensional Interpolator that returns a 2- or 3-dimensional Point which - * represents the vector the Center of the Effect is currently being dragged with. - * @param point Center of the Effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param vector 2- or 3-dimensional Interpolator that returns a 2- or 3-dimensional Point which + * represents the vector the Center of the Effect is currently being dragged with. + * @param center Center of the Effect. + * @return ID of the effect added, or -1 if we failed to add one. */ - public long distort(Interpolator i, Float2D point) + public long distort(Interpolator vector, Float2D center) { - return mV.add(EffectNames.DISTORT, i, null, point.x, point.y); + return mV.add(EffectNames.DISTORT, vector, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Distort part of the Bitmap by a vector of force that changes from (0,0,0) to v. + * Distort part of the Object by a vector of force that changes from (0,0,0) to v. * * @param vector Maximum vector of force. * @param region Region that masks the effect of the Distortion. - * @param point Center of the Effect. + * @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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long distort(Float3D vector, Float4D region, Float2D point, int duration, float count) + public long distort(Float3D vector, Float4D region, Float2D center, int duration, float count) { Interpolator3D di = new Interpolator3D(); di.setCount(count); @@ -2067,20 +2071,20 @@ public abstract class DistortedObject di.add(new Float3D(0.0f,0.0f,0.0f)); di.add(vector); - return mV.add(EffectNames.DISTORT, di, region, point.x, point.y); + return mV.add(EffectNames.DISTORT, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Distort the whole Bitmap by a vector of force that changes from (0,0,0) to v. + * Distort the whole Object by a vector of force that changes from (0,0,0) to v. * * @param vector Maximum vector of force. - * @param point Center of the Effect. + * @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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long distort(Float3D vector, Float2D point, int duration, float count) + public long distort(Float3D vector, Float2D center, int duration, float count) { Interpolator3D di = new Interpolator3D(); di.setCount(count); @@ -2088,22 +2092,22 @@ public abstract class DistortedObject di.add(new Float3D(0.0f,0.0f,0.0f)); di.add(vector); - return mV.add(EffectNames.DISTORT, di, null, point.x, point.y); + return mV.add(EffectNames.DISTORT, di, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Distort the whole Bitmap by a vector of force that changes from (0,0,0) to v. + * Distort the whole Object by a vector of force that changes from (0,0,0) to v. *

* Difference between this and the previous method is that here the vector of force will get interpolated * to the maximum v and the effect will end. We are thus limited to count=0.5. * * @param vector Maximum, final vector of force. - * @param point Center of the Effect. + * @param center Center of the Effect. * @param duration Time, in milliseconds, it takes to do one full interpolation. * @return ID of the effect added, or -1 if we failed to add one. */ - public long distort(Float3D vector, Float2D point, int duration) + public long distort(Float3D vector, Float2D center, int duration) { Interpolator3D di = new Interpolator3D(); di.setCount(0.5f); @@ -2111,20 +2115,20 @@ public abstract class DistortedObject di.add(new Float3D(0.0f,0.0f,0.0f)); di.add(vector); - return mV.add(EffectNames.DISTORT, di, null, point.x, point.y); + return mV.add(EffectNames.DISTORT, di, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Distort the whole Bitmap by a vector of force v. + * Distort the whole Object by a vector of force v. *

* Here we apply a constant vector of force. * * @param vector Vector of force. - * @param point Center of the Effect. + * @param center Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long distort(Float3D vector, Float2D point ) + public long distort(Float3D vector, Float2D center ) { Interpolator3D di = new Interpolator3D(); di.setCount(0.5f); @@ -2132,54 +2136,54 @@ public abstract class DistortedObject di.add(new Float3D(0.0f,0.0f,0.0f)); di.add(vector); - return mV.add(EffectNames.DISTORT, di, null, point.x, point.y); + return mV.add(EffectNames.DISTORT, di, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// // DEFORM /** - * Deform the shape of the whole Bitmap with a (possibly changing in time) vector of force applied to + * Deform the shape of the whole Object with a (possibly changing in time) vector of force applied to * a (possibly changing in time) point on the Bitmap. * - * @param i Interpolator that, at any given time, returns a Point2D representing vector of - * force that deforms the shapre of the whole Bitmap. - * @param point 2-dimensional Interpolator that, at any given time, returns a Point2D representing - * the Center of the Effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param vector Interpolator that, at any given time, returns a Float2D representing vector of + * force that deforms the shape of the whole Bitmap. + * @param center 2-dimensional Interpolator that, at any given time, returns a Point2D representing + * the Center of the Effect. + * @return ID of the effect added, or -1 if we failed to add one. */ - public long deform(Interpolator i, Interpolator2D point) + public long deform(Interpolator vector, Interpolator2D center) { - return mV.add(EffectNames.DEFORM, i, null, point); + return mV.add(EffectNames.DEFORM, vector, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Deform the shape of the whole Bitmap with a (possibly changing in time) vector of force applied to + * Deform the shape of the whole Object with a (possibly changing in time) vector of force applied to * a constant point on the Bitmap. * - * @param i Interpolator that, at any given time, returns a Point2D representing - * vector of force that deforms the shapre of the whole Bitmap. - * @param point Center of the Effect. - * @return ID of the effect added, or -1 if we failed to add one. + * @param vector Interpolator that, at any given time, returns a Float2D representing + * vector of force that deforms the shape of the whole Bitmap. + * @param center Center of the Effect. + * @return ID of the effect added, or -1 if we failed to add one. */ - public long deform(Interpolator i, Float2D point) + public long deform(Interpolator vector, Float2D center) { - return mV.add(EffectNames.DEFORM, i, null, point.x, point.y); + return mV.add(EffectNames.DEFORM, vector, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Deform the shape of the whole Bitmap with a vector of force smoothly changing from (0,0,0) to v - * applied to a constant point on the Bitmap. + * Deform the shape of the whole Object with a vector of force smoothly changing from (0,0,0) to v + * applied to a constant point on the Object. * * @param vector Vector of force. - * @param point Center of the Effect. + * @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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long deform(Float3D vector, Float2D point, int duration, float count) + public long deform(Float3D vector, Float2D center, int duration, float count) { Interpolator3D di = new Interpolator3D(); di.setCount(count); @@ -2187,22 +2191,22 @@ public abstract class DistortedObject di.add(new Float3D(0.0f,0.0f,0.0f)); di.add(vector); - return mV.add(EffectNames.DEFORM, di, null, point.x, point.y); + return mV.add(EffectNames.DEFORM, di, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Deform the shape of the whole Bitmap with a vector of force smoothly changing from (0,0,0) to v - * applied to a constant point on the Bitmap. + * Deform the shape of the whole Object with a vector of force smoothly changing from (0,0,0) to v + * applied to a constant point on the Object. *

* Identical to calling the previous method with count=0.5. * * @param vector Final vector of force. - * @param point Center of the Effect. + * @param center Center of the Effect. * @param duration Time, in milliseconds, it takes to do one full interpolation. * @return ID of the effect added, or -1 if we failed to add one. */ - public long deform(Float3D vector, Float2D point, int duration) + public long deform(Float3D vector, Float2D center, int duration) { Interpolator3D di = new Interpolator3D(); di.setCount(0.5f); @@ -2210,19 +2214,19 @@ public abstract class DistortedObject di.add(new Float3D(0.0f,0.0f,0.0f)); di.add(vector); - return mV.add(EffectNames.DEFORM, di, null, point.x, point.y); + return mV.add(EffectNames.DEFORM, di, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Deform the shape of the whole Bitmap with a constant vector of force applied to a constant - * point on the Bitmap. + * Deform the shape of the whole Object with a constant vector of force applied to a constant + * point on the Object. * * @param vector Vector of force. - * @param point Center of the Effect. + * @param center Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long deform(Float3D vector, Float2D point ) + public long deform(Float3D vector, Float2D center ) { Interpolator3D di = new Interpolator3D(); di.setCount(0.5f); @@ -2230,7 +2234,7 @@ public abstract class DistortedObject di.add(new Float3D(0.0f,0.0f,0.0f)); di.add(vector); - return mV.add(EffectNames.DEFORM, di, null, point.x, point.y); + return mV.add(EffectNames.DEFORM, di, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2240,16 +2244,16 @@ public abstract class DistortedObject * Pull all points around the center of the effect towards the center (if degree>=1) or push them * away from the center (degree<=1) * - * @param di 1-dimensional Interpolator which, at any given time, returns a Point1D representing + * @param sink 1-dimensional Interpolator which, at any given time, returns a Point1D representing * the current degree of the effect. * @param region Region that masks the effect of the Sink. - * @param point 2-dimensional Interpolator that, at any given time, returns a Point2D representing + * @param center 2-dimensional Interpolator that, at any given time, returns a Point2D representing * the Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long sink(Interpolator1D di, Float4D region, Interpolator2D point) + public long sink(Interpolator1D sink, Float4D region, Interpolator2D center) { - return mV.add(EffectNames.SINK, di, region, point); + return mV.add(EffectNames.SINK, sink, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2259,15 +2263,15 @@ public abstract class DistortedObject *

* Here the Center stays constant. * - * @param di 1-dimensional Interpolator which, at any given time, returns a Point1D + * @param sink 1-dimensional Interpolator which, at any given time, returns a Point1D * representing the current degree of the effect. * @param region Region that masks the effect of the Sink. - * @param point Center of the Effect. + * @param center Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long sink(Interpolator1D di, Float4D region, Float2D point) + public long sink(Interpolator1D sink, Float4D region, Float2D center) { - return mV.add(EffectNames.SINK, di, region, point.x, point.y); + return mV.add(EffectNames.SINK, sink, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2277,23 +2281,23 @@ public abstract class DistortedObject *

* Here we can only interpolate between 1 and degree. * - * @param degree How much to push or pull. Between 0 and infinity. + * @param sink How much to push or pull. Between 0 and infinity. * @param region Region that masks the effect of the Sink. - * @param p 2-dimensional Interpolator that, at any given time, returns a Point2D representing + * @param center 2-dimensional Interpolator that, at any given time, returns a Point2D representing * the 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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long sink(float degree, Float4D region, Interpolator2D p, int duration, float count) + public long sink(float sink, Float4D region, Interpolator2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); di.setDuration(duration); di.add(new Float1D(1)); - di.add(new Float1D(degree)); + di.add(new Float1D(sink)); - return mV.add(EffectNames.SINK, di, region, p); + return mV.add(EffectNames.SINK, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2301,235 +2305,235 @@ public abstract class DistortedObject * Pull all points around the center of the effect towards the center (if degree>=1) or push them * away from the center (degree<=1). * - * @param degree How much to push or pull. Between 0 and infinity. + * @param sink How much to push or pull. Between 0 and infinity. * @param region Region that masks the effect of the Sink. - * @param point Center of the Effect. + * @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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long sink(float degree, Float4D region, Float2D point, int duration, float count) + public long sink(float sink, Float4D region, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); di.setDuration(duration); di.add(new Float1D(1)); - di.add(new Float1D(degree)); + di.add(new Float1D(sink)); - return mV.add(EffectNames.SINK, di, region, point.x, point.y); + return mV.add(EffectNames.SINK, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Pull all points of the Bitmap towards the center of the Effect (if degree>=1) or push them + * Pull all points of the Object towards the center of the Effect (if degree>=1) or push them * away from the center (degree<=1). * - * @param degree How much to push or pull. Between 0 and infinity. - * @param point Center of the Effect. + * @param sink How much to push or pull. Between 0 and infinity. + * @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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long sink(float degree, Float2D point, int duration, float count) + public long sink(float sink, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); di.setDuration(duration); di.add(new Float1D(1)); - di.add(new Float1D(degree)); + di.add(new Float1D(sink)); - return mV.add(EffectNames.SINK, di, null, point.x, point.y); + return mV.add(EffectNames.SINK, di, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Pull all points of the Bitmap towards the center of the Effect (if degree>=1) or push them + * Pull all points of the Object towards the center of the Effect (if degree>=1) or push them * away from the center (degree<=1). *

* Equivalent to calling the previous method with count=0.5. * - * @param degree How much to push or pull. Between 0 and infinity. - * @param point Center of the Effect. + * @param sink How much to push or pull. Between 0 and infinity. + * @param center Center of the Effect. * @param duration Time, in milliseconds, it takes to do one full interpolation. * @return ID of the effect added, or -1 if we failed to add one. */ - public long sink(float degree, Float2D point, int duration) + public long sink(float sink, Float2D center, int duration) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); di.setDuration(duration); di.add(new Float1D(1)); - di.add(new Float1D(degree)); + di.add(new Float1D(sink)); - return mV.add(EffectNames.SINK, di, null, point.x, point.y); + return mV.add(EffectNames.SINK, di, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Pull all points of the Bitmap towards the center of the Effect (if degree>=1) or push them + * Pull all points of the Object towards the center of the Effect (if degree>=1) or push them * away from the center (degree<=1). *

* Equivalent of calling the previous method with duration=0; i.e. we pull immediately. * - * @param degree How much to push or pull. Between 0 and infinity. - * @param point Center of the Effect. + * @param sink How much to push or pull. Between 0 and infinity. + * @param center Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long sink(float degree, Float2D point) + public long sink(float sink, Float2D center) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); di.setDuration(0); di.add(new Float1D(1)); - di.add(new Float1D(degree)); + di.add(new Float1D(sink)); - return mV.add(EffectNames.SINK, di, null, point.x, point.y); + return mV.add(EffectNames.SINK, di, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// // SWIRL /** - * Rotate part of the Bitmap around the Center of the Effect by a certain angle (as returned by the + * Rotate part of the Object around the Center of the Effect by a certain angle (as returned by the * Interpolator). * - * @param di 1-dimensional Interpolator which, at any given time, returns a Point1D representing + * @param swirl 1-dimensional Interpolator which, at any given time, returns a Point1D representing * the degree of Swirl. * @param region Region that masks the effect of the Swirl. - * @param point 2-dimensional Interpolator that, at any given time, returns a Point2D representing + * @param center 2-dimensional Interpolator that, at any given time, returns a Point2D representing * the Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long swirl(Interpolator1D di, Float4D region, Interpolator2D point) + public long swirl(Interpolator1D swirl, Float4D region, Interpolator2D center) { - return mV.add(EffectNames.SWIRL, di, region, point); + return mV.add(EffectNames.SWIRL, swirl, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Rotate part of the Bitmap around the Center of the Effect by a certain angle (as returned by the + * Rotate part of the Object around the Center of the Effect by a certain angle (as returned by the * Interpolator). *

* Here the Center stays constant. * - * @param di 1-dimensional Interpolator which, at any given time, returns a Point1D representing + * @param swirl 1-dimensional Interpolator which, at any given time, returns a Point1D representing * the degree of Swirl. * @param region Region that masks the effect of the Swirl. - * @param point Center of the Effect. + * @param center Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long swirl(Interpolator1D di, Float4D region, Float2D point) + public long swirl(Interpolator1D swirl, Float4D region, Float2D center) { - return mV.add(EffectNames.SWIRL, di, region, point.x, point.y); + return mV.add(EffectNames.SWIRL, swirl, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Rotate part of the Bitmap around the Center of the Effect by 'degree' angle. + * Rotate part of the Object around the Center of the Effect by 'degree' angle. * - * @param degree Angle of rotation. Unit: degrees. + * @param swirl Angle of rotation. Unit: degrees. * @param region Region that masks the effect of the Swirl. - * @param point 2-dimensional Interpolator that, at any given time, returns a Point2D representing + * @param center 2-dimensional Interpolator that, at any given time, returns a Point2D representing * the Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long swirl(int degree, Float4D region, Interpolator2D point) + public long swirl(int swirl, Float4D region, Interpolator2D center) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); di.setDuration(0); di.add(new Float1D(0)); - di.add(new Float1D(degree)); + di.add(new Float1D(swirl)); - return mV.add(EffectNames.SWIRL, di, region, point); + return mV.add(EffectNames.SWIRL, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Rotate part of the Bitmap around the Center of the Effect by 'degree' angle. + * Rotate part of the Object around the Center of the Effect by 'degree' angle. *

* Here the Center stays constant. * - * @param degree Angle of rotation. Unit: degrees. + * @param swirl Angle of rotation. Unit: degrees. * @param region Region that masks the effect of the Swirl. - * @param point Center of the Effect. + * @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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long swirl(int degree, Float4D region, Float2D point, int duration, float count) + public long swirl(int swirl, Float4D region, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); di.setDuration(duration); di.add(new Float1D(0)); - di.add(new Float1D(degree)); + di.add(new Float1D(swirl)); - return mV.add(EffectNames.SWIRL, di, region, point.x, point.y); + return mV.add(EffectNames.SWIRL, di, region, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Rotate the whole Bitmap around the Center of the Effect by 'degree' angle. + * Rotate the whole Object around the Center of the Effect by 'degree' angle. * - * @param degree Angle of rotation. Unit: degrees. - * @param point Center of the Effect. + * @param swirl Angle of rotation. Unit: degrees. + * @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)} * @return ID of the effect added, or -1 if we failed to add one. */ - public long swirl(int degree, Float2D point, int duration, float count) + public long swirl(int swirl, Float2D center, int duration, float count) { Interpolator1D di = new Interpolator1D(); di.setCount(count); di.setDuration(duration); di.add(new Float1D(0)); - di.add(new Float1D(degree)); + di.add(new Float1D(swirl)); - return mV.add(EffectNames.SWIRL, di, null, point.x, point.y); + return mV.add(EffectNames.SWIRL, di, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Rotate the whole Bitmap around the Center of the Effect by 'degree' angle. + * Rotate the whole Object around the Center of the Effect by 'degree' angle. *

* Equivalent to calling the previous method with count=0.5. * - * @param degree Angle of rotation. Unit: degrees. - * @param point Center of the Effect. + * @param swirl Angle of rotation. Unit: degrees. + * @param center Center of the Effect. * @param duration Time, in milliseconds, it takes to do one full interpolation. * @return ID of the effect added, or -1 if we failed to add one. */ - public long swirl(int degree, Float2D point, int duration) + public long swirl(int swirl, Float2D center, int duration) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); di.setDuration(duration); di.add(new Float1D(0)); - di.add(new Float1D(degree)); + di.add(new Float1D(swirl)); - return mV.add(EffectNames.SWIRL, di, null, point.x, point.y); + return mV.add(EffectNames.SWIRL, di, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Rotate the whole Bitmap around the Center of the Effect by 'degree' angle. + * Rotate the whole Object around the Center of the Effect by 'degree' angle. *

* Equivalent to calling the previous method with duration=0. * - * @param degree Angle of rotation. Unit: degrees. - * @param point Center of the Effect. + * @param swirl Angle of rotation. Unit: degrees. + * @param center Center of the Effect. * @return ID of the effect added, or -1 if we failed to add one. */ - public long swirl(int degree, Float2D point) + public long swirl(int swirl, Float2D center) { Interpolator1D di = new Interpolator1D(); di.setCount(0.5f); di.setDuration(0); di.add(new Float1D(0)); - di.add(new Float1D(degree)); + di.add(new Float1D(swirl)); - return mV.add(EffectNames.SWIRL, di, null, point.x, point.y); + return mV.add(EffectNames.SWIRL, di, null, center); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2542,7 +2546,7 @@ public abstract class DistortedObject /////////////////////////////////////////////////////////////////////////////////////////////////// // SAVE_PNG /** - * Save the current state of the Bitmap that's backing up our DistortedObject to a PNG file. + * Save the current state of the Object that's backing up our DistortedObject to a PNG file. * * @param filename Full path to the file. * @return ID of the effect added, or -1 if we failed to add one. diff --git a/src/main/java/org/distorted/library/EffectQueueFragment.java b/src/main/java/org/distorted/library/EffectQueueFragment.java index 4e6b196..ee2137c 100644 --- a/src/main/java/org/distorted/library/EffectQueueFragment.java +++ b/src/main/java/org/distorted/library/EffectQueueFragment.java @@ -179,15 +179,15 @@ class EffectQueueFragment extends EffectQueue /////////////////////////////////////////////////////////////////////////////////////////////////// - synchronized long add(EffectNames eln, Interpolator inter, Float4D region, float x, float y) + synchronized long add(EffectNames eln, Interpolator inter, Float4D region, Float2D point) { if( mMax[INDEX]>mNumEffects ) { EffectNames.fillWithUnities(eln.ordinal(), mUniforms, NUM_UNIFORMS*mNumEffects); mInterI[mNumEffects] = inter; mInterP[mNumEffects] = null; - mBuf[4*mNumEffects ] = x; - mBuf[4*mNumEffects+1] = y; + mBuf[4*mNumEffects ] = point.x; + mBuf[4*mNumEffects+1] = point.y; mBuf[4*mNumEffects+2] = (region==null || region.z<=0.0f) ? 1000*mObjHalfX : region.z; mBuf[4*mNumEffects+3] = (region==null || region.w<=0.0f) ? 1000*mObjHalfY : region.w; @@ -220,14 +220,14 @@ class EffectQueueFragment extends EffectQueue /////////////////////////////////////////////////////////////////////////////////////////////////// - synchronized long add(EffectNames eln, Interpolator1D inter, Float3D c, Float4D region, float x, float y) + synchronized long add(EffectNames eln, Interpolator1D inter, Float3D c, Float4D region, Float2D point) { if( mMax[INDEX]>mNumEffects ) { mInterI[mNumEffects] = inter; mInterP[mNumEffects] = null; - mBuf[4*mNumEffects ] = x; - mBuf[4*mNumEffects+1] = y; + mBuf[4*mNumEffects ] = point.x; + mBuf[4*mNumEffects+1] = point.y; mBuf[4*mNumEffects+2] = (region==null || region.z<=0.0f) ? 1000*mObjHalfX : region.z; mBuf[4*mNumEffects+3] = (region==null || region.w<=0.0f) ? 1000*mObjHalfY : region.w; @@ -265,14 +265,14 @@ class EffectQueueFragment extends EffectQueue /////////////////////////////////////////////////////////////////////////////////////////////////// - synchronized long add(EffectNames eln, float t, Float3D c, Float4D region, float x, float y) + synchronized long add(EffectNames eln, float t, Float3D c, Float4D region, Float2D point) { if( mMax[INDEX]>mNumEffects ) { mInterI[mNumEffects] = null; mInterP[mNumEffects] = null; - mBuf[4*mNumEffects ] = x; - mBuf[4*mNumEffects+1] = y; + mBuf[4*mNumEffects ] = point.x; + mBuf[4*mNumEffects+1] = point.y; mBuf[4*mNumEffects+2] = (region==null || region.z<=0.0f) ? 1000*mObjHalfX : region.z; mBuf[4*mNumEffects+3] = (region==null || region.w<=0.0f) ? 1000*mObjHalfY : region.w; diff --git a/src/main/java/org/distorted/library/EffectQueueMatrix.java b/src/main/java/org/distorted/library/EffectQueueMatrix.java index 665bb2f..6bb0be8 100644 --- a/src/main/java/org/distorted/library/EffectQueueMatrix.java +++ b/src/main/java/org/distorted/library/EffectQueueMatrix.java @@ -237,6 +237,21 @@ class EffectQueueMatrix extends EffectQueue GLES20.glUniformMatrix4fv(mMVPMatrixH, 1, false, mMVPMatrix, 0); } +/////////////////////////////////////////////////////////////////////////////////////////////////// + + synchronized long add(EffectNames eln, Interpolator i) + { + if( mMax[INDEX]>mNumEffects ) + { + mInterP[mNumEffects] = null; + mInterI[mNumEffects] = i; + + return addBase(eln); + } + + return -1; + } + /////////////////////////////////////////////////////////////////////////////////////////////////// synchronized long add(EffectNames eln, Interpolator3D p, Interpolator i) @@ -254,16 +269,16 @@ class EffectQueueMatrix extends EffectQueue /////////////////////////////////////////////////////////////////////////////////////////////////// - synchronized long add(EffectNames eln, float x, float y, float z, Interpolator i) + synchronized long add(EffectNames eln, Float3D p, Interpolator i) { if( mMax[INDEX]>mNumEffects ) { mInterP[mNumEffects] = null; mInterI[mNumEffects] = i; - mUniforms[NUM_UNIFORMS*mNumEffects ] = x; - mUniforms[NUM_UNIFORMS*mNumEffects+1] = y; - mUniforms[NUM_UNIFORMS*mNumEffects+2] = z; + mUniforms[NUM_UNIFORMS*mNumEffects ] = p.x; + mUniforms[NUM_UNIFORMS*mNumEffects+1] = p.y; + mUniforms[NUM_UNIFORMS*mNumEffects+2] = p.z; return addBase(eln); } @@ -273,16 +288,16 @@ class EffectQueueMatrix extends EffectQueue /////////////////////////////////////////////////////////////////////////////////////////////////// - synchronized long add(EffectNames eln, float x, float y, float z, Interpolator1D i, float aX, float aY, float aZ) + synchronized long add(EffectNames eln, Float3D p, Interpolator1D i, float aX, float aY, float aZ) { if( mMax[INDEX]>mNumEffects ) { mInterP[mNumEffects] = null; mInterI[mNumEffects] = i; - mUniforms[NUM_UNIFORMS*mNumEffects ] = x; - mUniforms[NUM_UNIFORMS*mNumEffects+1] = y; - mUniforms[NUM_UNIFORMS*mNumEffects+2] = z; + mUniforms[NUM_UNIFORMS*mNumEffects ] = p.x; + mUniforms[NUM_UNIFORMS*mNumEffects+1] = p.y; + mUniforms[NUM_UNIFORMS*mNumEffects+2] = p.z; mUniforms[NUM_UNIFORMS*mNumEffects+4] = aX; mUniforms[NUM_UNIFORMS*mNumEffects+5] = aY; @@ -315,16 +330,16 @@ class EffectQueueMatrix extends EffectQueue /////////////////////////////////////////////////////////////////////////////////////////////////// - synchronized long add(EffectNames eln, float x, float y, float z, float aA, float aX, float aY, float aZ) + synchronized long add(EffectNames eln, Float3D p, float aA, float aX, float aY, float aZ) { if( mMax[INDEX]>mNumEffects ) { mInterP[mNumEffects] = null; mInterI[mNumEffects] = null; - mUniforms[NUM_UNIFORMS*mNumEffects ] = x; - mUniforms[NUM_UNIFORMS*mNumEffects+1] = y; - mUniforms[NUM_UNIFORMS*mNumEffects+2] = z; + mUniforms[NUM_UNIFORMS*mNumEffects ] = p.x; + mUniforms[NUM_UNIFORMS*mNumEffects+1] = p.y; + mUniforms[NUM_UNIFORMS*mNumEffects+2] = p.z; mUniforms[NUM_UNIFORMS*mNumEffects+3] = aA; mUniforms[NUM_UNIFORMS*mNumEffects+4] = aX; mUniforms[NUM_UNIFORMS*mNumEffects+5] = aY; diff --git a/src/main/java/org/distorted/library/EffectQueueVertex.java b/src/main/java/org/distorted/library/EffectQueueVertex.java index 4507a23..4322ad9 100644 --- a/src/main/java/org/distorted/library/EffectQueueVertex.java +++ b/src/main/java/org/distorted/library/EffectQueueVertex.java @@ -165,7 +165,7 @@ class EffectQueueVertex extends EffectQueue /////////////////////////////////////////////////////////////////////////////////////////////////// - synchronized long add(EffectNames eln, Interpolator inter, Float4D region, float x, float y) + synchronized long add(EffectNames eln, Interpolator inter, Float4D region, Float2D point) { if( mMax[INDEX]>mNumEffects ) { @@ -173,8 +173,8 @@ class EffectQueueVertex extends EffectQueue mInterI[mNumEffects] = inter; mInterP[mNumEffects] = null; - mUniforms[NUM_UNIFORMS*mNumEffects+7] = x-mObjHalfX; - mUniforms[NUM_UNIFORMS*mNumEffects+8] =-y+mObjHalfY; + mUniforms[NUM_UNIFORMS*mNumEffects+7] = point.x-mObjHalfX; + mUniforms[NUM_UNIFORMS*mNumEffects+8] =-point.y+mObjHalfY; return addPriv(eln,region); } @@ -184,7 +184,7 @@ class EffectQueueVertex extends EffectQueue /////////////////////////////////////////////////////////////////////////////////////////////////// - synchronized long add(EffectNames eln, float v1, float v2, float v3, Float4D region, float x, float y) + synchronized long add(EffectNames eln, float v1, float v2, float v3, Float4D region, Float2D point) { if( mMax[INDEX]>mNumEffects ) { @@ -195,8 +195,8 @@ class EffectQueueVertex extends EffectQueue mInterI[mNumEffects] = null; mInterP[mNumEffects] = null; - mUniforms[NUM_UNIFORMS*mNumEffects+7] = x-mObjHalfX; - mUniforms[NUM_UNIFORMS*mNumEffects+8] =-y+mObjHalfY; + mUniforms[NUM_UNIFORMS*mNumEffects+7] = point.x-mObjHalfX; + mUniforms[NUM_UNIFORMS*mNumEffects+8] =-point.y+mObjHalfY; return addPriv(eln,region); } diff --git a/src/main/java/org/distorted/library/Interpolator.java b/src/main/java/org/distorted/library/Interpolator.java index f213a3b..69cfa5b 100644 --- a/src/main/java/org/distorted/library/Interpolator.java +++ b/src/main/java/org/distorted/library/Interpolator.java @@ -1,3 +1,22 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2016 Leszek Koltunski // +// // +// This file is part of Distorted. // +// // +// Distorted is free software: you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 2 of the License, or // +// (at your option) any later version. // +// // +// Distorted is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with Distorted. If not, see . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + package org.distorted.library; import java.util.Random; @@ -67,7 +86,7 @@ public abstract class Interpolator /////////////////////////////////////////////////////////////////////////////////////////////////// - void interpolateMain(float[] buffer, int offset, long currentDuration) + public void interpolateMain(float[] buffer, int offset, long currentDuration) { if( mDuration<=0.0f ) { @@ -86,7 +105,7 @@ public abstract class Interpolator /////////////////////////////////////////////////////////////////////////////////////////////////// - boolean interpolateMain(float[] buffer, int offset, long currentDuration, long step) + public boolean interpolateMain(float[] buffer, int offset, long currentDuration, long step) { if( mDuration<=0.0f ) {