/ - Diff - Distorted Android

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       Effect(EffectType type, EffectName name, int dimension, boolean center, boolean region, float[] unity)
       Effect(EffectName name)
+        {
         mID        = (mNextID++)<<EffectType.LENGTH + type.ordinal();
         mName      = name;
         mType      = type;
         mDimension = dimension;
         mSupportsC = center;
         mSupportsR = region;
         mType      = name.getType();
         mDimension = name.getDimension();
         mSupportsC = name.supportsCenter();
         mSupportsR = name.supportsRegion();
         int n = name.ordinal();
         int l = unity.length;
         float[] u = name.getUnity();
         int l = name.getUnity().length;
         for(int i=0; i<l; i++)
+          {
           mUnity[n*MAX_UNITY_DIM+i] = unity[i];
           mUnity[n*MAX_UNITY_DIM+i] = u[i];
+          }
         mUnityDim[n] = l;
         mID = (mNextID++)<<EffectType.LENGTH + mType.ordinal();
+        }
+      }

      * Names of Effects one can add to the DistortedEffects queues.
      * <p>
      * Effect's 'Type' is one of the constants defined in {@link EffectType}.
      * </p>
      * <p>
      * Effect's 'Uniforms' are a vector of 7 (matrix effects) 12 (vertex) or 8 (fragment) floats, which
      * together form full information how to compute a given effect.
      * Typically, some of those values will be Interpolated in CPU (by one of the 'EffectQueueX.compute()'
      * methods) and the effect of such Interpolation sent to the Shaders.
      * </p>
      * <p>
      * Effect's 'Unity' is such a particular vector of its 'interpolated values' which makes the
      * effect NULL. For example, if the effect is 'MOVE' by a 3-dimensional vector, then a 'NULL
      * MOVE' is a MOVE by vector (0,0,0), thus (0,0,0) is the unity of the MOVE effect.
      * This is used by the EffectQueue classes to decide if the final form of the Effect is NULL - and
      * thus if it can safely be removed from Effect Queues without affecting the visual in any way.
      * </p>
      */
     public enum EffectName
