/ - 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.resetNewCounter() );
         android.util.Log.d("surface", "SurfaceID "+ surface.getID()+" transparent fragments: "+ surface.returnCounter() );
         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 create()
	42	void createSurface()
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 delete()
	138	void deleteSurface()
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 recreate()
	161	void recreateSurface()
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.util.ArrayList;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       private int mDebugLevel;
       ////////////////////////////////////////////////////////////////////////////////
       // section dealing with Shader Storage Buffer Object (for counting transparency)
       private static final int BUFFERING = 3;
       private static int mBufferSize     =10;
       private static DistortedObjectCounter mSurfaceCounter = new DistortedObjectCounter();
       private static int[] mSSBO = new int[1];
       private static ByteBuffer mSSBOBuffer;
       static
+        {
         mSSBO[0]    = -1;
         mSSBOBuffer = ByteBuffer.allocateDirect(BUFFERING*mBufferSize*4).order(ByteOrder.nativeOrder());
+        }
       private int mSurfaceID;
       private int mLastIndex;
       // 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, BUFFERING*mBufferSize*4 , null, GLES31.GL_DYNAMIC_READ);
           mSSBOBuffer = (ByteBuffer) GLES31.glMapBufferRange(GLES31.GL_SHADER_STORAGE_BUFFER, 0, BUFFERING*mBufferSize*4, GLES31.GL_MAP_WRITE_BIT | GLES31.GL_MAP_WRITE_BIT );
           GLES31.glBindBufferBase(GLES31.GL_SHADER_STORAGE_BUFFER,1, mSSBO[0]);
+          }
         mSurfaceID = mSurfaceCounter.returnNext();
         if( mSurfaceID>=mBufferSize )
+          {
           // increase the size of mSSBOBuffer, copy over old values, remap.
           // TODO (don't need this if there are never more than mBufferSize=10 Surfaces)
+          }
         createSurface();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Must be called from a thread holding OpenGL Context
       void delete()
+        {
         mSurfaceCounter.release(mSurfaceID);
         deleteSurface();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void recreate()
+        {
         mSSBO[0] = -1;
         mSurfaceCounter.releaseAll();
         recreateSurface();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       int resetNewCounter()
+        {
         //mSSBOBuffer.putInt(BUFFERING*mSurfaceID+mLastIndex,0);
         return BUFFERING*mSurfaceID + mLastIndex;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       int returnOldCounter()
+        {
         int ret = mSSBOBuffer.getInt(BUFFERING*mSurfaceID+mLastIndex);
         mLastIndex++;
         if( mLastIndex>=BUFFERING ) mLastIndex-=BUFFERING;
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       int returnCounter()
+        {
         return mSSBOBuffer.getInt(0);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void createProjection()

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

                                             // next describes the Region, i.e. area over which the effect is active.
     #endif    // NUM_FRAGMENT>0
     layout (std140,binding=1) buffer SSBO   // PER-SURFACE count of transparent fragments.
       {                                     // Can be buffered, i.e. if we are for example
       int count[];                          // triple-buffered, then surfaceID=N uses 3
       };                                    // consecutive counts (N,N+1,N+2) during 3
                                             // consecutive frames.
     uniform int u_currentIndex;             // Index into the count[] array we are supposed to be using
                                             // during this very invocation.
     //////////////////////////////////////////////////////////////////////////////////////////////
     void main()
-...
+        }
     #endif
       count[0]=17;
       FRAG_COLOR = vec4(color.rgb * (1.0 + 7.0*v_Normal.z) * 0.125, color.a);
+      }

Project

General

Profile

Distorted Android

Revision 12f45260

Added by Leszek Koltunski about 6 years ago