/ - Diff - Distorted Android

« Previous | Next »

Revision 0bd9f644

Added by Leszek Koltunski about 5 years ago

ID 0bd9f6449b59699922e8df2c7533129eae05b33f
Parent 524e4fe7
Child 97755c02

Introduce an UBO to the vertex shader holding info about mesh effect associations.

       private static DistortedProgram mPreProgram;
       private static int mPreColorH;
       private static int mPreTextureH;
       private static int mPreProgramH;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
           throw new RuntimeException(e.getMessage());
+          }
         int preProgramH = mPreProgram.getProgramHandle();
         EffectQueueVertex.getUniforms( preProgramH,2 );
         EffectQueueMatrix.getUniforms( preProgramH,2 );
         MeshBase.getUniforms(preProgramH,2);
         mPreColorH  = GLES30.glGetUniformLocation( preProgramH, "u_Color"  );
         mPreTextureH= GLES30.glGetUniformLocation( preProgramH, "u_Texture");
         mPreProgramH = mPreProgram.getProgramHandle();
         EffectQueueVertex.getUniforms( mPreProgramH,2 );
         EffectQueueMatrix.getUniforms( mPreProgramH,2 );
         mPreColorH  = GLES30.glGetUniformLocation( mPreProgramH, "u_Color"  );
         mPreTextureH= GLES30.glGetUniformLocation( mPreProgramH, "u_Texture");
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         mPreProgram.useProgram();
         mesh.bindVertexAttribs(mPreProgram);
         mesh.send(2);
         mesh.send(mPreProgramH);
         EffectQueue[] queues = effects.getQueues();
         EffectQueueMatrix matrix = (EffectQueueMatrix)queues[0];

       private static int mBlitDepthDepthH;
       private static int mBlitDepthTexCorrH;
       /// Program Handles ///
       private static int mMainProgramH, mFullProgramH, mMainOITProgramH;
       /// OIT SSBO BUFFER ///
       private static int[] mLinkedListSSBO = new int[1];
       private static int[] mAtomicCounter;
-...
           throw new RuntimeException(e.getMessage());
+          }
         int mainProgramH = mMainProgram.getProgramHandle();
         EffectQueue.getUniforms(mainProgramH,0);
         MeshBase.getUniforms(mainProgramH,0);
         mMainTextureH= GLES30.glGetUniformLocation( mainProgramH, "u_Texture");
         mTransformFeedbackH= GLES30.glGetUniformLocation( mainProgramH, "u_TransformFeedback");
         mMainProgramH = mMainProgram.getProgramHandle();
         EffectQueue.getUniforms(mMainProgramH,0);
         mMainTextureH= GLES30.glGetUniformLocation( mMainProgramH, "u_Texture");
         mTransformFeedbackH= GLES30.glGetUniformLocation( mMainProgramH, "u_TransformFeedback");
         // BLIT PROGRAM ////////////////////////////////////
         final InputStream blitVertStream = mResources.openRawResource(R.raw.blit_vertex_shader);
-...
         mBlitDepthDepthTextureH = GLES30.glGetUniformLocation( blitDepthProgramH, "u_DepthTexture");
         mBlitDepthDepthH        = GLES30.glGetUniformLocation( blitDepthProgramH, "u_Depth");
         mBlitDepthTexCorrH      = GLES30.glGetUniformLocation( blitDepthProgramH, "u_TexCorr");
         int[] params = new int[1];
         int index = GLES30.glGetUniformBlockIndex(mMainProgramH, "meshAssociation");
         GLES30.glGetActiveUniformBlockiv( mMainProgramH, index, GLES30.GL_UNIFORM_BLOCK_DATA_SIZE, params, 0);
         MeshBase.setAssociationSize(params[0]);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
           throw new RuntimeException(e.getMessage());
+          }
         int fullProgramH = mFullProgram.getProgramHandle();
         EffectQueue.getUniforms(fullProgramH,3);
         MeshBase.getUniforms(fullProgramH,3);
         mFullProgramH = mFullProgram.getProgramHandle();
         EffectQueue.getUniforms(mFullProgramH,3);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
           throw new RuntimeException(e.getMessage());
