/ - Diff - Distorted Android

     public class Distorted
+      {
       /**
        * When creating an instance of a DistortedObject from another instance, do not clone anything.
        * When creating an instance of a DistortedTexture (or Tree) from another instance, do not clone anything.
        * Used in the copy constructor.
        */
       public static final int CLONE_NOTHING = 0x0;
       /**
        * When creating an instance of a DistortedObject from another instance, clone the Bitmap that's
        * backing up our DistortedObject.
        * When creating an instance of a DistortedTexture from another instance, clone the Bitmap that's
        * backing up our DistortedTexture.
        * <p>
        * This way we can have two DistortedObjects, both backed up by the same Bitmap, to which we can
        * This way we can have two DistortedTextures, both backed up by the same Bitmap, to which we can
        * apply different effects. Used in the copy constructor.
        */
       public static final int CLONE_BITMAP  = 0x1;
       /**
        * When creating an instance of a DistortedObject from another instance, clone the Matrix Effects.
        * When creating an instance of a DistortedEffects from another instance, clone the Matrix Effects.
        * <p>
        * This way we can have two different DistortedObjects with different Bitmaps behind them, both
        * always displayed in exactly the same place on the screen. Applying any matrix-based effect to
        * one of them automatically applies the effect to the other. Used in the copy constructor.
        * This way we can have two different DistortedEffects sharing the MATRIX queue.
        */
       public static final int CLONE_MATRIX = 0x2;
       /**
        * When creating an instance of a DistortedObject from another instance, clone the Vertex Effects.
        * When creating an instance of a DistortedEffects from another instance, clone the Vertex Effects.
        * <p>
        * This way we can have two different DistortedObjects with different Bitmaps behind them, both
        * always with the same Vertex effects. Applying any vertex-based effect to one of them automatically
        * applies the effect to the other. Used in the copy constructor.
        * This way we can have two different DistortedEffects sharing the VERTEX queue.
        */
       public static final int CLONE_VERTEX  = 0x4;
       /**
        * When creating an instance of a DistortedObject from another instance, clone the Fragment Effects.
        * When creating an instance of a DistortedEffects from another instance, clone the Fragment Effects.
        * <p>
        * This way we can have two different DistortedObjects with different Bitmaps behind them, both
        * always with the same Fragment effects. Applying any fragment-based effect to one of them automatically
        * applies the effect to the other. Used in the copy constructor.
        * This way we can have two different DistortedEffects sharing the FRAGMENT queue.
        */
       public static final int CLONE_FRAGMENT= 0x8;
       /**
        * When creating an instance of a DistortedTree from another instance, clone the children Nodes.
        * <p>
        * This is mainly useful for creating many similar sub-trees of Bitmaps and rendering then at different places
        * on the screen, with (optionally) different effects of the top-level root Bitmap.
        * This is mainly useful for creating many similar sub-trees and rendering then at different places
        * on the screen with (optionally) different Effects.
        */
       public static final int CLONE_CHILDREN= 0x10;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the maximum number of Matrix effects that can be applied to a single DistortedObject at one time.
      * Sets the maximum number of Matrix effects that can be stored in a single EffectQueue at one time.
      * This can fail if:
      * <ul>
      * <li>the value of 'max' is outside permitted range (0 &le; max &le; Byte.MAX_VALUE)
      * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called
      *     before the Vertex Shader gets compiled, i.e. before the call to {@link #onSurfaceCreated}. After this
      *     time only decreasing the value of 'max' is permitted.
      * <li>Furthermore, this needs to be called before any DistortedObject gets created.
      * <li>Furthermore, this needs to be called before any DistortedEffects gets created.
      * </ul>
+     *
      * @param max new maximum number of simultaneous Matrix Effects. Has to be a non-negative number not greater
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the maximum number of Vertex effects that can be applied to a single DistortedObject at one time.
      * Sets the maximum number of Vertex effects that can be stored in a single EffectQueue at one time.
      * This can fail if:
      * <ul>
      * <li>the value of 'max' is outside permitted range (0 &le; max &le; Byte.MAX_VALUE)
      * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called
      *     before the Vertex Shader gets compiled, i.e. before the call to {@link #onSurfaceCreated}. After this
      *     time only decreasing the value of 'max' is permitted.
     * <li>Furthermore, this needs to be called before any DistortedObject gets created.
     * <li>Furthermore, this needs to be called before any DistortedEffects get created.
      * </ul>
+     *
      * @param max new maximum number of simultaneous Vertex Effects. Has to be a non-negative number not greater
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the maximum number of Fragment effects that can be applied to a single DistortedObject at one time.
      * Sets the maximum number of Fragment effects that can be stored in a single EffectQueue at one time.
      * This can fail if:
      * <ul>
      * <li>the value of 'max' is outside permitted range (0 &le; max &le; Byte.MAX_VALUE)
      * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called
      *     before the Fragment Shader gets compiled, i.e. before the call to {@link #onSurfaceCreated}. After this
      *     time only decreasing the value of 'max' is permitted.
      * <li>Furthermore, this needs to be called before any DistortedObject gets created.
      * <li>Furthermore, this needs to be called before any DistortedEffects get created.
      * </ul>
+     *
      * @param max new maximum number of simultaneous Fragment Effects. Has to be a non-negative number not greater

         long mEffectID;
         int mEffectName;
         long mBitmapID;
         String mStr;
         Message(EffectListener l, EffectMessage m, long id, int name, long bmpID, String str)
         Message(EffectListener l, EffectMessage m, long id, int name, long bmpID)
+          {
           mListener   = l;
           mMessage    = m;
           mEffectID   = id;
           mEffectName = name;
           mBitmapID   = bmpID;
           mStr        = str;
+          }
+        }
-...
           while( mList.size()>0 )
+            {
             tmp = mList.remove(0);
             tmp.mListener.effectMessage(tmp.mMessage, tmp.mEffectID, EffectNames.getName(tmp.mEffectName),
                                         tmp.mBitmapID, tmp.mStr);
             tmp.mListener.effectMessage(tmp.mMessage, tmp.mEffectID, EffectNames.getName(tmp.mEffectName),tmp.mBitmapID);
+            }
           synchronized(mThis)
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static void newMessage(EffectListener l, EffectMessage m, long id, int name, long bmpID, String str)
       static void newMessage(EffectListener l, EffectMessage m, long id, int name, long bmpID)
+        {
         Message msg = mThis.new Message(l,m,id,name,bmpID,str);
         Message msg = mThis.new Message(l,m,id,name,bmpID);
         mList.add(msg);
         synchronized(mThis)

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Names of Effects one can apply to DistortedObjects.
      * Names of Effects one can add to the DistortedEffects queues.
      * <p>
      * Effect's 'Type' is one of the constants defined in {@link EffectTypes}.
      * </p>
-...
       SWIRL            ( EffectTypes.VERTEX  ,   new float[] {0.0f}           , 1, true, true ),
       /**
        * Directional sinusoidal wave effect. The direction of the wave is given by the 'angle'
        * parameters. Details: {@link DistortedObject#wave(org.distorted.library.type.Data5D,org.distorted.library.type.Data3D)}
        * parameters. Details: {@link DistortedEffects#wave(org.distorted.library.type.Data5D,org.distorted.library.type.Data3D)}
        * <p>
        * Uniforms: (amplitude,length,phase,angleAlpha,
        *            angleBeta, centerX,centerY,centerZ,

+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Only max Byte.MAX_VALUE concurrent effects per DistortedObject.
     // Only max Byte.MAX_VALUE concurrent effects per DistortedEffects object.
     // If you want more, change type of the mNumEffects, mIDIndex and mFreeIndexes variables to shorts.
     // (although probably this many uniforms will not fit in the shaders anyway!)
       static boolean setMax(int index, int m)
+        {
-...
                                               EffectMessage.EFFECT_REMOVED,
                                               (removedID<<EffectTypes.LENGTH)+EffectNames.getType(removedName).type,
                                               removedName,
                                               mObjectID,
                                               null);
                                               mObjectID);
+            }
+          }
-...
                                           EffectMessage.EFFECT_REMOVED,
                                           (removedID<<EffectTypes.LENGTH)+EffectNames.getType(removedName).type,
                                           removedName,
                                           mObjectID,
                                           null);
                                           mObjectID);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

                                               EffectMessage.EFFECT_FINISHED,
                                               (mID[i]<<EffectTypes.LENGTH)+EffectTypes.FRAGMENT.type,
                                               mName[i],
                                               mObjectID,
                                               null);
                                               mObjectID);
             if( EffectNames.isUnity(mName[i], mUniforms, NUM_UNIFORMS*i) )
+              {

                                               EffectMessage.EFFECT_FINISHED,
                                              (mID[i]<<EffectTypes.LENGTH)+EffectTypes.MATRIX.type,
                                               mName[i],
                                               mObjectID,
                                               null);
                                               mObjectID);
             if( EffectNames.isUnity(mName[i], mUniforms, NUM_UNIFORMS*i) )
+              {

                                                 EffectMessage.EFFECT_FINISHED,
                                                (mID[i]<<EffectTypes.LENGTH)+EffectTypes.VERTEX.type,
                                                 mName[i],
                                                 mObjectID,
                                                 null);
                                                 mObjectID);
               if( EffectNames.isUnity(mName[i], mUniforms, NUM_UNIFORMS*i) )
+                {

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Types of Effects one can apply to DistortedObjects.
      * Types of Effects one can add to the DistortedEffects queues.
      * <p>
      * Each effect type goes to an independent queue; the queues get executed one-by-one
      * and are each a class descendant from EffectQueue.

src/main/java/org/distorted/library/GridCubes.java
162	162	}
163	163	*/
164	164	///////////////////////////////////////////////////////////////////////////////////////////////////
165		// desc is guaranteed to be padded with 0s in the end (DistortedCubes constructor does it)
166	165
167	166	private void prepareDataStructures(int cols, String desc, boolean frontOnly)
168	167	{

       private int remainingVert;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Create a flat, full grid. cols and rows is guaranteed (by DistortedBitmap constructor)
     // to be in 1,2,...,256.
     // Create a flat, full grid.
        private void computeNumberOfVertices(int cols, int rows)
+         {

     /**
      * This interface lets users of the Distorted library get notified when something happens to one of the effects.
      * To receive the notifications, we first have to register with a call to {@link org.distorted.library.DistortedObject#addEventListener(EffectListener)}.
      * To receive the notifications, we first have to register with a call to {@link org.distorted.library.DistortedEffects#registerForMessages(EffectListener)}.
      * List of all possible events that can happen is defined in {@link EffectMessage}
      */
-...
+     *
      * @param eventType  Type of event that happened.
      * @param effectID   ID of the effect the event happened to. This ID must have been previously returned by one
      *                   of the DistortedObject.{deform,distort,move,...} functions.
      *                   of the DistortedEffects.{deform,distort,move,...} functions.
      * @param effectName Name of the effect as defined by EffectNames.
      * @param objectID   the ID of the DistortedObject object, as returned by {@link org.distorted.library.DistortedObject#getID()},
      *                   this event happened to. If the Object has been created using a copy constructor
      *                   from another instance of DistortedObject, the ID here will be the one of the original object.
      * @param message    Any message string associated with it. 'Failed' event types have one.
      * @param objectID   the ID of the DistortedEffects object, as returned by {@link org.distorted.library.DistortedEffects#getID()},
      *                   this event happened to.
      * @see EffectMessage
      * @see EffectNames
      */
       void effectMessage(final EffectMessage eventType, final long effectID, final EffectNames effectName, final long objectID, final String message);
       void effectMessage(final EffectMessage eventType, final long effectID, final EffectNames effectName, final long objectID);
+      }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     /**
      * The effect has been removed. This can happen if:
      * <ul>
      * <li> someone explicitly removed the effect with a call to {@link org.distorted.library.DistortedObject#abortEffect(long)}
      * <li> someone explicitly removed the effect with a call to {@link org.distorted.library.DistortedEffects#abortEffect(long)}
      *      (or one of the other 'abort' methods)
      * <li> the interpolation of the effect has finished and the end result is equal to the effect's unity.
      * </ul>
-...
      * If then the end effect is equal to the effect's unity, then immediately after this message you
      * will also get a EFFECT_REMOVED message.
      */
       EFFECT_FINISHED,
       /**
      * The effect has failed to properly execute.
      * <p>
      * Currently only OTHER effects (saving to PNG file and to a MP4 movie) can fail.
      */
       EFFECT_FAILED
       EFFECT_FINISHED
+      }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

+      {
       private Vector<Static3D> vv;
       private Static3D prev, curr, next;
     /*
     private float a0,a1,a2;
     private float f0, f1;
     private float b00,b01,b02;
     private float b10,b11,b12;
     private float b20,b21,b22;
     private float oldTime;
     */
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // no array bounds checking!

src/main/java/org/distorted/library/type/DynamicQuat.java
37	37	// omega, sinOmega, cosOmega - angle between pair of quaternions, its sinus and cosinus.
38	38	//
39	39	// (vx,vy,vz,vw) is the original vector from vv (copied here so when interpolating we can see if it is
40		// still valid and if not - rebuild the Cache
	40	// still valid and if not - rebuild the Cache.
41	41
42	42	private class VectorCacheQuat
43	43	{
...	...
398	398	}
399	399
400	400	}
401		///////////////////////////////////////////////////////////////////////////////////////////////////
402		//

src/main/java/org/distorted/library/type/Static1D.java
22	22	///////////////////////////////////////////////////////////////////////////////////////////////////
23	23	/**
24	24	* A 1-dimensional data structure containing a single float. The float has no particular meaning;
25		* when this data structure is used in Interpolators, we can think of it as a 1-dimensional Point
	25	* when this data structure is used in Dynamics, we can think of it as a 1-dimensional Point
26	26	* a few of which the Dynamic interpolates between.
27	27	*/
28	28
...	...
106	106	{
107	107	return x;
108	108	}
109
110		///////////////////////////////////////////////////////////////////////////////////////////////////
111		// end of class
	109
112	110	}

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * A 2-dimensional data structure containing two floats. The floats have no particular meaning;
      * when this data structure is used in Interpolators, we can think of it as a 2-dimensional Point
      * when this data structure is used in Dynamics, we can think of it as a 2-dimensional Point
      * a few of which the Dynamic interpolates between.
      */
-...
         return y;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // end of class
+      }

src/main/java/org/distorted/library/type/Static3D.java
22	22	///////////////////////////////////////////////////////////////////////////////////////////////////
23	23	/**
24	24	* A 3-dimensional data structure containing three floats. The floats have no particular meaning;
25		* when this data structure is used in Interpolators, we can think of it as a 3-dimensional Point
	25	* when this data structure is used in Dynamics, we can think of it as a 3-dimensional Point
26	26	* a few of which the Dynamic interpolates between.
27	27	*/
28	28
...	...
120	120	{
121	121	return z;
122	122	}
123
124		///////////////////////////////////////////////////////////////////////////////////////////////////
125		// end of class
	123
126	124	}

src/main/java/org/distorted/library/type/Static4D.java
126	126	{
127	127	return w;
128	128	}
129
130		///////////////////////////////////////////////////////////////////////////////////////////////////
131		// end of class
	129
132	130	}

src/main/java/org/distorted/library/type/Static5D.java
132	132	{
133	133	return v;
134	134	}
135
136		///////////////////////////////////////////////////////////////////////////////////////////////////
137		// end of class
	135
138	136	}

Project

General

Profile

Distorted Android

Revision cacc63de

Added by Leszek Koltunski about 8 years ago