+      {
       // EFFECT NAME /////// EFFECT TYPE
       // MATRIX EFFECTS
       ROTATE           ( EffectType.MATRIX ),
       QUATERNION       ( EffectType.MATRIX ),
       MOVE             ( EffectType.MATRIX ),
       SCALE            ( EffectType.MATRIX ),
       SHEAR            ( EffectType.MATRIX ),
       // add new Matrix effects here...
       // VERTEX EFFECTS
       DISTORT          ( EffectType.VERTEX ),
       DEFORM           ( EffectType.VERTEX ),
       SINK             ( EffectType.VERTEX ),
       PINCH            ( EffectType.VERTEX ),
       SWIRL            ( EffectType.VERTEX ),
       WAVE             ( EffectType.VERTEX ),
       // add new Vertex Effects here...
       // FRAGMENT EFFECTS
       ALPHA            ( EffectType.FRAGMENT ),
       SMOOTH_ALPHA     ( EffectType.FRAGMENT ),
       CHROMA           ( EffectType.FRAGMENT ),
       SMOOTH_CHROMA    ( EffectType.FRAGMENT ),
       BRIGHTNESS       ( EffectType.FRAGMENT ),
       SMOOTH_BRIGHTNESS( EffectType.FRAGMENT ),
       SATURATION       ( EffectType.FRAGMENT ),
       SMOOTH_SATURATION( EffectType.FRAGMENT ),
       CONTRAST         ( EffectType.FRAGMENT ),
       SMOOTH_CONTRAST  ( EffectType.FRAGMENT ),
       // add new Fragment effects here...
       // POSTPROCESSING EFFECTS.
       BLUR             ( EffectType.POSTPROCESS ),
       GLOW             ( EffectType.POSTPROCESS );
       // add new Postprocess effects here...
       // EFFECT NAME /////// EFFECT TYPE /////// EFFECT UNITY //////////// DIM // REGION // CENTER
       ROTATE           ( EffectType.MATRIX  ,   new float[] {0.0f}           , 4, false, true  ),
       QUATERNION       ( EffectType.MATRIX  ,   new float[] {0.0f,0.0f,0.0f} , 4, false, true  ),
       MOVE             ( EffectType.MATRIX  ,   new float[] {0.0f,0.0f,0.0f} , 3, false, false ),
       SCALE            ( EffectType.MATRIX  ,   new float[] {1.0f,1.0f,1.0f} , 3, false, false ),
       SHEAR            ( EffectType.MATRIX  ,   new float[] {0.0f,0.0f,0.0f} , 3, false, true  ),
       DISTORT          ( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 3, true , true  ),
       DEFORM           ( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 3, true , true  ),
       SINK             ( EffectType.VERTEX  ,   new float[] {1.0f}           , 1, true , true  ),
       PINCH            ( EffectType.VERTEX  ,   new float[] {1.0f}           , 2, true , true  ),
       SWIRL            ( EffectType.VERTEX  ,   new float[] {0.0f}           , 1, true , true  ),
       WAVE             ( EffectType.VERTEX  ,   new float[] {0.0f}           , 5, true , true  ),
       ALPHA            ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false ),
       SMOOTH_ALPHA     ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false ),
       CHROMA           ( EffectType.FRAGMENT,   new float[] {0.0f}           , 4, true , false ),
       SMOOTH_CHROMA    ( EffectType.FRAGMENT,   new float[] {0.0f}           , 4, true , false ),
       BRIGHTNESS       ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false ),
       SMOOTH_BRIGHTNESS( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false ),
       SATURATION       ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false ),
       SMOOTH_SATURATION( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false ),
       CONTRAST         ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false ),
       SMOOTH_CONTRAST  ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false ),
       BLUR             ( EffectType.POSTPROCESS,new float[] {0.0f}           , 1, false, false ),
       GLOW             ( EffectType.POSTPROCESS,new float[] {0.0f}           , 1, false, false );
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private static final int MAXDIM = 4;  // maximum supported dimension of effect's unity
       public static final int LENGTH = values().length;
       private final EffectType type;
       private final float[] unity;
       private final int dimension;
       private final boolean supportsR;
       private final boolean supportsC;
       private static final float[] unities;
       private static final int[] unityDimensions;
       private static final int[] dimensions;
       private static final boolean[] supportsRegion;
       private static final boolean[] supportsCenter;
       private static final EffectName[] names;  // copy the values() to a local variable so that we
                                                 // don't have to keep recreating the array every time
       static
