/ - Diff - Distorted Android

« Previous | Next »

Revision a0397f32

Added by Leszek Koltunski about 5 years ago

ID a0397f32e7fc50a45104fe3f567bb8383e7b1628
Parent e37d470b
Child bfe45b4a

Make DistortedEffects oblivious of the effect types.

src/main/java/org/distorted/library/main/DistortedChildrenList.java
99	99	void addSortingByBuckets(DistortedNode newChild)
100	100	{
101	101	int i;
102		long bucket = newChild.getEffects().getPostprocess().getID();
	102	EffectQueue queue = newChild.getEffects().getQueues()[3];
	103	long bucket = queue.getID();
103	104	boolean sameBucket = false;
104	105
105	106	for(i=0; i<mNumChildren; i++)
106	107	{
107		if( mChildren.get(i).getEffects().getPostprocess().getID() == bucket )
	108	queue = mChildren.get(i).getEffects().getQueues()[3];
	109
	110	if( queue.getID() == bucket )
108	111	{
109	112	sameBucket=true;
110	113	}

       private static long mNextID =0;
       private long mID;
       private EffectQueueMatrix mM;
       private EffectQueueFragment mF;
       private EffectQueueVertex mV;
       private EffectQueuePostprocess mP;
       private boolean matrixCloned, vertexCloned, fragmentCloned, postprocessCloned;
       private EffectQueue[] mQueues;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         String enabledEffectV= VertexEffect.getGLSL();
         String enabledEffectF= FragmentEffect.getGLSL();
         //android.util.Log.e("Effects", "vertHeader= "+mainVertHeader);
         //android.util.Log.e("Effects", "fragHeader= "+mainFragHeader);
         //android.util.Log.e("Effects", "enabledV= "+enabledEffectV);
         //android.util.Log.e("Effects", "enabledF= "+enabledEffectF);
         String[] feedback = { "v_Position", "v_endPosition" };
         try
-...
+          }
         int mainProgramH = mMainProgram.getProgramHandle();
         EffectQueueFragment.getUniforms(mainProgramH,0);
         EffectQueueVertex.getUniforms(mainProgramH,0);
         EffectQueueMatrix.getUniforms(mainProgramH,0);
         EffectQueue.getUniforms(mainProgramH,0);
         mMainTextureH= GLES31.glGetUniformLocation( mainProgramH, "u_Texture");
         // BLIT PROGRAM ////////////////////////////////////
-...
+          }
         int mainOITProgramH = mMainOITProgram.getProgramHandle();
         EffectQueueFragment.getUniforms(mainOITProgramH,1);
         EffectQueueVertex.getUniforms(mainOITProgramH,1);
         EffectQueueMatrix.getUniforms(mainOITProgramH,1);
         EffectQueue.getUniforms(mainOITProgramH,1);
         mMainOITTextureH    = GLES31.glGetUniformLocation( mainOITProgramH, "u_Texture");
         mMainOITSizeH       = GLES31.glGetUniformLocation( mainOITProgramH, "u_Size");
         mMainOITNumRecordsH = GLES31.glGetUniformLocation( mainOITProgramH, "u_numRecords");
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void initializeEffectLists(DistortedEffects d, int flags)
       EffectQueue[] getQueues()
