/ - Diff - Distorted Android

src/main/java/org/distorted/library/effectqueue/EffectQueuePostprocess.java
129	129	String mainFragHeader= version + "\n";
130	130
131	131	mainVertHeader += "#define MAX_COMPON " + MeshBase.getMaxEffComponents() + "\n";
	132	if( MeshBase.getUseCenters() ) mainVertHeader += "#define COMP_CENTERS\n";
132	133
133	134	String enabledEffectV= VertexEffect.getGLSL();
134	135

       private static int mFBOQueueSize;
       private static int mGLSL;
       private static String mGLSL_VERSION;
       private static boolean mOITCompilationAttempted;
       private static boolean mNeedsTransformFeedback;
       private static boolean mOITCompilationAttempted, mNeedsTransformFeedback;
       private static int mMaxTextureSize         = Integer.MAX_VALUE;
       private static int mMaxNumberOfVerUniforms = Integer.MAX_VALUE;
-...
         String mainFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " + ( numF>0 ? getMax(EffectType.FRAGMENT) : 0 ) + "\n");
         mainVertHeader += "#define MAX_COMPON " + MeshBase.getMaxEffComponents() + "\n";
         if( MeshBase.getUseCenters() ) mainVertHeader += "#define COMP_CENTERS\n";
         String enabledEffectV= VertexEffect.getGLSL();
         String enabledEffectF= FragmentEffect.getGLSL();
-...
         String fullFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " +                                         0   + "\n");
         fullVertHeader += "#define MAX_COMPON " + MeshBase.getMaxEffComponents() + "\n";
         if( MeshBase.getUseCenters() ) fullVertHeader += "#define COMP_CENTERS\n";
         String enabledEffectV= VertexEffect.getAllGLSL();
         String enabledEffectF= "{}";
-...
         String mainFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " + ( numF>0 ? getMax(EffectType.FRAGMENT) : 0 ) + "\n") + ("#define OIT\n");
         mainVertHeader += "#define MAX_COMPON " + MeshBase.getMaxEffComponents() + "\n";
         if( MeshBase.getUseCenters() ) mainVertHeader += "#define COMP_CENTERS\n";
         String enabledEffectV= VertexEffect.getGLSL();
         String enabledEffectF= FragmentEffect.getGLSL();

       private static final int JOB_TYPE_CENTER       = 8;
       private static final int JOB_TYPE_ADD_EMPTY_TEX= 9;
       private static ArrayList<JobNode> mJobs = new ArrayList<>();
       private static final ArrayList<JobNode> mJobs = new ArrayList<>();
       //////////////////////////////////////////////////////////////////////////
       private static class Job