+        {
         int i=0;
         names = new EffectName[LENGTH];
         unities         = new float[MAXDIM*LENGTH];
         unityDimensions = new int[LENGTH];
         dimensions      = new int[LENGTH];
         supportsRegion  = new boolean[LENGTH];
         supportsCenter  = new boolean[LENGTH];
         names           = new EffectName[LENGTH];
         for(EffectName name: EffectName.values())
+          {
           names[i++] = name;
           unityDimensions[i] = (name.unity==null ? 0 : name.unity.length);
           dimensions[i]      = name.dimension;
           supportsRegion[i]  = name.supportsR;
           supportsCenter[i]  = name.supportsC;
           names[i]           = name;
           switch(unityDimensions[i])
+            {
             case 4: unities[MAXDIM*i+3] = name.unity[3];
             case 3: unities[MAXDIM*i+2] = name.unity[2];
             case 2: unities[MAXDIM*i+1] = name.unity[1];
             case 1: unities[MAXDIM*i  ] = name.unity[0];
             case 0: break;
+            }
           i++;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       EffectName(EffectType type)
       float[] getUnity()
+        {
         return unity;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       EffectName(EffectType type, float[] unity, int dimension, boolean supportsR, boolean supportsC)
+        {
         this.type = type;
         this.type      = type;
         this.unity     = unity;
         this.dimension = dimension;
         this.supportsR = supportsR;
         this.supportsC = supportsC;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        {
         return names[ordinal];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns the dimension of an Effect (in other words, the number of interpolated values).
      * @return dimension of the Effect.
      */
       public int getDimension() { return dimensions[ordinal()]; }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Do we support being masked by a Region?
      * @return true if the Effect supports being masked with a Region.
      */
       public boolean supportsRegion() { return supportsRegion[ordinal()]; }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Does this Effect have a center?
      * @return true if the Effect has a center.
      */
       public boolean supportsCenter() { return supportsCenter[ordinal()]; }
+      }

src/main/java/org/distorted/library/effect/FragmentEffect.java
39	39
40	40	///////////////////////////////////////////////////////////////////////////////////////////////////
41	41
42		public FragmentEffect(EffectName name, int dimension, boolean center, boolean region, float[] unity)
	42	public FragmentEffect(EffectName name)
43	43	{
44		super(EffectType.FRAGMENT,name,dimension,center,region,unity);
	44	super(name);
45	45	}
46	46	}

     public class FragmentEffectAlpha extends FragmentEffect
+      {
       private static final float[] UNITIES         = new float[] {1.0f};
       private static final int     DIMENSION       = 1;
       private static final boolean SUPPORTS_CENTER = false;
       private static final boolean SUPPORTS_REGION = true;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
-...
      */
       public FragmentEffectAlpha(Data1D alpha, Data4D region, boolean smooth)
+        {
         super(smooth? EffectName.SMOOTH_ALPHA:EffectName.ALPHA ,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(smooth? EffectName.SMOOTH_ALPHA:EffectName.ALPHA);
         if( alpha instanceof Dynamic1D )
+          {
-...
      */
       public FragmentEffectAlpha(Data1D alpha)
+        {
         super(EffectName.ALPHA,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.ALPHA);
         if( alpha instanceof Dynamic1D )
+          {

     public class FragmentEffectBrightness extends FragmentEffect
+      {
       private static final float[] UNITIES         = new float[] {1.0f};
       private static final int DIMENSION           = 1;
       private static final boolean SUPPORTS_CENTER = false;
       private static final boolean SUPPORTS_REGION = true;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
-...
      */
       public FragmentEffectBrightness(Data1D brightness, Data4D region, boolean smooth)
+        {
         super(smooth?EffectName.SMOOTH_BRIGHTNESS:EffectName.BRIGHTNESS ,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(smooth?EffectName.SMOOTH_BRIGHTNESS:EffectName.BRIGHTNESS);
         if( brightness instanceof Dynamic1D )
+          {
-...
      */
       public FragmentEffectBrightness(Data1D brightness)
+        {
         super(EffectName.BRIGHTNESS,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.BRIGHTNESS);
         if( brightness instanceof Dynamic1D )
+          {

     public class FragmentEffectChroma extends FragmentEffect
+      {
       private static final float[] UNITIES         = new float[] {0.0f};
       private static final int DIMENSION           = 4;
       private static final boolean SUPPORTS_CENTER = false;
       private static final boolean SUPPORTS_REGION = true;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
-...
      */
       public FragmentEffectChroma(Data1D blend, Data3D color, Data4D region, boolean smooth)
+        {
         super(smooth?EffectName.SMOOTH_CHROMA:EffectName.CHROMA,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(smooth?EffectName.SMOOTH_CHROMA:EffectName.CHROMA);
         if( blend instanceof Dynamic1D )
+          {
-...
      */
       public FragmentEffectChroma(Data1D blend, Data3D color)
+        {
         super(EffectName.CHROMA,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.CHROMA);
         if( blend instanceof Dynamic1D )
+          {

     public class FragmentEffectContrast extends FragmentEffect
+      {
       private static final float[] UNITIES         = new float[] {1.0f};
       private static final int DIMENSION           = 1;
       private static final boolean SUPPORTS_CENTER = false;
       private static final boolean SUPPORTS_REGION = true;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
-...
      */
       public FragmentEffectContrast(Data1D contrast, Data4D region, boolean smooth)
+        {
         super(smooth?EffectName.SMOOTH_CONTRAST:EffectName.CONTRAST,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(smooth?EffectName.SMOOTH_CONTRAST:EffectName.CONTRAST);
         if( contrast instanceof Dynamic1D )
+          {
-...
      */
       public FragmentEffectContrast(Data1D contrast)
+        {
         super(EffectName.CONTRAST,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.CONTRAST);
         if( contrast instanceof Dynamic1D )
+          {

     public class FragmentEffectSaturation extends FragmentEffect
+      {
       private static final float[] UNITIES         = new float[] {1.0f};
       private static final int DIMENSION           = 1;
       private static final boolean SUPPORTS_CENTER = false;
       private static final boolean SUPPORTS_REGION = true;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
-...
      */
       public FragmentEffectSaturation(Data1D saturation, Data4D region, boolean smooth)
+        {
         super(smooth?EffectName.SMOOTH_SATURATION:EffectName.SATURATION ,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(smooth?EffectName.SMOOTH_SATURATION:EffectName.SATURATION);
         if( saturation instanceof Dynamic1D )
+          {
-...
      */
       public FragmentEffectSaturation(Data1D saturation)
+        {
         super(EffectName.SATURATION,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.SATURATION);
         if( saturation instanceof Dynamic1D )
+          {

src/main/java/org/distorted/library/effect/MatrixEffect.java
36	36
37	37	///////////////////////////////////////////////////////////////////////////////////////////////////
38	38
39		public MatrixEffect(EffectName name, int dimension, boolean center, boolean region, float[] unity)
	39	public MatrixEffect(EffectName name)
40	40	{
41		super(EffectType.MATRIX,name,dimension,center,region,unity);
	41	super(name);
42	42	}
43	43	}

     public class MatrixEffectMove extends MatrixEffect
+      {
       private static final float[] UNITIES         = new float[]{0.0f, 0.0f, 0.0f};
       private static final int DIMENSION           = 3;
       private static final boolean SUPPORTS_CENTER = false;
       private static final boolean SUPPORTS_REGION = false;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Moves the Object by a (possibly changing in time) vector.
-...
      */
       public MatrixEffectMove(Data3D vector)
+        {
         super(EffectName.MOVE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.MOVE);
         if( vector instanceof Static3D)
+          {

     public class MatrixEffectQuaternion extends MatrixEffect
+      {
       private static final float[] UNITIES         = new float[]{0.0f, 0.0f, 0.0f};
       private static final int DIMENSION           = 4;
       private static final boolean SUPPORTS_CENTER = true;
       private static final boolean SUPPORTS_REGION = false;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object by quaternion.
-...
      */
       public MatrixEffectQuaternion(Data4D quaternion, Data3D center )
+        {
         super(EffectName.QUATERNION,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.QUATERNION);
         if( quaternion instanceof Static4D)
+          {

     public class MatrixEffectRotate extends MatrixEffect
+      {
       private static final float[] UNITIES         = new float[]{0.0f};
       private static final int DIMENSION           = 4;
       private static final boolean SUPPORTS_CENTER = true;
       private static final boolean SUPPORTS_REGION = false;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object by 'angle' degrees around the center.
-...
      */
       public MatrixEffectRotate(Data1D angle, Static3D axis, Data3D center)
+        {
         super(EffectName.ROTATE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.ROTATE);
         if( angle instanceof Static1D )
+          {
-...
      */
       public MatrixEffectRotate(Data4D angleaxis, Data3D center)
+        {
         super(EffectName.ROTATE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.ROTATE);
         if( angleaxis instanceof Static4D)
+          {

     public class MatrixEffectScale extends MatrixEffect
+      {
       private static final float[] UNITIES         = new float[] {1.0f,1.0f,1.0f};
       private static final int DIMENSION           = 3;
       private static final boolean SUPPORTS_CENTER = false;
       private static final boolean SUPPORTS_REGION = false;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Scales the Object by (possibly changing in time) 3D scale factors.
-...
      */
       public MatrixEffectScale(Data3D scale)
+        {
         super(EffectName.SCALE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.SCALE);
         if( scale instanceof Static3D)
+          {
-...
      */
       public MatrixEffectScale(float scale)
+        {
         super(EffectName.SCALE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.SCALE);
         mStatic0 = new Static3D(scale,scale,scale);
+        }

     public class MatrixEffectShear extends MatrixEffect
+      {
       private static final float[] UNITIES         = new float[] {0.0f,0.0f,0.0f};
       private static final int DIMENSION           = 3;
       private static final boolean SUPPORTS_CENTER = true;
       private static final boolean SUPPORTS_REGION = false;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Shears the Object.
-...
      */
       public MatrixEffectShear(Data3D shear, Data3D center)
+        {
         super(EffectName.SHEAR,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.SHEAR);
         if( shear instanceof Static3D)
+          {

src/main/java/org/distorted/library/effect/PostprocessEffect.java
35	35
36	36	///////////////////////////////////////////////////////////////////////////////////////////////////
37	37
38		public PostprocessEffect(EffectName name, int dimension, boolean center, boolean region, float[] unity)
	38	public PostprocessEffect(EffectName name)
39	39	{
40		super(EffectType.POSTPROCESS,name,dimension,center,region,unity);
	40	super(name);
41	41	}
42	42	}

     public class PostprocessEffectBlur extends PostprocessEffect
+      {
       private static final float[] UNITIES         = new float[] {0.0f};
       private static final int DIMENSION           = 1;
       private static final boolean SUPPORTS_CENTER = false;
       private static final boolean SUPPORTS_REGION = false;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Blur the object.
-...
      */
       public PostprocessEffectBlur(Data1D radius)
+        {
         super(EffectName.BLUR,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.BLUR);
         if( radius instanceof Dynamic1D)
+          {

     public class PostprocessEffectGlow extends PostprocessEffect
+      {
       private static final float[] UNITIES         = new float[] {0.0f};
       private static final int DIMENSION           = 5;
       private static final boolean SUPPORTS_CENTER = false;
       private static final boolean SUPPORTS_REGION = false;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Make the object glow with a specific color and a halo of specific radius.
-...
      */
       public PostprocessEffectGlow(Data1D radius, Data4D color)
+        {
         super(EffectName.GLOW,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.GLOW);
         if( radius instanceof Dynamic1D)
+          {

src/main/java/org/distorted/library/effect/VertexEffect.java
43	43
44	44	///////////////////////////////////////////////////////////////////////////////////////////////////
45	45
46		public VertexEffect(EffectName name, int dimension, boolean center, boolean region, float[] unity)
	46	public VertexEffect(EffectName name)
47	47	{
48		super(EffectType.VERTEX,name,dimension,center,region,unity);
	48	super(name);
49	49	}
50	50	}

     public class VertexEffectDeform extends VertexEffect
+      {
       private static final float[] UNITIES         = new float[] {0.0f,0.0f,0.0f};
       private static final int DIMENSION           = 3;
       private static final boolean SUPPORTS_CENTER = true;
       private static final boolean SUPPORTS_REGION = true;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Deform the shape of the whole Object with a (possibly changing in time) vector of force applied to
-...
      */
       public VertexEffectDeform(Data3D vector, Data3D center, Data4D region)
+        {
         super(EffectName.DEFORM,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.DEFORM);
         if( vector instanceof Dynamic3D )
+          {
-...
      */
       public VertexEffectDeform(Data3D vector, Data3D center)
+        {
         super(EffectName.DEFORM,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.DEFORM);
         if( vector instanceof Dynamic3D )
+          {

     public class VertexEffectDistort extends VertexEffect
+      {
       private static final float[] UNITIES         = new float[] {0.0f,0.0f,0.0f};
       private static final int DIMENSION           = 3;
       private static final boolean SUPPORTS_CENTER = true;
       private static final boolean SUPPORTS_REGION = true;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Distort a (possibly changing in time) part of the Object by a (possibly changing in time) vector of force.
-...
      */
       public VertexEffectDistort(Data3D vector, Data3D center, Data4D region)
+        {
         super(EffectName.DISTORT,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.DISTORT);
         if( vector instanceof Dynamic3D )
+          {
-...
      */
       public VertexEffectDistort(Data3D vector, Data3D center)
+        {
         super(EffectName.DISTORT,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.DISTORT);
         if( vector instanceof Dynamic3D )
+          {

     public class VertexEffectPinch extends VertexEffect
+      {
       private static final float[] UNITIES         = new float[] {1.0f};
       private static final int     DIMENSION       = 2;
       private static final boolean SUPPORTS_CENTER = true;
       private static final boolean SUPPORTS_REGION = true;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Pull all points around the center of the Effect towards a line passing through the center
-...
      */
       public VertexEffectPinch(Data2D pinch, Data3D center, Data4D region)
+        {
         super(EffectName.PINCH,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.PINCH);
         if( pinch instanceof Dynamic2D)
+          {
-...
      */
       public VertexEffectPinch(Data2D pinch, Data3D center)
+        {
         super(EffectName.PINCH,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.PINCH);
         if( pinch instanceof Dynamic2D)
+          {

     public class VertexEffectSink extends VertexEffect
+      {
       private static final float[] UNITIES         = new float[] {1.0f};
       private static final int     DIMENSION       = 1;
       private static final boolean SUPPORTS_CENTER = true;
       private static final boolean SUPPORTS_REGION = true;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Pull all points around the center of the Effect towards the center (if degree>=1) or push them
-...
      */
       public VertexEffectSink(Data1D sink, Data3D center, Data4D region)
+        {
         super(EffectName.SINK,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.SINK);
         if( sink instanceof Dynamic1D)
+          {
-...
      */
       public VertexEffectSink(Data1D sink, Data3D center)
+        {
         super(EffectName.SINK,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.SINK);
         if( sink instanceof Dynamic1D)
+          {

     public class VertexEffectSwirl extends VertexEffect
+      {
       private static final float[] UNITIES         = new float[] {0.0f};
       private static final int     DIMENSION       = 1;
       private static final boolean SUPPORTS_CENTER = true;
       private static final boolean SUPPORTS_REGION = true;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotate part of the Object around the Center of the Effect by a certain angle.
-...
      */
       public VertexEffectSwirl(Data1D swirl, Data3D center, Data4D region)
+        {
         super(EffectName.SWIRL,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.SWIRL);
         if( swirl instanceof Dynamic1D)
+          {
-...
      */
       public VertexEffectSwirl(Data1D swirl, Data3D center)
+        {
         super(EffectName.SWIRL,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.SWIRL);
         if( swirl instanceof Dynamic1D)
+          {

     public class VertexEffectWave extends VertexEffect
+      {
       private static final float[] UNITIES         = new float[] {0.0f};
       private static final int     DIMENSION       = 5;
       private static final boolean SUPPORTS_CENTER = true;
       private static final boolean SUPPORTS_REGION = true;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Directional, sinusoidal wave effect.
-...
      */
       public VertexEffectWave(Data5D wave, Data3D center)
+        {
         super(EffectName.WAVE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.WAVE);
         if( wave instanceof Dynamic5D)
+          {
-...
      */
       public VertexEffectWave(Data5D wave, Data3D center, Data4D region)
+        {
         super(EffectName.WAVE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
         super(EffectName.WAVE);
         if( wave instanceof Dynamic5D)
+          {

Project

General

Profile

Distorted Android

Revision 9d0d8530

Added by Leszek Koltunski over 8 years ago