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

« Previous | Next »

Revision 6bb59aad

Added by Leszek Koltunski almost 7 years ago

ID 6bb59aad4f6f04f04ca6e6ff22be8ad86b31b252
Parent 15aa7d94
Child 02a4ac20

Progress with support for Effect classes.

     import org.distorted.library.program.LinkingException;
     import org.distorted.library.program.VertexCompilationException;
     import org.distorted.library.program.VertexUniformsException;
     import org.distorted.library.type.Data1D;
     import org.distorted.library.type.Data2D;
     import org.distorted.library.type.Data3D;
     import org.distorted.library.type.Data4D;
     import org.distorted.library.type.Data5D;
     import org.distorted.library.type.Static3D;
     import java.io.InputStream;
     import java.nio.ByteBuffer;
     import java.nio.ByteOrder;
     import java.nio.FloatBuffer;
     import java.util.ArrayList;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
-...
       /// MAIN PROGRAM ///
       private static DistortedProgram mMainProgram;
       private static int mMainTextureH;
       private static boolean[] mEffectEnabled = new boolean[EffectNames.size()];
       static
+        {
         int len = EffectNames.size();
         for(int i=0; i<len; i++)
+          {
           mEffectEnabled[i] = false;
+          }
+        }
       private static ArrayList<Effect> mEnabledEffects = new ArrayList<>();
       /// BLIT PROGRAM ///
       private static DistortedProgram mBlitProgram;
-...
         String mainVertHeader= Distorted.GLSL_VERSION;
         String mainFragHeader= Distorted.GLSL_VERSION;
         EffectNames name;
         EffectTypes type;
         boolean foundF = false;
         boolean foundV = false;
         int type, effects = mEnabledEffects.size();
         Effect effect;
         for(int i=0; i<mEffectEnabled.length; i++)
         for(int i=0; i<effects; i++)
+          {
           if( mEffectEnabled[i] )
           effect = mEnabledEffects.remove(0);
           type   = effect.getType();
           if( type == Effect.VERTEX )
+            {
             mainVertHeader += ("#define "+effect.getString()+" "+effect.getName()+"\n");
             foundV = true;
+            }
           else if( type == Effect.FRAGMENT )
+            {
             name = EffectNames.getName(i);
             type = EffectNames.getType(i);
             if( type == EffectTypes.VERTEX )
+              {
               mainVertHeader += ("#define "+name.name()+" "+name.ordinal()+"\n");
               foundV = true;
+              }
             else if( type == EffectTypes.FRAGMENT )
+              {
               mainFragHeader += ("#define "+name.name()+" "+name.ordinal()+"\n");
               foundF = true;
+              }
             mainFragHeader += ("#define "+effect.getString()+" "+effect.getName()+"\n");
             foundF = true;
+            }
+          }
-...
       static void onDestroy()