+          }
         int mainOITProgramH = mMainOITProgram.getProgramHandle();
         EffectQueue.getUniforms(mainOITProgramH,1);
         MeshBase.getUniforms(mainOITProgramH,1);
         mMainOITTextureH    = GLES30.glGetUniformLocation( mainOITProgramH, "u_Texture");
         mMainOITSizeH       = GLES30.glGetUniformLocation( mainOITProgramH, "u_Size");
         mMainOITNumRecordsH = GLES30.glGetUniformLocation( mainOITProgramH, "u_numRecords");
         mMainOITProgramH = mMainOITProgram.getProgramHandle();
         EffectQueue.getUniforms(mMainOITProgramH,1);
         mMainOITTextureH    = GLES30.glGetUniformLocation( mMainOITProgramH, "u_Texture");
         mMainOITSizeH       = GLES30.glGetUniformLocation( mMainOITProgramH, "u_Size");
         mMainOITNumRecordsH = GLES30.glGetUniformLocation( mMainOITProgramH, "u_numRecords");
         // OIT CLEAR PROGRAM ////////////////////////////////////
         final InputStream oitClearVertStream = resources.openRawResource(R.raw.oit_vertex_shader);
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // execute all VertexEffects and adjust all vertices
     /**
      * Execute all VertexEffects and adjust all vertices
+     *
      * @y.exclude
      */
       public static void adjustVertices(MeshBase mesh, EffectQueueVertex queue)
