/ - Diff - Distorted Android

     package org.distorted.library.effect;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Abstract Effect of any type.
      */
     public abstract class Effect
+      {
       private final static int MAX_UNITY_DIM = 4;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public abstract boolean compute(float[] uniforms, int index, long currentDuration, long step );
       Effect(EffectName name)
+        {
         mName      = name;
         mType      = name.getType();
         mDimension = name.getDimension();
         mSupportsC = name.supportsCenter();
         mSupportsR = name.supportsRegion();
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         int n = name.ordinal();
         float[] u = name.getUnity();
         int l = name.getUnity().length;
         for(int i=0; i<l; i++)
+          {
           mUnity[n*MAX_UNITY_DIM+i] = u[i];
+          }
         mUnityDim[n] = l;
         mID = ((mNextID++)<<EffectType.LENGTH) + mType.ordinal();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static void onDestroy()
+        {
         mNextID = 0;
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public abstract boolean compute(float[] uniforms, int index, long currentDuration, long step );
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Do the set of Uniforms written in buffer[index], buffer[index+1], etc represent a Unity, i.e a
      * null Effect?
      */
       public boolean isUnity(float[] buffer, int index)
+        {
         int name = mName.ordinal();
-...
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the EffectType enum corresponding to this Effect.
+     *
      * @see EffectType
      */
       public EffectType getType()
+        {
         return mType;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the EffectName enum corresponding to this Effect.
+     *
      * @see EffectName
      */
       public EffectName getName()
+        {
         return mName;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the unique ID of this Effect.
      */
       public long getID()
+        {
         return mID;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return a printable name of this Effect.
      */
       public String getString()
+        {
         return mName.name();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Does this effect have a Center?
      */
       public boolean supportsCenter()
+        {
         return mSupportsC;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Does this effect support being masked by a Region?
      */
       public boolean supportsRegion()
+        {
         return mSupportsR;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the number of Uniforms needed to describe this effect.
      */
       public int getDimension()
+        {
         return mDimension;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       Effect(EffectName name)
+        {
         mName      = name;
         mType      = name.getType();
         mDimension = name.getDimension();
         mSupportsC = name.supportsCenter();
         mSupportsR = name.supportsRegion();
         int n = name.ordinal();
         float[] u = name.getUnity();
         int l = name.getUnity().length;
         for(int i=0; i<l; i++)
+          {
           mUnity[n*MAX_UNITY_DIM+i] = u[i];
+          }
         mUnityDim[n] = l;
         mID = ((mNextID++)<<EffectType.LENGTH) + mType.ordinal();
+        }
+      }

       LOW      ( 3 );
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static final float MULTIPLIER = 0.5f;      // each next Quality level renders into 1/0.5 smaller buffers
     /**
      * Each next Quality level renders into 1/MULTIPLIER smaller buffers.
      */
       public static final float MULTIPLIER = 0.5f;
     /**
      * Numof of possible qualities.
      */
       public static final int LENGTH = values().length;
       private final int level;
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public int getLevel()
+        {
         return level;

       POSTPROCESS;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static final int LENGTH = values().length;  // The number of effect types.
       public static final int MASK= (1<<LENGTH)-1;       // Needed when we do bitwise operations on Effect Types.
     /**
      * Number of effect types.
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static final int LENGTH = values().length;
     /**
      * Needed when we do bitwise operations on Effect Types.
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static final int MASK= (1<<LENGTH)-1;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // called from EffectQueue
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static void reset(int[] maxtable)
+        {
         maxtable[0] =10;  // By default, there can be a maximum 10 MATRIX effects in a single

     package org.distorted.library.effect;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // FRAGMENT EFFECTS
     /**
      * Fragment Effect - an Effect that works by injecting certain code into the main Fragment shader.
      */
     public abstract class FragmentEffect extends Effect
+      {
       public static final int NUM_UNIFORMS = 8; // 4-per effect interpolated values, 4 dimensional Region.
     /**
      * 8: 4-per effect interpolated values, 4 dimensional Region.
      */
       public static final int NUM_UNIFORMS = 8;
       private static String mGLSL = "";
       private static int mNumEnabled = 0;
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // prepare code to be injected into the 'main_fragment_shader' main() function.
       static void addEffect(EffectName not_smooth, EffectName yes_smooth, String code)
+        {
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static String getGLSL()
+        {
         return mGLSL + "{}";
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static int getNumEnabled()
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static void onDestroy()
+        {
         return mNumEnabled;
         mNumEnabled = 0;
         mGLSL = "";
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static void onDestroy()
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the number of Fragment effects enabled.
      */
       public static int getNumEnabled()
+        {
         mNumEnabled = 0;
         mGLSL = "";
         return mNumEnabled;
+        }
+      }

     import org.distorted.library.type.Static4D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Make a certain Region change its transparency level.
      */
     public class FragmentEffectAlpha extends FragmentEffect
+      {
       private Data1D mAlpha;
       private Data4D mRegion;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mRegion.get(uniforms, index+4, currentDuration, step);
         return mAlpha.get(uniforms,index, currentDuration, step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its transparency level.
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mRegion.get(uniforms, index+4, currentDuration, step);
         return mAlpha.get(uniforms,index, currentDuration, step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Have to call this before the shaders get compiled (i.e before Distorted.onCreate()) for the Effect to work.
      */
       public static void enable()
+        {
         addEffect( EffectName.ALPHA,EffectName.SMOOTH_ALPHA,

     import org.distorted.library.type.Static4D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Make a certain Region change its brightness level.
      */
     public class FragmentEffectBrightness extends FragmentEffect
+      {
       private Data1D mBrightness;
       private Data4D mRegion;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mRegion.get(uniforms,index+4,currentDuration,step);
         return mBrightness.get(uniforms,index,currentDuration,step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its brightness level.
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mRegion.get(uniforms,index+4,currentDuration,step);
         return mBrightness.get(uniforms,index,currentDuration,step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Have to call this before the shaders get compiled (i.e before Distorted.onCreate()) for the Effect to work.
      */
       public static void enable()
+        {
         addEffect( EffectName.BRIGHTNESS,EffectName.SMOOTH_BRIGHTNESS,

     import org.distorted.library.type.Static4D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Make a certain Region change its color.
      */
     public class FragmentEffectChroma extends FragmentEffect
+      {
       private Data1D mBlend;
       private Data3D mColor;
       private Data4D mRegion;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mRegion.get(uniforms,index+4,currentDuration,step);
         mColor.get(uniforms,index+1,currentDuration,step);
         return mBlend.get(uniforms,index,currentDuration,step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mRegion.get(uniforms,index+4,currentDuration,step);
         mColor.get(uniforms,index+1,currentDuration,step);
         return mBlend.get(uniforms,index,currentDuration,step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Have to call this before the shaders get compiled (i.e before Distorted.onCreate()) for the Effect to work.
      */
       public static void enable()
+        {
         addEffect( EffectName.CHROMA,EffectName.SMOOTH_CHROMA,

     import org.distorted.library.type.Static4D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Make a certain Region change its contrast level.
      */
     public class FragmentEffectContrast extends FragmentEffect
+      {
       private Data1D mContrast;
       private Data4D mRegion;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mRegion.get(uniforms,index+4,currentDuration,step);
         return mContrast.get(uniforms,index,currentDuration,step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its contrast level.
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mRegion.get(uniforms,index+4,currentDuration,step);
         return mContrast.get(uniforms,index,currentDuration,step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Have to call this before the shaders get compiled (i.e before Distorted.onCreate()) for the Effect to work.
      */
       public static void enable()
+        {
         addEffect( EffectName.CONTRAST,EffectName.SMOOTH_CONTRAST,

     import org.distorted.library.type.Static4D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Make a certain Region change its color saturation.
      */
     public class FragmentEffectSaturation extends FragmentEffect
+      {
       private Data1D mSaturation;
       private Data4D mRegion;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mRegion.get(uniforms,index+4,currentDuration,step);
         return mSaturation.get(uniforms,index,currentDuration,step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Object smoothly change its saturation level.
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mRegion.get(uniforms,index+4,currentDuration,step);
         return mSaturation.get(uniforms,index,currentDuration,step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Have to call this before the shaders get compiled (i.e before Distorted.onCreate()) for the Effect to work.
      */
       public static void enable()
+        {
         addEffect( EffectName.SATURATION,EffectName.SMOOTH_SATURATION,

     package org.distorted.library.effect;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // MATRIX EFFECTS.
     /**
      * Matrix Effect - an Effect that works by modifying the ModelView matrix.
      */
     public abstract class MatrixEffect extends Effect
+      {
       public static final int NUM_UNIFORMS = 7; // 4 per-effect interpolated values + 3 dimensional center.
     /**
      * 7: 4 per-effect interpolated values + 3 dimensional center.
      */
       public static final int NUM_UNIFORMS = 7;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public abstract void apply(float[] matrix, float[] uniforms, int index);
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     import org.distorted.library.type.Data3D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Move the Mesh by a 3D vector.
      */
     public class MatrixEffectMove extends MatrixEffect
+      {
       private Data3D mVector;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Moves the Object by a (possibly changing in time) vector.
      * Only for use by the library itself.
+     *
      * @param vector current coordinates of the vector we want to move the Object with.
      * @y.exclude
      */
       public MatrixEffectMove(Data3D vector)
+        {
         super(EffectName.MOVE);
         mVector = vector;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         return mVector.get(uniforms,index,currentDuration,step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public void apply(float[] matrix, float[] uniforms, int index)
+        {
         float sx = uniforms[NUM_UNIFORMS*index  ];
-...
         Matrix.translateM(matrix, 0, sx,-sy, sz);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Move the Mesh by a 3D vector.
+     *
      * @param vector current coordinates of the vector we want to move the Mesh with.
      */
       public MatrixEffectMove(Data3D vector)
+        {
         super(EffectName.MOVE);
         mVector = vector;
+        }
+      }

     import org.distorted.library.type.Data4D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotate the Mesh by a quaternion.
      */
     public class MatrixEffectQuaternion extends MatrixEffect
+      {
       private Data4D mQuaternion;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object by quaternion.
      * Only for use by the library itself.
+     *
      * @param quaternion Quaternion describing the rotation.
      * @param center     Coordinates of the Point we are rotating around.
      * @y.exclude
      */
       public MatrixEffectQuaternion(Data4D quaternion, Data3D center )
+        {
         super(EffectName.QUATERNION);
         mQuaternion = quaternion;
         mCenter = center;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mCenter.get(uniforms,index+4,currentDuration,step);
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public void apply(float[] matrix, float[] uniforms, int index)
+        {
         float qX = uniforms[NUM_UNIFORMS*index  ];
-...
         matrix[14] = mTmpMatrix2[14];
         matrix[15] = mTmpMatrix2[15];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotate the Mesh by a quaternion.
+     *
      * @param quaternion Quaternion describing the rotation.
      * @param center     Coordinates of the Point we are rotating around.
      */
       public MatrixEffectQuaternion(Data4D quaternion, Data3D center )
+        {
         super(EffectName.QUATERNION);
         mQuaternion = quaternion;
         mCenter = center;
+        }
+      }

     import org.distorted.library.type.Data3D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotate the Mesh by 'angle' degrees around the center, along an axis.
      */
     public class MatrixEffectRotate extends MatrixEffect
+      {
       private Data1D mAngle;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object by 'angle' degrees around the center.
      * Static axis of rotation is given by the last parameter.
      * Only for use by the library itself.
+     *
      * @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.
      * @y.exclude
      */
       public MatrixEffectRotate(Data1D angle, Data3D axis, Data3D center)
+        {
         super(EffectName.ROTATE);
         mAngle = angle;
         mAxis = axis;
         mCenter = center;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mCenter.get(uniforms,index+4,currentDuration,step);
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public void apply(float[] matrix, float[] uniforms, int index)
+        {
         float alpha = uniforms[NUM_UNIFORMS*index  ];
-...
         Matrix.rotateM( matrix, 0, alpha, axisX, axisY, axisZ);
         Matrix.translateM(matrix, 0,-x, y,-z);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotate the Mesh by 'angle' degrees around the center, along an axis.
+     *
      * @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.
      */
       public MatrixEffectRotate(Data1D angle, Data3D axis, Data3D center)
+        {
         super(EffectName.ROTATE);
         mAngle = angle;
         mAxis = axis;
         mCenter = center;
+        }
+      }

     import org.distorted.library.type.Static3D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Scale the Mesh by 3D scale factors.
      */
     public class MatrixEffectScale extends MatrixEffect
+      {
       private Data3D mScale;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Scales the Object by (possibly changing in time) 3D scale factors.
      * Only for use by the library itself.
+     *
      * @param scale current x- , y- and z- scale factors.
      * @y.exclude
      */
       public MatrixEffectScale(Data3D scale)
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         super(EffectName.SCALE);
         mScale = scale;
         return mScale.get(uniforms,index,currentDuration,step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Scales the Object by (possibly changing in time) 3D scale factors.
      * Only for use by the library itself.
+     *
      * @param scale Common x,y, and z scale factor.
      * @y.exclude
      */
       public MatrixEffectScale(float scale)
       public void apply(float[] matrix, float[] uniforms, int index)
+        {
         super(EffectName.SCALE);
         mScale = new Static3D(scale,scale,scale);
         float sx = uniforms[NUM_UNIFORMS*index  ];
         float sy = uniforms[NUM_UNIFORMS*index+1];
         float sz = uniforms[NUM_UNIFORMS*index+2];
         Matrix.scaleM(matrix, 0, sx, sy, sz);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Scale the Mesh by 3D scale factors.
+     *
      * @param scale current x- , y- and z- scale factors.
      */
       public MatrixEffectScale(Data3D scale)
+        {
         return mScale.get(uniforms,index,currentDuration,step);
         super(EffectName.SCALE);
         mScale = scale;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void apply(float[] matrix, float[] uniforms, int index)
     /**
      * Scale the Mesh by 3D scale factors.
+     *
      * @param scale Common x,y, and z scale factor.
      */
       public MatrixEffectScale(float scale)
+        {
         float sx = uniforms[NUM_UNIFORMS*index  ];
         float sy = uniforms[NUM_UNIFORMS*index+1];
         float sz = uniforms[NUM_UNIFORMS*index+2];
         Matrix.scaleM(matrix, 0, sx, sy, sz);
         super(EffectName.SCALE);
         mScale = new Static3D(scale,scale,scale);
+        }
+      }

     import org.distorted.library.type.Data3D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Shear the Mesh.
      */
     public class MatrixEffectShear extends MatrixEffect
+      {
       private Data3D mShear, mCenter;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Shears the Object.
      * Only for use by the library itself.
+     *
      * @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.
      * @y.exclude
      */
       public MatrixEffectShear(Data3D shear, Data3D center)
+        {
         super(EffectName.SHEAR);
         mShear = shear;
         mCenter = center;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mCenter.get(uniforms,index+4,currentDuration,step);
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public void apply(float[] matrix, float[] uniforms, int index)
+        {
         float sx = uniforms[NUM_UNIFORMS*index  ];
-...
         Matrix.translateM(matrix, 0,-x, y, -z);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Shear the Mesh.
+     *
      * @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.
      */
       public MatrixEffectShear(Data3D shear, Data3D center)
+        {
         super(EffectName.SHEAR);
         mShear = shear;
         mCenter = center;
+        }
+      }

     import java.util.ArrayList;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // POSTPROCESSING EFFECTS.
     /**
      * Postprocessing Effect - an Effect that works by running a certain Shader Program(s) on a Framebuffer.
      */
     public abstract class PostprocessEffect extends Effect
+      {
       public static final int NUM_UNIFORMS = 5; // 5 per-effect interpolated values.
     /**
      * 5: 5 per-effect interpolated values.
      */
       public static final int NUM_UNIFORMS = 5;
       static final int POS_DATA_SIZE= 2; // Blur Program: size of the position data in elements
       static final int TEX_DATA_SIZE= 2; // Blur Program: size of the texture coordinate data in elements.
       static final int POS_DATA_SIZE= 2;
       static final int TEX_DATA_SIZE= 2;
       static final FloatBuffer mQuadPositions, mQuadTexture, mQuadTextureInv;
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static void createPrograms()
+        {
         Source source;
-...
+          {
           source = mSources.remove(0);
           //android.util.Log.d("postprocess", "compilaing: "+source.mName);
           //android.util.Log.d("postprocess", "compiling: "+source.mName);
           try
+            {
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public abstract int apply(float[] uniforms, int index, float qualityScale, DistortedFramebuffer buffer);
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     import org.distorted.library.type.Data1D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Blur the Framebuffer.
      */
     public class PostprocessEffectBlur extends PostprocessEffect
+      {
       private static final int MAX_HALO = 50;
-...
       private static int mIndex1, mIndex2;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Blur the object.
+     *
      * @param blurRadius The 'strength' if the effect, in pixels. 0 = no blur, 10 = when blurring a given pixel,
      *                   take into account 10 pixels in each direction.
      */
       public PostprocessEffectBlur(Data1D blurRadius)
     // This implements the 'Better separable implementation using GPU fixed function sampling' from
     // https://software.intel.com/en-us/blogs/2014/07/15/an-investigation-of-fast-real-time-gpu-based-image-blur-algorithms
       private void computeGaussianKernel(int radius)
+        {
         super(EffectName.BLUR);
         mBlurRadius = blurRadius;
         int offset = radius + radius*radius/4;
         if( weightsCache[offset]==0.0f )
+          {
           float z, x= 0.0f, P= (float)NUM_GAUSSIAN / (radius>3 ? radius:3);
           mWeights[0] = GAUSSIAN[0];
           float sum   = GAUSSIAN[0];
           int j;
           for(int i=1; i<=radius; i++)
+            {
             x += P;
             j = (int)x;
             z = x-j;
             mWeights[i] = (1-z)*GAUSSIAN[j] + z*GAUSSIAN[j+1];
             sum += 2*mWeights[i];
+            }
           for(int i=0; i<=radius; i++) mWeights[i] /= sum;
           int numloops = radius/2;
           weightsCache[offset] = mWeights[0];
           offsetsCache[offset] = 0.0f;
           for(int i=0; i<numloops; i++)
+            {
             offsetsCache[offset+i+1] = mWeights[2*i+1]*(2*i+1) + mWeights[2*i+2]*(2*i+2);
             weightsCache[offset+i+1] = mWeights[2*i+1] + mWeights[2*i+2];
             offsetsCache[offset+i+1]/= weightsCache[offset+i+1];
+            }
           if( radius%2 == 1 )
+            {
             int index = offset + radius/2 +1;
             offsetsCache[index]=radius;
             weightsCache[index]=mWeights[radius];
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         return mBlurRadius.get(uniforms,index,currentDuration,step);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public int apply(float[] uniforms, int index, float qualityScale, DistortedFramebuffer buffer)
+        {
         if( mProgram1 ==null)
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Have to call this before the shaders get compiled (i.e before Distorted.onCreate()) for the Effect to work.
      */
       public static void enable()
+        {
         final String blurVertex =
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // This implements the 'Better separable implementation using GPU fixed function sampling' from
     // https://software.intel.com/en-us/blogs/2014/07/15/an-investigation-of-fast-real-time-gpu-based-image-blur-algorithms
       private void computeGaussianKernel(int radius)
     /**
      * Blur the Framebuffer.
+     *
      * @param blurRadius The 'strength' if the effect, in pixels. 0 = no blur, 10 = when blurring a given pixel,
      *                   take into account 10 pixels in each direction.
      */
       public PostprocessEffectBlur(Data1D blurRadius)
+        {
         int offset = radius + radius*radius/4;
         if( weightsCache[offset]==0.0f )
+          {
           float z, x= 0.0f, P= (float)NUM_GAUSSIAN / (radius>3 ? radius:3);
           mWeights[0] = GAUSSIAN[0];
           float sum   = GAUSSIAN[0];
           int j;
           for(int i=1; i<=radius; i++)
+            {
             x += P;
             j = (int)x;
             z = x-j;
             mWeights[i] = (1-z)*GAUSSIAN[j] + z*GAUSSIAN[j+1];
             sum += 2*mWeights[i];
+            }
           for(int i=0; i<=radius; i++) mWeights[i] /= sum;
           int numloops = radius/2;
           weightsCache[offset] = mWeights[0];
           offsetsCache[offset] = 0.0f;
           for(int i=0; i<numloops; i++)
+            {
             offsetsCache[offset+i+1] = mWeights[2*i+1]*(2*i+1) + mWeights[2*i+2]*(2*i+2);
             weightsCache[offset+i+1] = mWeights[2*i+1] + mWeights[2*i+2];
             offsetsCache[offset+i+1]/= weightsCache[offset+i+1];
+            }
           if( radius%2 == 1 )
+            {
             int index = offset + radius/2 +1;
             offsetsCache[index]=radius;
             weightsCache[index]=mWeights[radius];
+            }
+          }
         super(EffectName.BLUR);
         mBlurRadius = blurRadius;
+        }
+      }

       private static int mIndex1, mIndex2;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // This implements the 'Better separable implementation using GPU fixed function sampling' from
     // https://software.intel.com/en-us/blogs/2014/07/15/an-investigation-of-fast-real-time-gpu-based-image-blur-algorithms
     /**
      * Make the object glow with a specific color and a halo of specific radius.
+     *
      * @param glowRadius The 'strength' if the effect, in pixels. 0 = no halo, 10 = halo of roughly 10 pixels
      *                   around the whole object.
      * @param color      RGBA of the color with which to draw the glow.
      */
       public PostprocessEffectGlow(Data1D glowRadius, Data4D color)
       private void computeGaussianKernel(int radius)
+        {
         super(EffectName.GLOW);
         mGlowRadius = glowRadius;
         mColor      = color;
         int offset = radius + radius*radius/4;
         if( weightsCache[offset]==0.0f )
+          {
           float z, x= 0.0f, P= (float)NUM_GAUSSIAN / (radius>3 ? radius:3);
           mWeights[0] = GAUSSIAN[0];
           float sum   = GAUSSIAN[0];
           int j;
           for(int i=1; i<=radius; i++)
+            {
             x += P;
             j = (int)x;
             z = x-j;
             mWeights[i] = (1-z)*GAUSSIAN[j] + z*GAUSSIAN[j+1];
             sum += 2*mWeights[i];
+            }
           for(int i=0; i<=radius; i++) mWeights[i] /= sum;
           int numloops = radius/2;
           weightsCache[offset] = mWeights[0];
           offsetsCache[offset] = 0.0f;
           for(int i=0; i<numloops; i++)
+            {
             offsetsCache[offset+i+1] = mWeights[2*i+1]*(2*i+1) + mWeights[2*i+2]*(2*i+2);
             weightsCache[offset+i+1] = mWeights[2*i+1] + mWeights[2*i+2];
             offsetsCache[offset+i+1]/= weightsCache[offset+i+1];
+            }
           if( radius%2 == 1 )
+            {
             int index = offset + radius/2 +1;
             offsetsCache[index]=radius;
             weightsCache[index]=mWeights[radius];
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+        {
         mColor.get(uniforms,index+1,currentDuration,step);
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public int apply(float[] uniforms, int index, float qualityScale, DistortedFramebuffer buffer)
+        {
         if( mProgram1 ==null)
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Have to call this before the shaders get compiled (i.e before Distorted.onCreate()) for the Effect to work.
      */
       public static void enable()
+        {
         final String glowVertex =
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // This implements the 'Better separable implementation using GPU fixed function sampling' from
     // https://software.intel.com/en-us/blogs/2014/07/15/an-investigation-of-fast-real-time-gpu-based-image-blur-algorithms
       private void computeGaussianKernel(int radius)
     /**
      * Make the object glow with a specific color and a halo of specific radius.
+     *
      * @param glowRadius The 'strength' if the effect, in pixels. 0 = no halo, 10 = halo of roughly 10 pixels
      *                   around the whole object.
      * @param color      RGBA of the color with which to draw the glow.
      */
       public PostprocessEffectGlow(Data1D glowRadius, Data4D color)
+        {
         int offset = radius + radius*radius/4;
         if( weightsCache[offset]==0.0f )
+          {
           float z, x= 0.0f, P= (float)NUM_GAUSSIAN / (radius>3 ? radius:3);
           mWeights[0] = GAUSSIAN[0];
           float sum   = GAUSSIAN[0];
           int j;
           for(int i=1; i<=radius; i++)
+            {
             x += P;
             j = (int)x;
             z = x-j;
             mWeights[i] = (1-z)*GAUSSIAN[j] + z*GAUSSIAN[j+1];
             sum += 2*mWeights[i];
+            }
           for(int i=0; i<=radius; i++) mWeights[i] /= sum;
           int numloops = radius/2;
           weightsCache[offset] = mWeights[0];
           offsetsCache[offset] = 0.0f;
           for(int i=0; i<numloops; i++)
+            {
             offsetsCache[offset+i+1] = mWeights[2*i+1]*(2*i+1) + mWeights[2*i+2]*(2*i+2);
             weightsCache[offset+i+1] = mWeights[2*i+1] + mWeights[2*i+2];
             offsetsCache[offset+i+1]/= weightsCache[offset+i+1];
+            }
           if( radius%2 == 1 )
+            {
             int index = offset + radius/2 +1;
             offsetsCache[index]=radius;
             weightsCache[index]=mWeights[radius];
+            }
+          }
         super(EffectName.GLOW);
         mGlowRadius = glowRadius;
         mColor      = color;
+        }
+      }

     package org.distorted.library.effect;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // VERTEX EFFECTS
     /**
      * Vertex Effect - an Effect that works by injecting certain code into the main Vertex shader.
      */
     public abstract class VertexEffect extends Effect
+      {
       public static final int NUM_UNIFORMS = 12; // 5 per-effect interpolated values, 3-dimensional center, 4-dimensional Region
     /**
      * 12: 5 per-effect interpolated values, 3-dimensional center, 4-dimensional Region
      */
       public static final int NUM_UNIFORMS = 12;
       private static String mGLSL = "";
       private static int mNumEnabled = 0;
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // prepare code to be injected into the 'main_vertex_shader' main() function.
       static void addEffect(EffectName name, String code)
+        {
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static String getGLSL()
+        {
         return mGLSL + "{}";
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static int getNumEnabled()
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public static void onDestroy()
+        {
         return mNumEnabled;
         mNumEnabled = 0;
         mGLSL = "";
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static void onDestroy()
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return the number of Fragment effects enabled.
      */
       public static int getNumEnabled()
+        {
         mNumEnabled = 0;
         mGLSL = "";
         return mNumEnabled;
+        }
+      }

     import org.distorted.library.type.Static4D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Deform the Mesh by applying a 3D vector of force.
      */
     public class VertexEffectDeform extends VertexEffect
+      {
       private Data3D mVector, mCenter;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * 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.

Project

General

Profile

Distorted Android

Revision faa3ff56

Added by Leszek Koltunski over 8 years ago