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

« Previous | Next »

Revision 0bd9f644

Added by Leszek Koltunski over 3 years ago

ID 0bd9f6449b59699922e8df2c7533129eae05b33f
Parent 524e4fe7
Child 97755c02

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

     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);

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision 0bd9f644

Added by Leszek Koltunski over 3 years ago