+        {
         private int mType;
         private MeshBase mTarget;
         private MeshBase[] mSource;
         private final int mType;
         private final MeshBase mTarget;
         private final MeshBase[] mSource;
         private final MatrixEffect mMatrixEffect;
         private final Static4D[] mMaps;
         private final int mComp, mAndAssoc, mEquAssoc;
         private final float mX,mY,mZ;
         private EffectQueueVertex mVertexEffects;
         private MatrixEffect mMatrixEffect;
         private Static4D[] mMaps;
         private int mComp, mAndAssoc, mEquAssoc;
         private float mX,mY,mZ;
         Job(int type, MeshBase target, MeshBase[] source, VertexEffect vEff, MatrixEffect mEff,
             Static4D[] maps, int comp, int and, int equ, float x, float y, float z)

+       {
        private static final int ASSOC_UBO_BINDING  = 3;
        private static final int CENTER_UBO_BINDING = 4;
        public  static final int MAX_EFFECT_COMPONENTS= 100;
        public  static final int MAX_EFFECT_COMPONENTS= 98;
        // sizes of attributes of an individual vertex.
        private static final int POS_DATA_SIZE= 3; // vertex coordinates: x,y,z
-...
        private static final int VERT1_SIZE = VERT1_ATTRIBS*BYTES_PER_FLOAT;
        private static final int VERT2_SIZE = VERT2_ATTRIBS*BYTES_PER_FLOAT;
        private static final int[] mCenterBlockIndex = new int[EffectQueue.MAIN_VARIANTS];
        private static final int[] mAssocBlockIndex  = new int[EffectQueue.MAIN_VARIANTS];
        private static final int TEX_COMP_SIZE = 5; // 5 four-byte entities inside the component
        private static boolean mUseCenters;
        private boolean mShowNormals;              // when rendering this mesh, draw normal vectors?
        private InternalBuffer mVBO1, mVBO2, mTFO; // main vertex buffer and transform feedback buffer
        private int mNumVertices;
-...
        private float[] mVertAttribs2;             // packed: TexS,TexT, Component
        private float mInflate;
        private final UniformBlockAssociation mUBA;
        private final UniformBlockCenter mUBC;
        private UniformBlockCenter mUBC;
        DeferredJobs.JobNode[] mJobNode;
        private static final int[] mCenterBlockIndex = new int[EffectQueue.MAIN_VARIANTS];
        private static final int[] mAssocBlockIndex  = new int[EffectQueue.MAIN_VARIANTS];
        private static final int TEX_COMP_SIZE = 5; // 5 four-byte entities inside the component
        private static class TexComponent
+         {
          private int mEndIndex;
-...
          mJobNode = new DeferredJobs.JobNode[1];
          mUBA = new UniformBlockAssociation();
          mUBC = new UniformBlockCenter();
          if( mUseCenters ) mUBC = new UniformBlockCenter();
          mVBO1= new InternalBuffer(GLES30.GL_ARRAY_BUFFER             , GLES30.GL_STATIC_READ);
          mVBO2= new InternalBuffer(GLES30.GL_ARRAY_BUFFER             , GLES30.GL_STATIC_READ);
-...
          mNumVertices= original.mNumVertices;
          mUBA = new UniformBlockAssociation(original.mUBA);
          mUBC = new UniformBlockCenter(original.mUBC);
          if( mUseCenters ) mUBC = new UniformBlockCenter(original.mUBC);
          if( deep )
+           {
-...
        void setComponentCenterNow(int component, float x, float y, float z)
+         {
          mUBC.setEffectCenterNow(component, x, y, z);
          if( mUBC!=null )
+           {
            mUBC.setEffectCenterNow(component, x, y, z);
+           }
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
              if( origEffComponents<MAX_EFFECT_COMPONENTS )
+               {
                mUBA.copy(origEffComponents, mesh.mUBA, j);
                mUBC.copy(origEffComponents, mesh.mUBC, j);
                if( mUseCenters ) mUBC.copy(origEffComponents, mesh.mUBC, j);
                origEffComponents++;
+               }
+             }
-...
          mVBO2.invalidate();
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Are we going to need per-component centers (needed for correct postprocessing of concave meshes)
      * Switching this on allocates 16*MAX_EFFECT_COMPONENTS bytes for uniforms in the vertex shader.
      */
        public static void setUseCenters()
+         {
          mUseCenters = true;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Are we using per-component centers?
      */
        public static boolean getUseCenters()
+         {
          return mUseCenters;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        public static int getMaxEffComponents()
-...
          GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, ASSOC_UBO_BINDING, indexA);
          GLES30.glUniformBlockBinding(programH, mAssocBlockIndex[variant], ASSOC_UBO_BINDING);
          int indexC = mUBC.getIndex();
          GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, CENTER_UBO_BINDING, indexC);
          GLES30.glUniformBlockBinding(programH, mCenterBlockIndex[variant], CENTER_UBO_BINDING);
          if( mUseCenters )
+           {
            int indexC = mUBC.getIndex();
            GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, CENTER_UBO_BINDING, indexC);
            GLES30.glUniformBlockBinding(programH, mCenterBlockIndex[variant], CENTER_UBO_BINDING);
+           }
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
              case 2 : float[] centers = new float[3*numEff];
                       floatBuf.get(centers,0,3*numEff);
                       for(int eff=0; eff<numEff; eff++)
                       if( mUseCenters )
+                        {
                         mUBC.setEffectCenterNow(eff, centers[3*eff], centers[3*eff+1], centers[3*eff+2]);
                         for(int eff=0; eff<numEff; eff++)
+                          {
                           mUBC.setEffectCenterNow(eff, centers[3*eff], centers[3*eff+1], centers[3*eff+2]);
+                          }
+                        }
                       floatBuf.get(mVertAttribs1, 0, VERT1_ATTRIBS*mNumVertices);
-...
              stream.writeFloat((float)mEffComponent.get(i));
+             }
            float[] centers = mUBC.getBackingArray();
            float[] centers = mUseCenters ? mUBC.getBackingArray() : new float[4*numEff];
            for(int i=0; i<numEff; i++)
+             {
-...
          mVBO2.markForDeletion();
          mTFO.markForDeletion();
          mUBA.markForDeletion();
          mUBC.markForDeletion();
          if( mUBC!=null )
+           {
            mUBC.markForDeletion();
+           }
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     uniform float u_Inflate;              // how much should we inflate (>0.0) or deflate (<0.0) the mesh.
     uniform int u_TransformFeedback;      // are we doing the transform feedback now?
     #ifdef COMP_CENTERS
     layout (std140) uniform componentCenter
+      {
       vec4 vComCenter[MAX_COMPON];        // centers of mesh components. 4 floats: (x,y,z,unused)
       };
     #endif
     #if NUM_VERTEX>0
     uniform int vNumEffects;              // total number of vertex effects
-...
     void main()
+      {
       int component = int(a_Component);
       vec3 v = a_Position + u_Inflate*(a_Position - vComCenter[component].xyz);
       vec3 n = a_Normal;
     #ifdef COMP_CENTERS
       vec3 v = a_Position + u_Inflate*(a_Position - vComCenter[component].xyz);
     #else
       vec3 v = a_Position + u_Inflate*a_Position;
     #endif
     #if NUM_VERTEX>0
       int effect=0;

Project

General

Profile

Distorted Android

Revision 46d463a4

Added by Leszek Koltunski over 4 years ago