+        {
         if( mFullProgram==null )
-...
         mesh.bindVertexAttribs(mFullProgram);
         queue.compute(1);
         queue.send(0.0f,3);
         mesh.send(3);
         mesh.send(mFullProgramH);
         GLES30.glBindBufferBase(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfo );
         GLES30.glBeginTransformFeedback( GLES30.GL_POINTS);
-...
           GLES30.glUniform2ui(mMainOITSizeH, surface.mWidth, surface.mHeight);
           GLES30.glUniform1ui(mMainOITNumRecordsH, (int)(mBufferSize*surface.mWidth*surface.mHeight) );
           mesh.bindVertexAttribs(mMainOITProgram);
           mesh.send(1);
           mesh.send(mMainOITProgramH);
           float inflate     = mesh.getInflate();
           float distance    = surface.mDistance;
-...
           if( mesh.getShowNormals() )
+            {
             mMainProgram.useProgram();
             mesh.send(0);
             mesh.send(mMainProgramH);
             EffectQueue.send(queues, distance, mipmap, projection, inflate, 0 );
             displayNormals(projection,mesh);
+            }
-...
           mMainProgram.useProgram();
           GLES30.glUniform1i(DistortedLibrary.mMainTextureH, 0);
           mesh.bindVertexAttribs(DistortedLibrary.mMainProgram);
           mesh.send(0);
           mesh.send(mMainProgramH);
           float inflate     = mesh.getInflate();
           float distance    = surface.mDistance;

     package org.distorted.library.main;
     import android.opengl.GLES30;
     import java.nio.Buffer;
     import java.nio.ByteBuffer;
     import java.nio.ByteOrder;
     import java.nio.FloatBuffer;
     import java.nio.IntBuffer;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
-...
+      {
       private final int[] mIndex;
       private int mTarget, mSize, mUsage;
       private FloatBuffer mBuffer;
       private Buffer mBuffer;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // must be called from a thread holding OpenGL Context.
       public int createImmediately(int size, float[] buffer)
       public int createImmediatelyFloat(int size, float[] buffer)
+        {
         if( mIndex[0]<0 )
+          {
-...
         return mIndex[0];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // must be called from a thread holding OpenGL Context.
       public int createImmediatelyInt(int size, int[] buffer)
+        {
         if( mIndex[0]<0 )
+          {
           mSize= size;
           if( buffer!=null )
+            {
             IntBuffer buf = ByteBuffer.allocateDirect(size).order(ByteOrder.nativeOrder()).asIntBuffer();
             buf.put(buffer).position(0);
             mBuffer = buf;
+            }
           else
+            {
             mBuffer = null;
+            }
           GLES30.glGenBuffers( 1, mIndex, 0);
           GLES30.glBindBuffer( mTarget,  mIndex[0]);
           GLES30.glBufferData( mTarget, mSize, mBuffer, mUsage);
           GLES30.glBindBuffer( mTarget,  0);
           markWasCreatedImmediately();
+          }
         return mIndex[0];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // buffer non-null!!
       public void updateFloat(float[] buffer)
+        {
         ((FloatBuffer)mBuffer).put(buffer).position(0);
         GLES30.glBindBuffer( mTarget, mIndex[0]);
         GLES30.glBufferData( mTarget, mSize, mBuffer, mUsage);
         GLES30.glBindBuffer( mTarget, 0);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // buffer non-null!!
       public void update(float[] buffer)
       public void updateInt(int[] buffer)
+        {
         mBuffer.put(buffer).position(0);
         ((IntBuffer)mBuffer).put(buffer).position(0);
         GLES30.glBindBuffer( mTarget, mIndex[0]);
         GLES30.glBufferData( mTarget, mSize, mBuffer, mUsage);

     import org.distorted.library.effect.MatrixEffect;
     import org.distorted.library.effect.VertexEffect;
     import org.distorted.library.effectqueue.EffectQueue;
     import org.distorted.library.main.InternalBuffer;
     import org.distorted.library.program.DistortedProgram;
     import org.distorted.library.type.Static4D;
-...
      */
     public abstract class MeshBase
+       {
        private static final int UBO_BINDING = 1;
        private static final int MAX_EFFECT_COMPONENTS= 100;
        private static final int DEFAULT_ASSOCIATION = 0xffffffff;
-...
        private static final int VERT1_SIZE = VERT1_ATTRIBS*BYTES_PER_FLOAT;
        private static final int VERT2_SIZE = VERT2_ATTRIBS*BYTES_PER_FLOAT;
        private static int mAssociationSize = 8*MAX_EFFECT_COMPONENTS;
        private boolean mShowNormals;              // when rendering this mesh, draw normal vectors?
        private InternalBuffer mVBO1, mVBO2, mTFO; // main vertex buffer and transform feedback buffer
        private InternalBuffer mUBO;               // Uniform Buffer Object
        private int mNumVertices;
        private float[] mVertAttribs1;             // packed: PosX,PosY,PosZ, NorX,NorY,NorZ, InfX,InfY,InfZ
        private float[] mVertAttribs2;             // packed: TexS,TexT, Component
        private float mInflate;
        private int[] mEquAssociation;
        private int[] mAndAssociation;
        private int[] mAssociations;
        private int mAssociationBlock;
        private boolean mNeedAdjustAssociation;
        DeferredJobs.JobNode[] mJobNode;
        private static int[] mEquAssociationH = new int[EffectQueue.MAIN_VARIANTS];
        private static int[] mAndAssociationH = new int[EffectQueue.MAIN_VARIANTS];
        private static final int TEX_COMP_SIZE = 5; // 5 four-bytes entities inside the component
        private static class TexComponent
-...
          mTexComponent = new ArrayList<>();
          mEffComponent = new ArrayList<>();
          mEquAssociation= new int[MAX_EFFECT_COMPONENTS];
          mAndAssociation= new int[MAX_EFFECT_COMPONENTS];
          mNeedAdjustAssociation = true;
          mAssociationBlock = computeAssociationBlockSize();
          mAssociations= new int[mAssociationSize/4];
          mJobNode = new DeferredJobs.JobNode[1];
          for(int i=0; i<MAX_EFFECT_COMPONENTS; i++)
+           {
            mAndAssociation[i] = DEFAULT_ASSOCIATION;
            mEquAssociation[i] = i;
            mAssociations[getAndIndex(i)] = DEFAULT_ASSOCIATION;
            mAssociations[getEquIndex(i)] = i;
+           }
          mVBO1= new InternalBuffer(GLES30.GL_ARRAY_BUFFER             , GLES30.GL_STATIC_READ);
          mVBO2= new InternalBuffer(GLES30.GL_ARRAY_BUFFER             , GLES30.GL_STATIC_READ);
          mTFO = new InternalBuffer(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, GLES30.GL_STATIC_READ);
          mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER           , GLES30.GL_STATIC_READ);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
          mInflate    = original.mInflate;
          mNumVertices= original.mNumVertices;
          mAndAssociation= new int[MAX_EFFECT_COMPONENTS];
          System.arraycopy(original.mAndAssociation, 0, mAndAssociation, 0, MAX_EFFECT_COMPONENTS);
          mEquAssociation= new int[MAX_EFFECT_COMPONENTS];
          System.arraycopy(original.mEquAssociation, 0, mEquAssociation, 0, MAX_EFFECT_COMPONENTS);
          mNeedAdjustAssociation = original.mNeedAdjustAssociation;
          mAssociationBlock = original.mAssociationBlock;
          int size = original.mAssociations.length;
          mAssociations= new int[size];
          System.arraycopy(original.mAssociations, 0, mAssociations, 0, size);
          if( deep )
+           {
-...
+           }
          mTFO = new InternalBuffer(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, GLES30.GL_STATIC_READ);
          mTFO.invalidate();
          mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER           , GLES30.GL_STATIC_READ);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * @y.exclude
      */
        public static void setAssociationSize(int size)
+         {
          mAssociationSize = size;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        private int getAndIndex(int component)
+         {
          return mAssociationBlock*component;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        private int getEquIndex(int component)
+         {
          return mAssociationBlock*(MAX_EFFECT_COMPONENTS+component);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        private int computeAssociationBlockSize()
+         {
          return 1 + (mAssociationSize/4 - 2*MAX_EFFECT_COMPONENTS) / (2*MAX_EFFECT_COMPONENTS-1);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // The problem here is that at MeshBase object creation time, we might not know the size of the
     // 'meshAssociation' Uniform Block Object in the vertex shader (the UBO is packed according to the
     // 'shared' layout, which means the size of the block is known only after linking the shaders).
     //
     // We thus, in the constructor, guess that the layout will be tight (so we will need 8*MAX_EFFECT_C
     // bytes there), allocate mAssociation already, and if later on, as a result of linking the shaders,
     // we get a call to setAssociationSize() which changes the size to something else, we need to reallocate.
     //
     // It can happen that even before the linking the value of mAssociationSize is already 'right' because
     // this is a static variable and it might persist from an earlier run. All the better then; this should
     // never be wrong.
        private void adjustAssociation()
+         {
          int oldLen = mAssociations.length;
          if( mAssociationSize != 4*oldLen )
+           {
            int[] tmp = new int[oldLen];
            System.arraycopy(mAssociations, 0, tmp, 0, oldLen);
            int newLen = mAssociationSize/4;
            mAssociations = new int[newLen];
            mAssociationBlock = computeAssociationBlockSize();
            for(int i=0; i<oldLen/2; i++)
+             {
              mAssociations[getAndIndex(i)] = tmp[i];                         // oldLen must be equal to
              mAssociations[getEquIndex(i)] = tmp[MAX_EFFECT_COMPONENTS+i];   // 8*MAX_EFFECT_COM
+             }
+           }
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
            start = end+1;
            end   = mEffComponent.get(i);
            if( (andAssoc & mAndAssociation[i]) != 0 || (equAssoc == mEquAssociation[i]) )
            if( (andAssoc & mAssociations[getAndIndex(i)]) != 0 || (equAssoc == mAssociations[getEquIndex(i)]) )
+             {
              applyMatrixToComponent(matrixP, matrixV, start, end);
+             }
-...
        void setEffectAssociationNow(int component, int andAssociation, int equAssociation)
+         {
          mAndAssociation[component] = andAssociation;
          mEquAssociation[component] = equAssociation;
          mAssociations[getAndIndex(component)] = andAssociation;
          mAssociations[getEquIndex(component)] = equAssociation;
          mUBO.invalidate();
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
              if( origEffComponents<MAX_EFFECT_COMPONENTS )
+               {
                mAndAssociation[origEffComponents] = mesh.mAndAssociation[j];
                mEquAssociation[origEffComponents] = mesh.mEquAssociation[j];
                mAssociations[getAndIndex(origEffComponents)] = mesh.mAssociations[mesh.getAndIndex(j)];
                mAssociations[getEquIndex(origEffComponents)] = mesh.mAssociations[mesh.getEquIndex(j)];
                origEffComponents++;
+               }
+             }
-...
          return MAX_EFFECT_COMPONENTS;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        public static void getUniforms(int mProgramH, int variant)
+         {
          mEquAssociationH[variant] = GLES30.glGetUniformLocation( mProgramH, "vComEquAssoc");
          mAndAssociationH[variant] = GLES30.glGetUniformLocation( mProgramH, "vComAndAssoc");
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Not part of public API, do not document (public only because has to be used from the main package)
-...
+           {
            FloatBuffer feedback = buffer.order(ByteOrder.nativeOrder()).asFloatBuffer();
            feedback.get(mVertAttribs1,0,VERT1_ATTRIBS*mNumVertices);
            mVBO1.update(mVertAttribs1);
            mVBO1.updateFloat(mVertAttribs1);
+           }
          else
+           {
-...
      */
        public int getTFO()
+         {
          return mTFO.createImmediately(mNumVertices*TRAN_SIZE, null);
          return mTFO.createImmediatelyFloat(mNumVertices*TRAN_SIZE, null);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+     *
      * @y.exclude
      */
        public void send(int variant)
        public void send(int programH)
+         {
          GLES30.glUniform1iv( mEquAssociationH[variant], MAX_EFFECT_COMPONENTS, mEquAssociation, 0);
          GLES30.glUniform1iv( mAndAssociationH[variant], MAX_EFFECT_COMPONENTS, mAndAssociation, 0);
          if( mNeedAdjustAssociation )
+           {
            mNeedAdjustAssociation = false;
            adjustAssociation();
+           }
          int index = mUBO.createImmediatelyInt( mAssociationSize, mAssociations);
          GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, UBO_BINDING, index);
          GLES30.glUniformBlockBinding(programH, UBO_BINDING, index);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
+           }
          int index1 = mVBO1.createImmediately(mNumVertices*VERT1_SIZE, mVertAttribs1);
          int index2 = mVBO2.createImmediately(mNumVertices*VERT2_SIZE, mVertAttribs2);
          int index1 = mVBO1.createImmediatelyFloat(mNumVertices*VERT1_SIZE, mVertAttribs1);
          int index2 = mVBO2.createImmediatelyFloat(mNumVertices*VERT2_SIZE, mVertAttribs2);
          GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, index1 );
          GLES30.glVertexAttribPointer(program.mAttribute[0], POS_DATA_SIZE, GLES30.GL_FLOAT, false, VERT1_SIZE, OFFSET_POS);
-...
      */
        public void bindTransformAttribs(DistortedProgram program)
+         {
          int index = mTFO.createImmediately(mNumVertices*TRAN_SIZE, null);
          int index = mTFO.createImmediatelyFloat(mNumVertices*TRAN_SIZE, null);
          GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, index );
          GLES30.glVertexAttribPointer(program.mAttribute[0], POS_DATA_SIZE, GLES30.GL_FLOAT, false, 0, 0);

     out vec3 v_Normal;                   //
     out vec2 v_TexCoordinate;            //
     uniform mat4 u_MVPMatrix;            // the combined model/view/projection matrix.
     uniform mat4 u_MVPMatrix;            // u_MVMatrixP * projection.
     uniform mat4 u_MVMatrixP;            // the combined model/view matrix. (for points)
     uniform mat4 u_MVMatrixV;            // the combined model/view matrix. (for vectors)
                                          // which need to work differently on points and vectors
-...
                                          // second vec4: first float - cache, next 3: Center, the third -  the Region.
     uniform int vEffAndAssoc[NUM_VERTEX];// Associations of the vertex effects. Those are used to connect an effect to a Mesh component.
     uniform int vEffEquAssoc[NUM_VERTEX];// Components the vertex effects work on. Likewise used to connect an effect to a Mesh component.
     uniform int vComAndAssoc[MAX_COMPON];// 'logical AND' association of the component.
     uniform int vComEquAssoc[MAX_COMPON];// 'equal' association of the component.
     layout (std140, binding=1) uniform meshAssociation
+      {
       int vComAndAssoc[MAX_COMPON]; // 'logical AND' association of the component.
       int vComEquAssoc[MAX_COMPON]; // 'equal' association of the component.
       };
     //////////////////////////////////////////////////////////////////////////////////////////////
     // HELPER FUNCTIONS

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision 0bd9f644

Added by Leszek Koltunski about 5 years ago