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

« Previous | Next »

Revision 56c6ca24

Added by Leszek Koltunski almost 6 years ago

ID 56c6ca24708e7b8a785a511d4fe401da25e0b475
Parent 27aefee6
Child 7f30ed38

OIT: lots of progress on all fronts. Still a few bugs to solve though!

       // Global buffers used for postprocessing.
       private static DistortedOutputSurface[] mBuffer = new DistortedOutputSurface[EffectQuality.LENGTH];
       private static DistortedOutputSurface   mBufferOIT;
       private long mTime;
       private float mFOV;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private static void createBuffers(int width, int height, float near)
       private static void createPostprocessingBuffers(int width, int height, float near)
+        {
         float mipmap=1.0f;
         for(int j=0; j<EffectQuality.LENGTH; j++)
         for (int j=0; j<EffectQuality.LENGTH; j++)
+          {
           mBuffer[j] = new DistortedFramebuffer(2,BOTH_DEPTH_STENCIL,TYPE_SYST, (int)(width*mipmap), (int)(height*mipmap) );
           mBuffer[j] = new DistortedFramebuffer(2, BOTH_DEPTH_STENCIL, TYPE_SYST, (int) (width * mipmap), (int) (height * mipmap));
           mBuffer[j].mMipmap = mipmap;
           mBuffer[j].mNear   = near;  // copy mNear as well (for blitting- see PostprocessEffect.apply() )
           mBuffer[j].glClearColor(1.0f,1.0f,1.0f,0.0f);
           mBuffer[j].mNear = near;  // copy mNear as well (for blitting- see PostprocessEffect.apply() )
           mBuffer[j].glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
           mipmap *= EffectQuality.MULTIPLIER;
+          }
-...
         GLES31.glStencilMask(0xff);
         GLES31.glDepthMask(true);
         GLES31.glColorMask(true,true,true,true);
         GLES31.glClearColor(1.0f,1.0f,1.0f,0.0f);
         GLES31.glColorMask(true, true, true, true);
         GLES31.glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
         GLES31.glClearDepthf(1.0f);
         GLES31.glClearStencil(0);
         for(int j=0; j<EffectQuality.LENGTH; j++)
         for (int j=0; j<EffectQuality.LENGTH; j++)
+          {
           mBuffer[j].setAsOutput();
           GLES31.glFramebufferTexture2D(GLES31.GL_FRAMEBUFFER, GLES31.GL_COLOR_ATTACHMENT0, GLES31.GL_TEXTURE_2D, mBuffer[j].mColorH[1], 0);
           GLES31.glClear(GLES31.GL_COLOR_BUFFER_BIT|GLES31.GL_DEPTH_BUFFER_BIT|GLES31.GL_STENCIL_BUFFER_BIT);
           GLES31.glClear(GLES31.GL_COLOR_BUFFER_BIT | GLES31.GL_DEPTH_BUFFER_BIT | GLES31.GL_STENCIL_BUFFER_BIT);
           GLES31.glFramebufferTexture2D(GLES31.GL_FRAMEBUFFER, GLES31.GL_COLOR_ATTACHMENT0, GLES31.GL_TEXTURE_2D, mBuffer[j].mColorH[0], 0);
           GLES31.glClear(GLES31.GL_COLOR_BUFFER_BIT);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private static void initializeOIT(DistortedOutputSurface surface)
+        {
         if( mBufferOIT==null )
+          {
           mBufferOIT = new DistortedFramebuffer(1, BOTH_DEPTH_STENCIL, TYPE_SYST, surface.mWidth, surface.mHeight);
           mBufferOIT.mMipmap = 1.0f;
           mBufferOIT.mNear = surface.mNear;  // copy mNear as well (for blitting- see PostprocessEffect.apply() )
           mBufferOIT.glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
           DistortedObject.toDo(); // create the FBOs immediately. This is safe as we must be holding the OpenGL context now.
           mBufferOIT.setAsOutput();
           GLES31.glFramebufferTexture2D(GLES31.GL_FRAMEBUFFER, GLES31.GL_COLOR_ATTACHMENT0, GLES31.GL_TEXTURE_2D, mBufferOIT.mColorH[0], 0);
           GLES31.glClear(GLES31.GL_COLOR_BUFFER_BIT | GLES31.GL_DEPTH_BUFFER_BIT | GLES31.GL_STENCIL_BUFFER_BIT);
+          }
         if( mBufferOIT.mWidth != surface.mWidth || mBufferOIT.mHeight != surface.mHeight )
+          {
           mBufferOIT.mWidth  = (int)(surface.mWidth *mBufferOIT.mMipmap);
           mBufferOIT.mHeight = (int)(surface.mHeight*mBufferOIT.mMipmap);
           mBufferOIT.mNear   = surface.mNear;  // Near plane is independent of the mipmap level
           //android.util.Log.e("surface", "viewport "+i+" to ("+from.mWidth+"x"+from.mHeight+")");
           mBufferOIT.createProjection();
           int maxw = mBufferOIT.mWidth  > mBufferOIT.mRealWidth  ? mBufferOIT.mWidth  : mBufferOIT.mRealWidth;
           int maxh = mBufferOIT.mHeight > mBufferOIT.mRealHeight ? mBufferOIT.mHeight : mBufferOIT.mRealHeight;
           if (maxw > mBufferOIT.mRealWidth || maxh > mBufferOIT.mRealHeight)
+            {
             mBufferOIT.mRealWidth = maxw;
             mBufferOIT.mRealHeight = maxh;
             mBufferOIT.recreate();
             mBufferOIT.create();
+            }
+          }
         if( mBufferOIT.mNear != surface.mNear || mBufferOIT.mFOV != surface.mFOV )
+          {
           mBufferOIT.mNear = surface.mNear;
           mBufferOIT.mFOV  = surface.mFOV;
           mBufferOIT.createProjection();
+          }
         GLES31.glBindFramebuffer(GLES31.GL_FRAMEBUFFER, mBufferOIT.mFBOH[0]);
         DistortedRenderState.colorDepthStencilOn();
         GLES31.glClearColor(surface.mClearR, surface.mClearG, surface.mClearB, surface.mClearA);
         GLES31.glClearDepthf(surface.mClearDepth);
         GLES31.glClearStencil(surface.mClearStencil);
         GLES31.glClear(surface.mClear);
         DistortedRenderState.colorDepthStencilRestore();
         DistortedEffects.zeroOutAtomic();
         DistortedEffects.oitClear(surface);
         GLES31.glMemoryBarrier(GLES31.GL_SHADER_STORAGE_BARRIER_BIT|GLES31.GL_ATOMIC_COUNTER_BARRIER_BIT);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static synchronized void onDestroy()
-...
+          {
           mBuffer[j] = null;
+          }
         mBufferOIT = null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     // smaller. That takes care of outputting pixels to them. When we use them as input, we have to
     // adjust the texture coords - see the get{Width|Height}Correction functions.
       private static void cloneViewport(DistortedOutputSurface from)
       private static void clonePostprocessingViewport(DistortedOutputSurface from)
+        {
         if( mBuffer[0].mWidth != from.mWidth )
         if( mBuffer[0].mWidth != from.mWidth || mBuffer[0].mHeight != from.mHeight )
+          {
           DistortedOutputSurface surface;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int blitWithDepth(long currTime, DistortedOutputSurface buffer)
       private int oitBuild(long currTime, DistortedOutputSurface buffer)
+        {
         GLES31.glViewport(0, 0, mWidth, mHeight);
         setAsOutput(currTime);
-...
         GLES31.glActiveTexture(GLES31.GL_TEXTURE1);
         GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, buffer.mDepthStencilH[0]);
         GLES31.glDisable(GLES31.GL_STENCIL_TEST);
         GLES31.glStencilMask(0x00);
         //GLES31.glDisable(GLES31.GL_STENCIL_TEST);
         //GLES31.glStencilMask(0x00);
         DistortedRenderState.colorDepthStencilOn();
         DistortedRenderState.enableDepthTest();
         DistortedEffects.blitDepth(this, buffer.getWidthCorrection(), buffer.getHeightCorrection() );
         DistortedEffects.oitBuild(this, buffer.getWidthCorrection(), buffer.getHeightCorrection() );
         GLES31.glActiveTexture(GLES31.GL_TEXTURE0);
         GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, 0);
         GLES31.glActiveTexture(GLES31.GL_TEXTURE1);
         GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, 0);
         DistortedRenderState.colorDepthStencilRestore();
         DistortedRenderState.restoreDepthTest();
         return 1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int mergeOIT(long currTime, DistortedOutputSurface buffer)
       private int oitRender(long currTime, DistortedOutputSurface buffer)
+        {
         GLES31.glViewport(0, 0, mWidth, mHeight);
         setAsOutput(currTime);
         GLES31.glActiveTexture(GLES31.GL_TEXTURE0);
         GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, buffer.mColorH[0]);
         GLES31.glActiveTexture(GLES31.GL_TEXTURE1);
         GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, buffer.mDepthStencilH[0]);
         DistortedRenderState.enableStencil();
         DistortedEffects.mergeOIT(this, buffer.getWidthCorrection(), buffer.getHeightCorrection() );
         DistortedEffects.oitRender(this, buffer.getWidthCorrection(), buffer.getHeightCorrection() );
         GLES31.glActiveTexture(GLES31.GL_TEXTURE1);
         GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, 0);
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Render all children, one by one. If there are no postprocessing effects, just render to THIS.
     // Otherwise, render to a buffer and on each change of Postprocessing Bucket, apply the postprocessing
     // to a whole buffer (lastQueue.postprocess) and merge it (this.blitWithDepth).
     // to a whole buffer (lastQueue.postprocess) and merge it (this.oitBuild).
       int renderChildren(long time, int numChildren, ArrayList<DistortedNode> children)
+        {
         int quality=0, internalQuality = 0, numRenders = 0, bucketChange = 0;
         DistortedNode child1, child2;
         EffectQueuePostprocess lastQueue=null, currQueue;
         long lastBucket=0, currBucket;
         long lastBucket=0, currBucket=0;
         initializeOIT(this);
         for(int i=0; i<numChildren; i++)
+          {
-...
           currQueue = child1.getPostprocessQueue();
           currBucket= currQueue.getID();
           if( currBucket==0 ) numRenders += child1.draw(time,this);
           if( currBucket==0 )
+            {
             GLES31.glBindFramebuffer(GLES31.GL_FRAMEBUFFER, mBufferOIT.mFBOH[0]);
             numRenders += child1.draw(time, mBufferOIT);
             //setAsOutput(time);
             //numRenders += child1.draw(time,this);
+            }
           else
+            {
             if( mBuffer[0]==null ) createBuffers(mWidth,mHeight,mNear);
             if( mBuffer[0]==null ) createPostprocessingBuffers(mWidth,mHeight,mNear);
             if( lastBucket!=currBucket )
+              {
               if( lastBucket==0 )
+                {
                 DistortedEffects.zeroOutAtomic();
                 clonePostprocessingViewport(this);
+                }
               else
+                {
-...
+                  }
                 numRenders += lastQueue.postprocess(mBuffer);
                 numRenders += blitWithDepth(time, mBuffer[quality]);
                 numRenders += mBufferOIT.oitBuild(time, mBuffer[quality]);
                 clearBuffer(mBuffer[quality]);
+                }
               internalQuality = currQueue.getInternalQuality();
               quality         = currQueue.getQuality();
               bucketChange    = i;
               cloneViewport(this);
+              }
             mBuffer[quality].setAsOutput(time);
             child1.drawNoBlend(time,mBuffer[quality]);
             if( i==numChildren-1 )
-...
+                }
               numRenders += currQueue.postprocess(mBuffer);
               numRenders += blitWithDepth(time, mBuffer[quality]);
               GLES31.glMemoryBarrier(GLES31.GL_ALL_BARRIER_BITS);
               numRenders += mergeOIT(time,mBuffer[quality]);  // merge the OIT linked list
               numRenders += mBufferOIT.oitBuild(time, mBuffer[quality]);
               GLES31.glMemoryBarrier(GLES31.GL_SHADER_STORAGE_BARRIER_BIT);
               numRenders += oitRender(time,mBufferOIT);  // merge the OIT linked list
               clearBuffer(mBuffer[quality]);
+              }
+            }
             } // end else (postprocessed child)
           lastQueue = currQueue;
           lastBucket= currBucket;
           } // end main for loop
         if( currBucket==0 ) // there was no postprocessing - we need to merge the main buffer
+          {
           numRenders += oitRender(time,mBufferOIT);
+          }
         return numRenders;
-...
           mNear=0.99f;
+          }
         if( mBuffer[0]!=null )
+          {
           for(int j=0; j<EffectQuality.LENGTH; j++) mBuffer[j].mNear = mNear;
+          }
         createProjection();
+        }

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision 56c6ca24

Added by Leszek Koltunski almost 6 years ago