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

« Previous | Next »

Revision 13687207

Added by Leszek Koltunski about 7 years ago

ID 13687207bddb02b0bcbb378cb0b372fe8949567b
Parent e137d4f5
Child e02264ff

Separate the Postprocessing Effects to their own DistortedEffectsPostprocess queue.
This partly breaks Multiblur (to be debugged)

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Class containing {@link EffectTypes#LENGTH} queues, each a class derived from EffectQueue.
      * Class containing Matrix,Vertex and Fragment effect queues. Postprocessing queue is held in a separate
      * class.
      * <p>
      * The queues hold actual effects to be applied to a given (DistortedTexture,MeshObject) combo.
      */
-...
       private EffectQueueMatrix      mM;
       private EffectQueueFragment    mF;
       private EffectQueueVertex      mV;
       private EffectQueuePostprocess mP;
       private boolean matrixCloned, vertexCloned, fragmentCloned, postprocessCloned;
       private boolean matrixCloned, vertexCloned, fragmentCloned;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
           mF = new EffectQueueFragment(mID);
           fragmentCloned = false;
+          }
         if( (flags & Distorted.CLONE_POSTPROCESS) != 0 )
+          {
           mP = d.mP;
           postprocessCloned = true;
+          }
         else
+          {
           mP = new EffectQueuePostprocess(mID);
           postprocessCloned = false;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       EffectQueuePostprocess getPostprocess()
+        {
         return mP;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       int postprocessPriv(long currTime, DistortedOutputSurface surface)
+        {
         return mP.postprocess(currTime,surface);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void drawPriv(float halfW, float halfH, MeshObject mesh, DistortedOutputSurface surface, long currTime)
-...
         if( !matrixCloned     ) mM.abortAll(false);
         if( !vertexCloned     ) mV.abortAll(false);
         if( !fragmentCloned   ) mF.abortAll(false);
         if( !postprocessCloned) mP.abortAll(false);
         mM = null;
         mV = null;
         mF = null;
         mP = null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     /**
      * Releases all resources. After this call, the queue should not be used anymore.
      */
       @SuppressWarnings("unused")
       public synchronized void delete()
+        {
         releasePriv();
-...
+     *
      * @param el A class implementing the EffectListener interface that wants to get notifications.
      */
       @SuppressWarnings("unused")
       public void registerForMessages(EffectListener el)
+        {
         mV.registerForMessages(el);
         mF.registerForMessages(el);
         mM.registerForMessages(el);
         mP.registerForMessages(el);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+     *
      * @param el A class implementing the EffectListener interface that no longer wants to get notifications.
      */
       @SuppressWarnings("unused")
       public void deregisterForMessages(EffectListener el)
+        {
         mV.deregisterForMessages(el);
         mF.deregisterForMessages(el);
         mM.deregisterForMessages(el);
         mP.deregisterForMessages(el);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * @return Number of effects aborted.
      */
       public int abortAllEffects()
+          {
           return mM.abortAll(true) + mV.abortAll(true) + mF.abortAll(true) + mP.abortAll(true);
+          }
+        {
         return mM.abortAll(true) + mV.abortAll(true) + mF.abortAll(true);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
-...
           case MATRIX     : return mM.abortAll(true);
           case VERTEX     : return mV.abortAll(true);
           case FRAGMENT   : return mF.abortAll(true);
           case POSTPROCESS: return mP.abortAll(true);
           default         : return 0;
+          }
+        }
-...
         if( type==EffectTypes.MATRIX.type      ) return mM.removeByID(id>>EffectTypes.LENGTH);
         if( type==EffectTypes.VERTEX.type      ) return mV.removeByID(id>>EffectTypes.LENGTH);
         if( type==EffectTypes.FRAGMENT.type    ) return mF.removeByID(id>>EffectTypes.LENGTH);
         if( type==EffectTypes.POSTPROCESS.type ) return mP.removeByID(id>>EffectTypes.LENGTH);
         return 0;
+        }
-...
           case MATRIX     : return mM.removeByType(name);
           case VERTEX     : return mV.removeByType(name);
           case FRAGMENT   : return mF.removeByType(name);
           case POSTPROCESS: return mP.removeByType(name);
           default         : return 0;
+          }
+        }
-...
      * @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);
         if( type==EffectTypes.POSTPROCESS.type )  return mP.printByID(id>>EffectTypes.LENGTH);
         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;
+        }
-...
+     *
      * @return The maximum number of Matrix effects
      */
       @SuppressWarnings("unused")
       public static int getMaxMatrix()
+        {
         return EffectQueue.getMax(EffectTypes.MATRIX.ordinal());
-...
+     *
      * @return The maximum number of Vertex effects
      */
       @SuppressWarnings("unused")
       public static int getMaxVertex()
+        {
         return EffectQueue.getMax(EffectTypes.VERTEX.ordinal());
-...
+     *
      * @return The maximum number of Fragment effects
      */
       @SuppressWarnings("unused")
       public static int getMaxFragment()
+        {
         return EffectQueue.getMax(EffectTypes.FRAGMENT.ordinal());
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns the maximum number of Postprocess effects.
+     *
      * @return The maximum number of Postprocess effects
      */
       public static int getMaxPostprocess()
+        {
         return EffectQueue.getMax(EffectTypes.POSTPROCESS.ordinal());
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the maximum number of Matrix effects that can be stored in a single EffectQueue at one time.
-...
      *            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(EffectTypes.MATRIX.ordinal(),max);
-...
      *            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(EffectTypes.VERTEX.ordinal(),max);
-...
      *            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(EffectTypes.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
      *            than Byte.MAX_VALUE
      * @return <code>true</code> if operation was successful, <code>false</code> otherwise.
      */
       public static boolean setMaxPostprocess(int max)
+        {
         return EffectQueue.setMax(EffectTypes.POSTPROCESS.ordinal(),max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Individual effect functions.
-...
+        {
         return mV.add(EffectNames.WAVE, wave, center, region);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Postprocess-based effects
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Blur the object.
+     *
      * @param radius The 'strength' if the effect, in pixels. 0 = no blur, 10 = when blurring a given pixel,
      *               take into account 10 pixels in each direction.
      * @return ID of the effect added, or -1 if we failed to add one.
      */
       public long blur(Data1D radius)
+        {
         return mP.add(EffectNames.BLUR, radius);
+        }
+      }

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision 13687207

Added by Leszek Koltunski about 7 years ago