/ - Diff - Distorted Android

           int realMaxV = (maxV-11)/4;   // adjust this in case of changes to the shaders...
           int realMaxF = (maxF- 2)/4;   //
           if( EffectQueueVertex.getMax() > realMaxV )
           if( getMaxVertex()   > realMaxV )
+            {
             throw new VertexUniformsException("Too many effects in the vertex shader, max is "+realMaxV, realMaxV);
+            }
           if( EffectQueueFragment.getMax() > realMaxF )
           if( getMaxFragment() > realMaxF )
+            {
             throw new FragmentUniformsException("Too many effects in the fragment shader, max is "+realMaxF, realMaxF);
+            }
-...
         switch(type)
+          {
           case GLES20.GL_VERTEX_SHADER  : header += ("#define NUM_VERTEX "  + EffectQueueVertex.getMax()+"\n");
           case GLES20.GL_VERTEX_SHADER  : header += ("#define NUM_VERTEX "  + getMaxVertex()+"\n");
                                           for(EffectNames name: EffectNames.values() )
+                                            {
-...
                                             header += ("#define "+name.name()+" "+name.ordinal()+"\n");
+                                            }
                                           break;
           case GLES20.GL_FRAGMENT_SHADER: header += ("#define NUM_FRAGMENT "+ EffectQueueFragment.getMax()+"\n");
           case GLES20.GL_FRAGMENT_SHADER: header += ("#define NUM_FRAGMENT "+ getMaxFragment()+"\n");
                                           for(EffectNames name: EffectNames.values() )
+                                            {
-...
+        {
         DistortedObjectList.release();
         DistortedNode.release();
         EffectQueueVertex.reset();
         EffectQueueFragment.reset();
         EffectQueueMatrix.reset();  // no need to reset Other EffectQueue
         EffectQueue.reset();
         EffectMessageSender.stopSending();
         mInitialized = false;
-...
      */
       public static int getMaxMatrix()
+        {
         return EffectQueueMatrix.getMax();
         return EffectQueue.getMax(EffectTypes.MATRIX.ordinal());
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public static int getMaxVertex()
+        {
         return EffectQueueVertex.getMax();
         return EffectQueue.getMax(EffectTypes.VERTEX.ordinal());
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public static int getMaxFragment()
+        {
         return EffectQueueFragment.getMax();
         return EffectQueue.getMax(EffectTypes.FRAGMENT.ordinal());
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns the maximum number of Other effects.
+     *
      * @return The maximum number of Other effects
      */
       public static int getMaxOther()
+        {
         return EffectQueue.getMax(EffectTypes.OTHER.ordinal());
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the maximum number of Matrix effects that can be applied to a single DistortedBitmap at one time.
      * Sets the maximum number of Matrix effects that can be applied to a single DistortedObject at one time.
      * This can fail if the value of 'max' is outside permitted range.
+     *
      * @param max new maximum number of simultaneous Matrix Effects. Has to be a non-negative number not greater
-...
      */
       public static boolean setMaxMatrix(int max)
+        {
         return EffectQueueMatrix.setMax(max);
         return EffectQueue.setMax(EffectTypes.MATRIX.ordinal(),max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the maximum number of Vertex effects that can be applied to a single DistortedBitmap at one time.
      * Sets the maximum number of Vertex effects that can be applied to a single DistortedObject at one time.
      * This can fail if:
      * <ul>
      * <li>the value of 'max' is outside permitted range
-...
      */
       public static boolean setMaxVertex(int max)
+        {
         return EffectQueueVertex.setMax(max);
         return EffectQueue.setMax(EffectTypes.VERTEX.ordinal(),max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the maximum number of Fragment effects that can be applied to a single DistortedBitmap at one time.
      * Sets the maximum number of Fragment effects that can be applied to a single DistortedObject at one time.
      * This can fail if:
      * <ul>
      * <li>the value of 'max' is outside permitted range
-...
      */
       public static boolean setMaxFragment(int max)
+        {
         return EffectQueueFragment.setMax(max);
         return EffectQueue.setMax(EffectTypes.FRAGMENT.ordinal(),max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the maximum number of Other effects that can be applied to a single DistortedObject at one time.
      * This can fail if the value of 'max' is outside permitted range.
+     *
      * @param max new maximum number of simultaneous Other 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 setMaxOther(int max)
+        {
         return EffectQueue.setMax(EffectTypes.OTHER.ordinal(),max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     //end of file
+    }

       protected static int[] mMax = new int[EffectTypes.LENGTH];
       protected int mMaxIndex;
       protected static boolean mCreated;
       protected Vector<EffectListener> mListeners =null;
       protected int mNumListeners=0;  // ==mListeners.length(), but we only create mListeners if the first one gets added
       protected long mBitmapID;
       private static boolean mCreated;
       static
+        {
         reset();
-...
         return mNumEffects;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Only max Byte.MAX_VALUE concurrent effects per DistortedObject.
     // If you want more, change type of the mNumEffects, mIDIndex and mFreeIndexes variables to shorts.
       static boolean setMax(int index, int m)
+        {
         if( (mCreated==false && !Distorted.isInitialized()) || m<=mMax[index] )
+          {
           if( m<0              ) m = 0;
           else if( m>Byte.MAX_VALUE ) m = Byte.MAX_VALUE;
           mMax[index] = m;
           return true;
+          }
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static int getMax(int index)
+        {
         return mMax[index];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void addListener(EffectListener el)

           mBuf= new float[4*mMax[INDEX]];
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Only max Byte.MAX_VALUE concurrent effects per bitmap.
     // If you want more, change type of the mNumEffects, mIDIndex and mFreeIndexes variables to shorts.
       static boolean setMax(int m)
+        {
         if( (mCreated==false && !Distorted.isInitialized()) || m<=mMax[INDEX] )
+          {
                if( m<0              ) m = 0;
           else if( m>Byte.MAX_VALUE ) m = Byte.MAX_VALUE;
           mMax[INDEX] = m;
           return true;
+          }
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static int getMax()
+        {
         return mMax[INDEX];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

         Matrix.multiplyMM(mMVPMatrix, 0, matrix, 0, mTmpMatrix, 0);
         for(int j=0; j<16; j++) matrix[j] = mMVPMatrix[j];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Only max Byte.MAX_VALUE concurrent effects per bitmap.
     // If you want more, change type of the mNumEffects, mIDIndex and mFreeIndexes variables to shorts.
       static boolean setMax(int m)
+        {
         if( (mCreated==false && !Distorted.isInitialized()) || m<=mMax[INDEX] )
+          {
                if( m<0              ) m = 0;
           else if( m>Byte.MAX_VALUE ) m = Byte.MAX_VALUE;
           mMax[INDEX] = m;
           return true;
+          }
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static int getMax()
+        {
         return mMax[INDEX];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     import java.util.Vector;
     /**
      * Do NOT base this on EffectQueue - this is an entirely different animal than the first 3 EffectLists.
      * The Effects in here will be executed after all the shaders have been executed - thus there are no
      * uniforms to send, no real queues to maintain.
      * <p>
      * Only 2 effects here ATM:
      * - save current Surface to a PNG file
      * - save current animation to a .MP4 file
+     *
      * In contrast to the other EffectLists, only one instance of each allowed at any given moment - thus
      * this is not even a real EffectQueue, it is named so only for consistency with the others.
      */
     public class EffectQueueOther
     class EffectQueueOther extends EffectQueue
+      {
       private Vector<EffectListener> mListeners =null;
       private int mNumListeners=0;  // ==mListeners.length(), but we only create mListeners if the first one gets added
       private static final int NUM_UNIFORMS = 0;
       private static final int INDEX = EffectTypes.OTHER.ordinal();
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public EffectQueueOther(DistortedObject obj)
+        {
         super(obj,NUM_UNIFORMS, INDEX );
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // There are no Uniforms, nothing to move
       synchronized void send()
       protected void moveEffect(int index)
+        {
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       synchronized int abortAll()
+        {
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void addListener(EffectListener el)
+        {
         if( mListeners==null ) mListeners = new Vector<>(2,2);
         mListeners.add(el);
         mNumListeners++;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void removeListener(EffectListener el)
+        {
         if( mNumListeners>0 )
+          {
           mListeners.remove(el);
           mNumListeners--;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       synchronized boolean removeByID(long id)
+        {
         //....
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       synchronized boolean removeByType(EffectNames effect)
       synchronized void send()
+        {
         // ...
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected boolean printByID(long id)
+        {
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

+        {
         super(obj,NUM_UNIFORMS,INDEX);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Only max Byte.MAX_VALUE concurrent effects per bitmap.
     // If you want more, change type of the mNumEffects, mIDIndex and mFreeIndexes variables to shorts.
       static boolean setMax(int m)
+        {
         if( (mCreated==false && !Distorted.isInitialized()) || m<=mMax[INDEX] )
+          {
                if( m<0              ) m = 0;
           else if( m>Byte.MAX_VALUE ) m = Byte.MAX_VALUE;
           mMax[INDEX] = m;
           return true;
+          }
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static int getMax()
+        {
         return mMax[INDEX];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Project

General

Profile

Distorted Android

Revision 71887484

Added by Leszek Koltunski over 8 years ago