/ - Diff - Distorted Android

       /// MAIN PROGRAM ///
       private static DistortedProgram mMainProgram;
       private static int mMainTextureH;
       private static int mCountIndexH;
       /// BLIT PROGRAM ///
       private static DistortedProgram mBlitProgram;
-...
         EffectQueueVertex.getUniforms(mainProgramH);
         EffectQueueMatrix.getUniforms(mainProgramH);
         mMainTextureH= GLES31.glGetUniformLocation( mainProgramH, "u_Texture");
         mCountIndexH = GLES31.glGetUniformLocation( mainProgramH, "u_currentIndex");
         // BLIT PROGRAM ////////////////////////////////////
         final InputStream blitVertStream = resources.openRawResource(R.raw.blit_vertex_shader);
-...
         mMainProgram.useProgram();
         GLES31.glUniform1i(mMainTextureH, 0);
         GLES31.glUniform1i(mCountIndexH, surface.getNewCounter() );
         if( Distorted.GLSL >= 300 )
+          {

src/main/java/org/distorted/library/main/DistortedFramebuffer.java
39	39	///////////////////////////////////////////////////////////////////////////////////////////////////
40	40	// Must be called from a thread holding OpenGL Context
41	41
42		void createSurface()
	42	void create()
43	43	{
44	44	if( mColorCreated==NOT_CREATED_YET )
45	45	{
...	...
135	135	///////////////////////////////////////////////////////////////////////////////////////////////////
136	136	// Must be called from a thread holding OpenGL Context
137	137
138		void deleteSurface()
	138	void delete()
139	139	{
140	140	if( mColorH[0]>0 )
141	141	{
...	...
158	158	///////////////////////////////////////////////////////////////////////////////////////////////////
159	159	// called from onDestroy(); mark OpenGL assets as 'not created'
160	160
161		void recreateSurface()
	161	void recreate()
162	162	{
163	163	if( mColorCreated!=DONT_CREATE )
164	164	{

     import org.distorted.library.effect.EffectQuality;
     import java.nio.ByteBuffer;
     import java.nio.ByteOrder;
     import java.nio.IntBuffer;
     import java.util.ArrayList;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
                         // mWidth,mHeight are the sizes of the Viewport, those -
                         // sizes of the backing up texture.
       ////////////////////////////////////////////////////////////////////////////////
       // section dealing with Shader Storage Buffer Object (for counting transparency)
       private static final int FRAME_DELAY = 3;
       private static int mBufferSize       =10;
       private static DistortedObjectCounter mSurfaceCounter = new DistortedObjectCounter();
       private static int[] mSSBO = new int[1];
       private static IntBuffer mIntBuffer;
       static
+        {
         mSSBO[0]= -1;
+        }
       private int mSurfaceID;
       private int mLastIndex;
       private int[] mLastValue = new int[FRAME_DELAY];
       private int mLastDiff = -1;
       private static final int RUNNING_AVERAGE = 10;
       private int[] mRunningAvg = new int[RUNNING_AVERAGE];
       private int mAvgIndex;
       private int mAvgSum;
       // end section
       ////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       abstract void prepareDebug(long time);
       abstract void renderDebug(long time);
       abstract void createSurface();
       abstract void deleteSurface();
       abstract void recreateSurface();
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         createProjection();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Must be called from a thread holding OpenGL Context
       void create()
+        {
         if( mSSBO[0]<0 )
+          {
           GLES31.glGenBuffers(1,mSSBO,0);
           // here bind the new SSBO and map it
           GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, mSSBO[0]);
           GLES31.glBufferData(GLES31.GL_SHADER_STORAGE_BUFFER, FRAME_DELAY *mBufferSize*4 , null, GLES31.GL_DYNAMIC_READ);
           ByteBuffer buf = (ByteBuffer) GLES31.glMapBufferRange(GLES31.GL_SHADER_STORAGE_BUFFER, 0, FRAME_DELAY *mBufferSize*4, GLES31.GL_MAP_READ_BIT );
           mIntBuffer = buf.order(ByteOrder.nativeOrder()).asIntBuffer();
           GLES31.glBindBufferBase(GLES31.GL_SHADER_STORAGE_BUFFER,0, mSSBO[0]);
+          }
         mSurfaceID = mSurfaceCounter.returnNext();
         if( mSurfaceID>=mBufferSize )
+          {
           // increase size of the Buffer, copy over old values, remap.
           int[] tmp = new int[FRAME_DELAY *mBufferSize];
           for(int i = 0; i< FRAME_DELAY *mBufferSize; i++) tmp[i] = mIntBuffer.get(i);
           mBufferSize*= 2;
           GLES31.glBindBufferBase(GLES31.GL_SHADER_STORAGE_BUFFER, 0, 0);
           GLES31.glUnmapBuffer(GLES31.GL_SHADER_STORAGE_BUFFER);
           GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER,0);
           GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, mSSBO[0]);
           GLES31.glBufferData(GLES31.GL_SHADER_STORAGE_BUFFER, FRAME_DELAY *mBufferSize*4 , null, GLES31.GL_DYNAMIC_READ);
           ByteBuffer buf = (ByteBuffer) GLES31.glMapBufferRange(GLES31.GL_SHADER_STORAGE_BUFFER, 0, FRAME_DELAY *mBufferSize*4, GLES31.GL_MAP_READ_BIT );
           mIntBuffer = buf.order(ByteOrder.nativeOrder()).asIntBuffer();
           GLES31.glBindBufferBase(GLES31.GL_SHADER_STORAGE_BUFFER,0, mSSBO[0]);
           for(int i=0;i<tmp.length;i++) mIntBuffer.put(i,tmp[i]);
+          }
         createSurface();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Must be called from a thread holding OpenGL Context
       void delete()
+        {
         mSurfaceCounter.release(mSurfaceID);
         deleteSurface();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void recreate()
+        {
         mSSBO[0]  = -1;
         mLastDiff = -1;
         for(int i = 0; i< FRAME_DELAY; i++) mLastValue[i] = 0;
         mSurfaceCounter.releaseAll();
         recreateSurface();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       int getNewCounter()
+        {
         return FRAME_DELAY*mSurfaceID + mLastIndex;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void createProjection()
-...
               surface.mRealWidth = maxw;
               surface.mRealHeight = maxh;
               surface.recreateSurface();
               surface.createSurface();
               surface.recreate();
               surface.create();
+              }
+            }
+          }

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // here we don't manage underlying OpenGL assets ourselves
       void createSurface()   {}
       void deleteSurface()   {}
       void recreateSurface() {}
       void create()   {}
       void delete()   {}
       void recreate() {}
     ///////////////////////////////////////////////////////////////////////////////////////////////////

           final int[] compileStatus = new int[1];
           GLES31.glGetShaderiv(shaderHandle, GLES31.GL_COMPILE_STATUS, compileStatus, 0);
           if (compileStatus[0] != GLES31.GL_TRUE )
           if (compileStatus[0] != GLES31.GL_TRUE)
+            {
             GLES31.glDeleteShader(shaderHandle);
             shaderHandle = 0;
+            }
+          }
             String error = GLES31.glGetShaderInfoLog(shaderHandle);
         if (shaderHandle == 0)
+          {
           String error = GLES31.glGetShaderInfoLog(shaderHandle);
             //android.util.Log.e("Program", "error compiling :" + error);
           //android.util.Log.e("Program", "error compiling :"+error);
             GLES31.glDeleteShader(shaderHandle);
           switch(shaderType)
+            {
             case GLES31.GL_VERTEX_SHADER  : throw new VertexCompilationException(error);
             case GLES31.GL_FRAGMENT_SHADER: throw new FragmentCompilationException(error);
             default                       : throw new RuntimeException(error);
             switch (shaderType)
+              {
               case GLES31.GL_VERTEX_SHADER:   throw new VertexCompilationException(error);
               case GLES31.GL_FRAGMENT_SHADER: throw new FragmentCompilationException(error);
               default:                        throw new RuntimeException(error);
+              }
+            }
+          }

     // along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                       //
     //////////////////////////////////////////////////////////////////////////////////////////////
     precision lowp float;
     precision highp float;
     #if __VERSION__ != 100
     in vec3 v_Position;                     // Interpolated position for this fragment.
-...
                                             // next describes the Region, i.e. area over which the effect is active.
     #endif    // NUM_FRAGMENT>0
     layout (std430,binding=0) buffer SSBO   // PER-SURFACE count of transparent fragments.
       {                                     // Can be buffered, i.e. if we are for example
       int ssbocount[];                      // triple-buffered, then surfaceID=N uses 3
       };                                    // consecutive counts (N,N+1,N+2) during 3
                                             // consecutive frames.
                                             // Cannot be an 'uint' because the Java application that's
                                             // reading this does not have unsigned types so it's reading
                                             // this into a signed int... Doesn't matter as things keep on
                                             // working even when this overflows into negative territory :)
     uniform int u_currentIndex;             // Index into the count[] array we are supposed to be using
                                             // during this very invocation.
     //////////////////////////////////////////////////////////////////////////////////////////////
     void main()
-...
+        }
     #endif
       if( color.a < 1.0 && color.a > 0.0 ) atomicAdd(ssbocount[u_currentIndex],1);
       FRAG_COLOR = vec4(color.rgb * (1.0 + 7.0*v_Normal.z) * 0.125, color.a);
+      }

     // along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                       //
     //////////////////////////////////////////////////////////////////////////////////////////////
     precision lowp float;
     precision highp float;
     #if __VERSION__ != 100
     in vec3 a_Position;                  // Per-vertex position.

Project

General

Profile

Distorted Android

Revision 341151fc

Added by Leszek Koltunski about 6 years ago