+        {
         mNextID = 0;
         int len = EffectNames.size();
         for(int i=0; i<len; i++)
+          {
           mEffectEnabled[i] = false;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     /**
      * Aborts all Effects of a given type, for example all MATRIX Effects.
+     *
      * @param type one of the constants defined in {@link EffectTypes}
      * @param type one of the constants defined in {@link Effect}
      * @return Number of effects aborted.
      */
       public int abortEffects(EffectTypes type)
       public int abortByType(int type)
+        {
         switch(type)
+          {
           case MATRIX     : return mM.abortAll(true);
           case VERTEX     : return mV.abortAll(true);
           case FRAGMENT   : return mF.abortAll(true);
           default         : return 0;
           case Effect.MATRIX     : return mM.abortAll(true);
           case Effect.VERTEX     : return mV.abortAll(true);
           case Effect.FRAGMENT   : return mF.abortAll(true);
       //  case Effect.POSTPROCESS: return mP.abortAll(true);
           default                : return 0;
+          }
+        }
-...
     /**
      * Aborts a single Effect.
+     *
      * @param id ID of the Effect we want to abort.
      * @param effect the Effect we want to abort.
      * @return number of Effects aborted. Always either 0 or 1.
      */
       public int abortEffect(long id)
       public int abortEffect(Effect effect)
+        {
         int type = (int)(id&Effect.MASK);
         if( type==Effect.MATRIX   ) return mM.removeByID(id>>Effect.LENGTH);
         if( type==Effect.VERTEX   ) return mV.removeByID(id>>Effect.LENGTH);
         if( type==Effect.FRAGMENT ) return mF.removeByID(id>>Effect.LENGTH);
         return 0;
         switch(effect.getType())
+          {
           case Effect.MATRIX     : return mM.removeEffect(effect);
           case Effect.VERTEX     : return mV.removeEffect(effect);
           case Effect.FRAGMENT   : return mF.removeEffect(effect);
       //  case Effect.POSTPROCESS: return mP.removeEffect(effect);
           default                : return 0;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Abort all Effects of a given name, for example all rotations.
+     *
      * @param name one of the constants defined in {@link EffectNames}
      * @param name one of the constants defined in
      *             {@link org.distorted.library.effect.MatrixEffect},
      *             {@link org.distorted.library.effect.VertexEffect},
      *             {@link org.distorted.library.effect.FragmentEffect} or
      *             {@link org.distorted.library.effect.PostprocessEffect}
      * @return number of Effects aborted.
      */
       public int abortEffects(EffectNames name)
       public int abortByName(int name)
+        {
         switch(name.getType())
         switch(Effect.getType(name))
+          {
           case MATRIX     : return mM.removeByType(name);
           case VERTEX     : return mV.removeByType(name);
           case FRAGMENT   : return mF.removeByType(name);
           default         : return 0;
           case Effect.MATRIX     : return mM.removeByName(name);
           case Effect.VERTEX     : return mV.removeByName(name);
           case Effect.FRAGMENT   : return mF.removeByName(name);
       //  case Effect.POSTPROCESS: return mP.removeByName(name);
           default                : return 0;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Print some info about a given Effect to Android's standard out. Used for debugging only.
+     *
      * @param id Effect ID we want to print info about
      * @return <code>true</code> if a single Effect of type effectType has been found.
      */
       @SuppressWarnings("unused")
       public boolean printEffect(long id)
+        {
         int type = (int)(id&EffectTypes.MASK);
         if( type==EffectTypes.MATRIX.type  )  return mM.printByID(id>>EffectTypes.LENGTH);
         if( type==EffectTypes.VERTEX.type  )  return mV.printByID(id>>EffectTypes.LENGTH);
         if( type==EffectTypes.FRAGMENT.type)  return mF.printByID(id>>EffectTypes.LENGTH);
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
-...
      * This needs to be called BEFORE shaders get compiled, i.e. before the call to Distorted.onCreate().
      * The point: by enabling only the effects we need, we can optimize the shaders.
+     *
      * @param name Name of the Effect to enable.
      * @param name one of the constants defined in
      *             {@link org.distorted.library.effect.MatrixEffect},
      *             {@link org.distorted.library.effect.VertexEffect},
      *             {@link org.distorted.library.effect.FragmentEffect} or
      *             {@link org.distorted.library.effect.PostprocessEffect}
      */
       public static void enableEffect(EffectNames name)
       public static void enableEffect(int name)
+        {
         mEffectEnabled[name.ordinal()] = true;
         mEffectEnabled[name] = true;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       @SuppressWarnings("unused")
       public static int getMaxMatrix()
+        {
         return EffectQueue.getMax(EffectTypes.MATRIX.ordinal());
         return EffectQueue.getMax(Effect.MATRIX);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       @SuppressWarnings("unused")
       public static int getMaxVertex()
+        {
         return EffectQueue.getMax(EffectTypes.VERTEX.ordinal());
         return EffectQueue.getMax(Effect.VERTEX);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       @SuppressWarnings("unused")
       public static int getMaxFragment()
+        {
         return EffectQueue.getMax(EffectTypes.FRAGMENT.ordinal());
         return EffectQueue.getMax(Effect.FRAGMENT);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       @SuppressWarnings("unused")
       public static boolean setMaxMatrix(int max)
+        {
         return EffectQueue.setMax(EffectTypes.MATRIX.ordinal(),max);
         return EffectQueue.setMax(Effect.MATRIX,max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       @SuppressWarnings("unused")
       public static boolean setMaxVertex(int max)
+        {
         return EffectQueue.setMax(EffectTypes.VERTEX.ordinal(),max);
         return EffectQueue.setMax(Effect.VERTEX,max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       @SuppressWarnings("unused")
       public static boolean setMaxFragment(int max)
+        {
         return EffectQueue.setMax(EffectTypes.FRAGMENT.ordinal(),max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Individual effect functions.
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Matrix-based effects
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Moves the Object by a (possibly changing in time) vector.
+     *
      * @param vector 3-dimensional Data which at any given time will return a Static3D
      *               representing the current coordinates of the vector we want to move the Object with.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long move(Data3D vector)
+        {
         return mM.add(EffectNames.MOVE,vector);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Scales the Object by (possibly changing in time) 3D scale factors.
+     *
      * @param scale 3-dimensional Data which at any given time returns a Static3D
      *              representing the current x- , y- and z- scale factors.
      * @return      ID of the effect added, or -1 if we failed to add one.
      */
       public long scale(Data3D scale)
+        {
         return mM.add(EffectNames.SCALE,scale);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Scales the Object by one uniform, constant factor in all 3 dimensions. Convenience function.
+     *
      * @param scale The factor to scale all 3 dimensions with.
      * @return      ID of the effect added, or -1 if we failed to add one.
      */
       public long scale(float scale)
+        {
         return mM.add(EffectNames.SCALE, new Static3D(scale,scale,scale));
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object by 'angle' degrees around the center.
      * Static axis of rotation is given by the last parameter.
+     *
      * @param angle  Angle that we want to rotate the Object to. Unit: degrees
      * @param axis   Axis of rotation
      * @param center Coordinates of the Point we are rotating around.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long rotate(Data1D angle, Static3D axis, Data3D center )
+        {
         return mM.add(EffectNames.ROTATE, angle, axis, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object by 'angle' degrees around the center.
      * Here both angle and axis can dynamically change.
+     *
      * @param angleaxis Combined 4-tuple representing the (angle,axisX,axisY,axisZ).
      * @param center    Coordinates of the Point we are rotating around.
      * @return          ID of the effect added, or -1 if we failed to add one.
      */
       public long rotate(Data4D angleaxis, Data3D center)
+        {
         return mM.add(EffectNames.ROTATE, angleaxis, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object by quaternion.
+     *
      * @param quaternion The quaternion describing the rotation.
      * @param center     Coordinates of the Point we are rotating around.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long quaternion(Data4D quaternion, Data3D center )
+        {
         return mM.add(EffectNames.QUATERNION,quaternion,center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Shears the Object.
+     *
      * @param shear   The 3-tuple of shear factors. The first controls level
      *                of shearing in the X-axis, second - Y-axis and the third -
      *                Z-axis. Each is the tangens of the shear angle, i.e 0 -
      *                no shear, 1 - shear by 45 degrees (tan(45deg)=1) etc.
      * @param center  Center of shearing, i.e. the point which stays unmoved.
      * @return        ID of the effect added, or -1 if we failed to add one.
      */
       public long shear(Data3D shear, Data3D center)
+        {
         return mM.add(EffectNames.SHEAR, shear, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Fragment-based effects
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * @param blend  1-dimensional Data that returns the level of blend a given pixel will be
      *               mixed with the next parameter 'color': pixel = (1-level)*pixel + level*color.
      *               Valid range: <0,1>
      * @param color  Color to mix. (1,0,0) is RED.
      * @param region Region this Effect is limited to.
      * @param smooth If true, the level of 'blend' will smoothly fade out towards the edges of the region.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long chroma(Data1D blend, Data3D color, Data4D region, boolean smooth)
+        {
         return mF.add( smooth? EffectNames.SMOOTH_CHROMA:EffectNames.CHROMA, blend, color, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Object smoothly change all three of its RGB components.
+     *
      * @param blend  1-dimensional Data that returns the level of blend a given pixel will be
      *               mixed with the next parameter 'color': pixel = (1-level)*pixel + level*color.
      *               Valid range: <0,1>
      * @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(Data1D blend, Data3D color)
+        {
         return mF.add(EffectNames.CHROMA, blend, color);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * @param alpha  1-dimensional Data that returns the level of transparency we want to have at any given
      *               moment: pixel.a *= alpha.
      *               Valid range: <0,1>
      * @param region Region this Effect is limited to.
      * @param smooth If true, the level of 'alpha' will smoothly fade out towards the edges of the region.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long alpha(Data1D alpha, Data4D region, boolean smooth)
+        {
         return mF.add( smooth? EffectNames.SMOOTH_ALPHA:EffectNames.ALPHA, alpha, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Object smoothly change its transparency level.
+     *
      * @param alpha  1-dimensional Data that returns the level of transparency we want to have at any
      *               given moment: pixel.a *= alpha.
      *               Valid range: <0,1>
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long alpha(Data1D alpha)
+        {
         return mF.add(EffectNames.ALPHA, alpha);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
+     *
      * @param brightness 1-dimensional Data that returns the level of brightness we want to have
      *                   at any given moment. Valid range: <0,infinity)
      * @param region     Region this Effect is limited to.
      * @param smooth     If true, the level of 'brightness' will smoothly fade out towards the edges of the region.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long brightness(Data1D brightness, Data4D region, boolean smooth)
+        {
         return mF.add( smooth ? EffectNames.SMOOTH_BRIGHTNESS: EffectNames.BRIGHTNESS, brightness, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Object smoothly change its brightness level.
+     *
      * @param brightness 1-dimensional Data that returns the level of brightness we want to have
      *                   at any given moment. Valid range: <0,infinity)
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long brightness(Data1D brightness)
+        {
         return mF.add(EffectNames.BRIGHTNESS, brightness);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
+     *
      * @param contrast 1-dimensional Data that returns the level of contrast we want to have
      *                 at any given moment. Valid range: <0,infinity)
      * @param region   Region this Effect is limited to.
      * @param smooth   If true, the level of 'contrast' will smoothly fade out towards the edges of the region.
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long contrast(Data1D contrast, Data4D region, boolean smooth)
+        {
         return mF.add( smooth ? EffectNames.SMOOTH_CONTRAST:EffectNames.CONTRAST, contrast, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Object smoothly change its contrast level.
+     *
      * @param contrast 1-dimensional Data that returns the level of contrast we want to have
      *                 at any given moment. Valid range: <0,infinity)
      * @return         ID of the effect added, or -1 if we failed to add one.
      */
       public long contrast(Data1D contrast)
+        {
         return mF.add(EffectNames.CONTRAST, contrast);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
+     *
      * @param saturation 1-dimensional Data that returns the level of saturation we want to have
      *                   at any given moment. Valid range: <0,infinity)
      * @param region     Region this Effect is limited to.
      * @param smooth     If true, the level of 'saturation' will smoothly fade out towards the edges of the region.
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long saturation(Data1D saturation, Data4D region, boolean smooth)
+        {
         return mF.add( smooth ? EffectNames.SMOOTH_SATURATION:EffectNames.SATURATION, saturation, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Object smoothly change its saturation level.
+     *
      * @param saturation 1-dimensional Data that returns the level of saturation we want to have
      *                   at any given moment. Valid range: <0,infinity)
      * @return           ID of the effect added, or -1 if we failed to add one.
      */
       public long saturation(Data1D saturation)
+        {
         return mF.add(EffectNames.SATURATION, saturation);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Vertex-based effects
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Distort a (possibly changing in time) part of the Object by a (possibly changing in time) vector of force.
+     *
      * @param vector 3-dimensional Vector which represents the force the Center of the Effect is
      *               currently being dragged with.
      * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
      * @param region Region that masks the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long distort(Data3D vector, Data3D center, Data4D region)
+        {
         return mV.add(EffectNames.DISTORT, vector, center, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Distort the whole Object by a (possibly changing in time) vector of force.
+     *
      * @param vector 3-dimensional Vector which represents the force the Center of the Effect is
      *               currently being dragged with.
      * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long distort(Data3D vector, Data3D center)
+        {
         return mV.add(EffectNames.DISTORT, vector, center, null);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * 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 Object.
+     *
      * @param vector Vector of force that deforms the shape of the whole Object.
      * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
      * @param region Region that masks the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long deform(Data3D vector, Data3D center, Data4D region)
+        {
         return mV.add(EffectNames.DEFORM, vector, center, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * 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 Object.
+     *
      * @param vector Vector of force that deforms the shape of the whole Object.
      * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long deform(Data3D vector, Data3D center)
+        {
         return mV.add(EffectNames.DEFORM, vector, center, null);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * 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 sink   The current degree of the Effect.
      * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
      * @param region Region that masks the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long sink(Data1D sink, Data3D center, Data4D region)
+        {
         return mV.add(EffectNames.SINK, sink, center, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * 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 sink   The current degree of the Effect.
      * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long sink(Data1D sink, Data3D center)
+        {
         return mV.add(EffectNames.SINK, sink, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Pull all points around the center of the Effect towards a line passing through the center
      * (that's if degree>=1) or push them away from the line (degree<=1)
+     *
      * @param pinch  The current degree of the Effect + angle the line forms with X-axis
      * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
      * @param region Region that masks the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long pinch(Data2D pinch, Data3D center, Data4D region)
+        {
         return mV.add(EffectNames.PINCH, pinch, center, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Pull all points around the center of the Effect towards a line passing through the center
      * (that's if degree>=1) or push them away from the line (degree<=1)
+     *
      * @param pinch  The current degree of the Effect + angle the line forms with X-axis
      * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long pinch(Data2D pinch, Data3D center)
+        {
         return mV.add(EffectNames.PINCH, pinch, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotate part of the Object around the Center of the Effect by a certain angle.
+     *
      * @param swirl  The angle of Swirl (in degrees). Positive values swirl clockwise.
      * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
      * @param region Region that masks the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long swirl(Data1D swirl, Data3D center, Data4D region)
+        {
         return mV.add(EffectNames.SWIRL, swirl, center, region);
         return EffectQueue.setMax(Effect.FRAGMENT,max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotate the whole Object around the Center of the Effect by a certain angle.
      * Add a new Effect to our queue.
+     *
      * @param swirl  The angle of Swirl (in degrees). Positive values swirl clockwise.
      * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      * @param effect The Effect to add.
      */
       public long swirl(Data1D swirl, Data3D center)
       public void apply(Effect effect)
+        {
         return mV.add(EffectNames.SWIRL, swirl, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Directional, sinusoidal wave effect.
+     *
      * @param wave   A 5-dimensional data structure describing the wave: first member is the amplitude,
      *               second is the wave length, third is the phase (i.e. when phase = PI/2, the sine
      *               wave at the center does not start from sin(0), but from sin(PI/2) ) and the next two
      *               describe the 'direction' of the wave.
      *               <p>
      *               Wave direction is defined to be a 3D vector of length 1. To define such vectors, we
      *               need 2 floats: thus the third member is the angle Alpha (in degrees) which the vector
      *               forms with the XY-plane, and the fourth is the angle Beta (again in degrees) which
      *               the projection of the vector to the XY-plane forms with the Y-axis (counterclockwise).
      *               <p>
      *               <p>
      *               Example1: if Alpha = 90, Beta = 90, (then V=(0,0,1) ) and the wave acts 'vertically'
      *               in the X-direction, i.e. cross-sections of the resulting surface with the XZ-plane
      *               will be sine shapes.
      *               <p>
      *               Example2: if Alpha = 90, Beta = 0, the again V=(0,0,1) and the wave is 'vertical',
      *               but this time it waves in the Y-direction, i.e. cross sections of the surface and the
      *               YZ-plane with be sine shapes.
      *               <p>
      *               Example3: if Alpha = 0 and Beta = 45, then V=(sqrt(2)/2, -sqrt(2)/2, 0) and the wave
      *               is entirely 'horizontal' and moves point (x,y,0) in direction V by whatever is the
      *               value if sin at this point.
      * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long wave(Data5D wave, Data3D center)
+        {
         return mV.add(EffectNames.WAVE, wave, center, null);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Directional, sinusoidal wave effect.
+     *
      * @param wave   see {@link DistortedEffects#wave(Data5D,Data3D)}
      * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
      * @param region Region that masks the Effect.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long wave(Data5D wave, Data3D center, Data4D region)
+        {
         return mV.add(EffectNames.WAVE, wave, center, region);
         switch(effect.getType())
+          {
           case Effect.VERTEX      : mV.add(effect); break;
           case Effect.FRAGMENT    : mF.add(effect); break;
           case Effect.MATRIX      : mM.add(effect); break;
        // case Effect.POSTPROCESS : mP.add(effect); break;
+          }
+        }
+      }

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision 6bb59aad

Added by Leszek Koltunski almost 7 years ago