/ - Diff - Distorted Android

+            }
+          }
         mainVertHeader += ("#define NUM_VERTEX "   + ( foundV ? getMaxVertex()   : 0 ) + "\n");
         mainFragHeader += ("#define NUM_FRAGMENT " + ( foundF ? getMaxFragment() : 0 ) + "\n");
         mainVertHeader += ("#define NUM_VERTEX "   + ( foundV ? getMax(EffectType.VERTEX  ) : 0 ) + "\n");
         mainFragHeader += ("#define NUM_FRAGMENT " + ( foundF ? getMax(EffectType.FRAGMENT) : 0 ) + "\n");
         //android.util.Log.e("Effects", "vertHeader= "+mainVertHeader);
         //android.util.Log.e("Effects", "fragHeader= "+mainFragHeader);
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns the maximum number of Matrix effects.
      * Returns the maximum number of effects of a given type.
+     *
      * @return The maximum number of Matrix effects
      * @param type {@link EffectType}
      * @return The maximum number of effects of a given type.
      */
       @SuppressWarnings("unused")
       public static int getMaxMatrix()
       public static int getMax(EffectType type)
+        {
         return EffectQueue.getMax(EffectType.MATRIX.ordinal());
         return EffectQueue.getMax(type.ordinal());
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns the maximum number of Vertex effects.
+     *
      * @return The maximum number of Vertex effects
      */
       @SuppressWarnings("unused")
       public static int getMaxVertex()
+        {
         return EffectQueue.getMax(EffectType.VERTEX.ordinal());
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns the maximum number of Fragment effects.
+     *
      * @return The maximum number of Fragment effects
      */
       @SuppressWarnings("unused")
       public static int getMaxFragment()
+        {
         return EffectQueue.getMax(EffectType.FRAGMENT.ordinal());
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns the maximum number of Postprocess effects.
+     *
      * @return The maximum number of Postprocess effects
      */
       @SuppressWarnings("unused")
       public static int getMaxPostprocess()
+        {
         return EffectQueue.getMax(EffectType.POSTPROCESS.ordinal());
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the maximum number of Matrix effects that can be stored in a single EffectQueue at one time.
      * Sets the maximum number of 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>Furthermore, this needs to be called before any instances of the DistortedEffects class get created.
      * </ul>
+     *
      * @param max new maximum number of simultaneous Matrix Effects. Has to be a non-negative number not greater
      *            than Byte.MAX_VALUE
      * @return <code>true</code> if operation was successful, <code>false</code> otherwise.
      */
       @SuppressWarnings("unused")
       public static boolean setMaxMatrix(int max)
+        {
         return EffectQueue.setMax(EffectType.MATRIX.ordinal(),max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * 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 Distorted#onCreate}. After this
      *     time only decreasing the value of 'max' is permitted.
     * <li>Furthermore, this needs to be called before any instances of the DistortedEffects class get created.
      * </ul>
+     *
      * @param max new maximum number of simultaneous Vertex Effects. Has to be a non-negative number not greater
      *            than Byte.MAX_VALUE
      * @return <code>true</code> if operation was successful, <code>false</code> otherwise.
      */
       @SuppressWarnings("unused")
       public static boolean setMaxVertex(int max)
+        {
         return EffectQueue.setMax(EffectType.VERTEX.ordinal(),max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * 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 Distorted#onCreate}. After this
      *     time only decreasing the value of 'max' is permitted.
      * <li>Furthermore, this needs to be called before any instances of the DistortedEffects class get created.
      * </ul>
+     *
      * @param max new maximum number of simultaneous Fragment Effects. Has to be a non-negative number not greater
      *            than Byte.MAX_VALUE
      * @return <code>true</code> if operation was successful, <code>false</code> otherwise.
      */
       @SuppressWarnings("unused")
       public static boolean setMaxFragment(int max)
+        {
         return EffectQueue.setMax(EffectType.FRAGMENT.ordinal(),max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the maximum number of Postprocess 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 Distorted#onCreate}. After this
      *     time only decreasing the value of 'max' is permitted.
      * <li>Furthermore, this needs to be called before any instances of the DistortedEffects class get created.
      * </ul>
+     *
      * @param max new maximum number of simultaneous Postprocess Effects. Has to be a non-negative number not greater
      * @param type {@link EffectType}
      * @param max new maximum number of simultaneous effects. Has to be a non-negative number not greater
      *            than Byte.MAX_VALUE
      * @return <code>true</code> if operation was successful, <code>false</code> otherwise.
      */
       @SuppressWarnings("unused")
       public static boolean setMaxPostprocess(int max)
       public static boolean setMax(EffectType type, int max)
+        {
         return EffectQueue.setMax(EffectType.POSTPROCESS.ordinal(),max);
         return EffectQueue.setMax(type.ordinal(),max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

             object = job.object;
             //android.util.Log.d("Object", object.getClass().getSimpleName()+"  ---> need to "
             //                  +(job.action==JOB_CREATE ? "create":"delete")+" objectID="+object.mID );
             //                  +(job.action==JOB_CREATE ? "create":"delete")+" objectID="+object.mDistortedEffectsID );
             if( job.action==JOB_CREATE )
+              {

       protected static int[] mMax = new int[EffectType.LENGTH];
       protected Vector<EffectListener> mListeners =null;
       protected int mNumListeners=0;  // ==mListeners.length(), but we only create mListeners if the first one gets added
       protected long mID;
       protected long mDistortedEffectsID;
       private static boolean mCreated;
       private int mIndex;
-...
       EffectQueue(long id, int numUniforms, int index)
+        {
         mNumEffects  = 0;
         mID          = id;
         mIndex       = index;
         mNumUniforms = numUniforms;
         mNumEffects         = 0;
         mDistortedEffectsID = id;
         mIndex              = index;
         mNumUniforms        = numUniforms;
         int max = mMax[mIndex];
-...
           if( notify )
+            {
             for(int j=0; j<mNumListeners; j++)
               EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_REMOVED, mEffects[i].getID(), mID);
               EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_REMOVED, mEffects[i].getID(), mDistortedEffectsID);
+            }
           mEffects[i] = null;
-...
         mEffects[mNumEffects] = null;
         for(int i=0; i<mNumListeners; i++)
           EffectMessageSender.newMessage( mListeners.elementAt(i), EffectMessage.EFFECT_REMOVED, removedID, mID);
           EffectMessageSender.newMessage( mListeners.elementAt(i), EffectMessage.EFFECT_REMOVED, removedID, mDistortedEffectsID);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

src/main/java/org/distorted/library/main/EffectQueueFragment.java
66	66	if( mEffects[i].compute(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i], step) )
67	67	{
68	68	for(int j=0; j<mNumListeners; j++)
69		EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mID);
	69	EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);
70	70
71	71	if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )
72	72	{

           if( mEffects[i].compute(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i], step) )
+            {
             for(int j=0; j<mNumListeners; j++)
               EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mID);
               EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);
             if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )
               remove(i--);

src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
187	187	if( mEffects[i].compute(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i], step) )
188	188	{
189	189	for(int j=0; j<mNumListeners; j++)
190		EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mID);
	190	EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);
191	191
192	192	if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )
193	193	{

src/main/java/org/distorted/library/main/EffectQueueVertex.java
66	66	if( mEffects[i].compute(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i], step) )
67	67	{
68	68	for(int j=0; j<mNumListeners; j++)
69		EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mID);
	69	EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);
70	70
71	71	if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )
72	72	{

src/main/java/org/distorted/library/program/DistortedProgram.java
22	22	import android.opengl.GLES30;
23	23	import android.os.Build;
24	24
	25	import org.distorted.library.effect.EffectType;
25	26	import org.distorted.library.main.DistortedEffects;
26	27
27	28	import java.io.BufferedReader;
...	...
201	202	int realMaxV = (maxV-11)/4; // adjust this in case of changes to the shaders...
202	203	int realMaxF = (maxF- 2)/4; //
203	204
204		if( DistortedEffects.getMaxVertex() > realMaxV )
	205	if( DistortedEffects.getMax(EffectType.VERTEX) > realMaxV )
205	206	{
206	207	throw new VertexUniformsException("Too many effects in the vertex shader, max is "+realMaxV, realMaxV);
207	208	}
208		if( DistortedEffects.getMaxFragment() > realMaxF )
	209	if( DistortedEffects.getMax(EffectType.FRAGMENT) > realMaxF )
209	210	{
210	211	throw new FragmentUniformsException("Too many effects in the fragment shader, max is "+realMaxF, realMaxF);
211	212	}

Project

General

Profile

Distorted Android

Revision fe6fe99a

Added by Leszek Koltunski over 8 years ago