+        {
         if( (flags & Distorted.CLONE_MATRIX) != 0 )
+          {
           mM = d.mM;
           matrixCloned = true;
+          }
         else
+          {
           mM = new EffectQueueMatrix(mID);
           matrixCloned = false;
+          }
         if( (flags & Distorted.CLONE_VERTEX) != 0 )
+          {
           mV = d.mV;
           vertexCloned = true;
+          }
         else
+          {
           mV = new EffectQueueVertex(mID);
           vertexCloned = false;
+          }
         if( (flags & Distorted.CLONE_FRAGMENT) != 0 )
+          {
           mF = d.mF;
           fragmentCloned = true;
+          }
         else
+          {
           mF = new EffectQueueFragment(mID);
           fragmentCloned = false;
+          }
         if( (flags & Distorted.CLONE_POSTPROCESS) != 0 )
+          {
           mP = d.mP;
           postprocessCloned = true;
+          }
         else
+          {
           mP = new EffectQueuePostprocess(mID);
           postprocessCloned = false;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       EffectQueueMatrix getMatrix()
+        {
         return mM;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       EffectQueueVertex getVertex()
+        {
         return mV;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       EffectQueueFragment getFragment()
+        {
         return mF;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       EffectQueuePostprocess getPostprocess()
+        {
         return mP;
         return mQueues;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void newNode(DistortedNode node)
+        {
         mP.newNode(node);
         EffectQueue.newNode(mQueues,node);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void removeNode(DistortedNode node)
+        {
         mP.removeNode(node);
         EffectQueue.removeNode(mQueues,node);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         GLES31.glBindBufferBase(GLES31.GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
         mNormalProgram.useProgram();
         GLES31.glUniformMatrix4fv(mNormalMVPMatrixH, 1, false, mM.getMVP() , 0);
         GLES31.glUniformMatrix4fv(mNormalMVPMatrixH, 1, false, EffectQueue.getMVP(mQueues) , 0);
         mesh.bindTransformAttribs(mNormalProgram);
         GLES31.glLineWidth(8.0f);
         GLES31.glDrawArrays(GLES31.GL_LINES, 0, 2*num);
-...
+        {
         float halfZ = halfW*mesh.getZFactor();
         mM.compute(currTime);
         mV.compute(currTime,halfW,halfH,halfZ);
         mF.compute(currTime,halfW,halfH,halfZ);
         mP.compute(currTime);
         EffectQueue.compute(mQueues, currTime, halfW, halfH, halfZ );
         GLES31.glViewport(0, 0, surface.mWidth, surface.mHeight );
         mMainOITProgram.useProgram();
-...
         float inflate = mesh.getInflate();
         mM.send(surface,halfW,halfH,halfZ,1);
         mV.send(inflate,1);
         mF.send(1);
         EffectQueue.send(mQueues, surface, inflate, halfW, halfH, halfZ, 1 );
         GLES31.glDrawArrays(GLES31.GL_TRIANGLE_STRIP, 0, mesh.getNumVertices() );
         if( mesh.getShowNormals() )
+          {
           mMainProgram.useProgram();
           mM.send(surface,halfW,halfH,halfZ,0);
           mV.send(inflate,0);
           mF.send(0);
           EffectQueue.send(mQueues, surface, inflate, halfW, halfH, halfZ, 0 );
           displayNormals(mesh);
+          }
+        }
-...
+        {
         float halfZ = halfW*mesh.getZFactor();
         mM.compute(currTime);
         mV.compute(currTime,halfW,halfH,halfZ);
         mF.compute(currTime,halfW,halfH,halfZ);
         mP.compute(currTime);
         EffectQueue.compute(mQueues, currTime, halfW, halfH, halfZ );
         GLES31.glViewport(0, 0, surface.mWidth, surface.mHeight );
         mMainProgram.useProgram();
         GLES31.glUniform1i(mMainTextureH, 0);
         mesh.bindVertexAttribs(mMainProgram);
         mM.send(surface,halfW,halfH,halfZ,0);
         mV.send( mesh.getInflate(),0);
         mF.send(0);
         EffectQueue.send(mQueues, surface, mesh.getInflate(), halfW, halfH, halfZ, 0 );
         GLES31.glDrawArrays(GLES31.GL_TRIANGLE_STRIP, 0, mesh.getNumVertices() );
         if( mesh.getShowNormals() ) displayNormals(mesh);
-...
         GLES31.glDrawArrays(GLES31.GL_TRIANGLE_STRIP, 0, 4);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void releasePriv()
+        {
         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;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static void onPause()
-...
       public DistortedEffects()
+        {
         mID = ++mNextID;
         initializeEffectLists(this,0);
         mQueues = new EffectQueue[EffectType.LENGTH];
         EffectQueue.allocateQueues(mQueues,null,0,mID);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public DistortedEffects(DistortedEffects dc, int flags)
+        {
         mID = ++mNextID;
         initializeEffectLists(dc,flags);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Releases all resources. After this call, the queue should not be used anymore.
      */
       @SuppressWarnings("unused")
       public synchronized void delete()
+        {
         releasePriv();
         mQueues = new EffectQueue[EffectType.LENGTH];
         EffectQueue.allocateQueues(mQueues,dc.getQueues(),flags,mID);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       @SuppressWarnings("unused")
       public void registerForMessages(EffectListener el)
+        {
         mM.registerForMessages(el);
         mV.registerForMessages(el);
         mF.registerForMessages(el);
         mP.registerForMessages(el);
         for( int i=0; i<EffectType.LENGTH; i++)
+          {
           mQueues[i].registerForMessages(el);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       @SuppressWarnings("unused")
       public void deregisterForMessages(EffectListener el)
+        {
         mM.deregisterForMessages(el);
         mV.deregisterForMessages(el);
         mF.deregisterForMessages(el);
         mP.deregisterForMessages(el);
         for( int i=0; i<EffectType.LENGTH; i++)
+          {
           mQueues[i].deregisterForMessages(el);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public int abortAllEffects()
+        {
         return mM.abortAll(true) + mV.abortAll(true) + mF.abortAll(true) + mP.abortAll(true);
         int aborted = 0;
         for( int i=0; i<EffectType.LENGTH; i++)
+          {
           aborted += mQueues[i].abortAll(true);
+          }
         return aborted;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public int abortByType(EffectType type)
+        {
         switch(type)
+          {
           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;
+          }
         int num = type.ordinal();
         return mQueues[num].abortAll(true);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public int abortById(long id)
+        {
         long type = id&EffectType.MASK;
         if( type == EffectType.MATRIX.ordinal()      ) return mM.removeById(id);
         if( type == EffectType.VERTEX.ordinal()      ) return mV.removeById(id);
         if( type == EffectType.FRAGMENT.ordinal()    ) return mF.removeById(id);
         if( type == EffectType.POSTPROCESS.ordinal() ) return mP.removeById(id);
         return 0;
         int num = (int)(id&EffectType.MASK);
         return mQueues[num].removeById(id);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public int abortEffect(Effect effect)
+        {
         switch(effect.getType())
+          {
           case MATRIX     : return mM.removeEffect(effect);
           case VERTEX     : return mV.removeEffect(effect);
           case FRAGMENT   : return mF.removeEffect(effect);
           case POSTPROCESS: return mP.removeEffect(effect);
           default         : return 0;
+          }
         int num = effect.getType().ordinal();
         return mQueues[num].removeEffect(effect);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public int abortByName(EffectName name)
+        {
         switch(name.getType())
+          {
           case MATRIX     : return mM.removeByName(name);
           case VERTEX     : return mV.removeByName(name);
           case FRAGMENT   : return mF.removeByName(name);
           case POSTPROCESS: return mP.removeByName(name);
           default                : return 0;
+          }
         int num = name.getType().ordinal();
         return mQueues[num].removeByName(name);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public boolean apply(Effect effect)
+        {
         switch(effect.getType())
+          {
           case MATRIX      : return mM.add(effect);
           case VERTEX      : return mV.add(effect);
           case FRAGMENT    : return mF.add(effect);
           case POSTPROCESS : return mP.add(effect);
+          }
         return false;
         int num = effect.getType().ordinal();
         return mQueues[num].add(effect);
+        }
+      }

         for(int i=0; i<numChildren; i++)
+          {
           child = children.getChild(i);
           currQueue = child.getEffects().getPostprocess();
           currQueue = (EffectQueuePostprocess)child.getEffects().getQueues()[3];
           currBucket= currQueue.getID();
           if( currBucket==0 )

         DistortedMaster.newSlave(this);                     // of uniforms later, on first render.
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // queues - guaranteed to be an array of EffectType.LENGTH length.
     // Change this when creating a new ty[e of effect!
       static void allocateQueues(EffectQueue[] queues, EffectQueue[] from, int flags, long id)
+        {
         queues[0] = (flags & Distorted.CLONE_MATRIX     ) != 0 ? from[0] : new EffectQueueMatrix(id);
         queues[1] = (flags & Distorted.CLONE_VERTEX     ) != 0 ? from[1] : new EffectQueueVertex(id);
         queues[2] = (flags & Distorted.CLONE_FRAGMENT   ) != 0 ? from[2] : new EffectQueueFragment(id);
         queues[3] = (flags & Distorted.CLONE_POSTPROCESS) != 0 ? from[3] : new EffectQueuePostprocess(id);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // queues - guaranteed to be an array of EffectType.LENGTH length.
     // Change this when creating a new ty[e of effect!
       static void compute(EffectQueue[] queues, long currTime, float halfW, float halfH, float halfZ )
+        {
         ((EffectQueueMatrix     )queues[0]).compute(currTime);
         ((EffectQueueVertex     )queues[1]).compute(currTime,halfW,halfH,halfZ);
         ((EffectQueueFragment   )queues[2]).compute(currTime,halfW,halfH,halfZ);
         ((EffectQueuePostprocess)queues[3]).compute(currTime);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // queues - guaranteed to be an array of EffectType.LENGTH length.
     // Change this when creating a new ty[e of effect!
       static void send(EffectQueue[] queues, DistortedOutputSurface surface, float inflate, float halfW, float halfH, float halfZ, int variant )
+        {
         ((EffectQueueMatrix  )queues[0]).send(surface,halfW,halfH,halfZ, variant);
         ((EffectQueueVertex  )queues[1]).send(inflate, variant);
         ((EffectQueueFragment)queues[2]).send(variant);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // queues - guaranteed to be an array of EffectType.LENGTH length.
     // Change this when creating a new ty[e of effect!
       static float[] getMVP(EffectQueue[] queues)
+        {
         return ((EffectQueueMatrix  )queues[0]).getMVP();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // queues - guaranteed to be an array of EffectType.LENGTH length.
     // Change this when creating a new ty[e of effect!
       static void newNode(EffectQueue[] queues, DistortedNode node)
+        {
         queues[3].newNode(node);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // queues - guaranteed to be an array of EffectType.LENGTH length.
     // Change this when creating a new ty[e of effect!
       static void removeNode(EffectQueue[] queues, DistortedNode node)
+        {
         queues[3].removeNode(node);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // queues - guaranteed to be an array of EffectType.LENGTH length.
     // Change this when creating a new ty[e of effect!
       static void getUniforms(int programH, int variant)
+        {
         EffectQueueFragment.getUniforms(programH,variant);
         EffectQueueVertex  .getUniforms(programH,variant);
         EffectQueueMatrix  .getUniforms(programH,variant);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Every effect queue has an ID, which should be the same iff two queues hold the same effects.
     // (this is a speedup: then both queues can be applied once, which seriously speeds up stuff -
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void newNode(DistortedNode node)
       private void newNode(DistortedNode node)
+        {
         if( mNodes==null ) mNodes = new ArrayList<>();
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void removeNode(DistortedNode node)
       private void removeNode(DistortedNode node)
+        {
         mNodes.remove(node);
+        }

           mesh.bindVertexAttribs(mPreProgram);
           DistortedEffects effects = node.getEffects();
           EffectQueueMatrix matrix = effects.getMatrix();
           EffectQueueVertex vertex = effects.getVertex();
           EffectQueue[] queues = node.getEffects().getQueues();
           EffectQueueMatrix matrix = (EffectQueueMatrix)queues[0];
           EffectQueueVertex vertex = (EffectQueueVertex)queues[1];
           float inflate=0.0f;

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision a0397f32

Added by Leszek Koltunski about 5 years ago