/ - Diff - Distorted Android

                            // EffectQueueMatrix at any given time. This can be changed with a call
                            // to EffectQueueMatrix.setMax(int)
         maxtable[1] =100;  // Max 100 VERTEX Effects
         maxtable[2] =100;  // Max 100 FRAGMENT Effects
         maxtable[2] =  5;  // Max 5 FRAGMENT Effects
         maxtable[3] =  3;  // Max 3 POSTPROCESSING Effects
+        }

       static final int VERT_INT_UBO_BINDING = 5;
       static final int VERT_FLO_UBO_BINDING = 6;
       static final int FRAG_INT_UBO_BINDING = 7;
       static final int FRAG_FLO_UBO_BINDING = 8;
       private static final int CREATE = 0;
       private static final int ATTACH = 1;
-...
+        {
         int type;
         int num1, num2;
         boolean notify;
         boolean bool;
         Effect effect;
         Job(int t, int m1, int m2, boolean n, Effect e)
-...
           type  = t;
           num1  = m1;
           num2  = m2;
           notify= n;
           bool  = n;
           effect= e;
+          }
+        }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       EffectQueue(int numFloatUniforms, int numIntUniforms, int index)
       EffectQueue(int numFloatUniforms, int numIntUniforms, boolean useUBO, int index)
+        {
         mCreated        = false;
         mTime           = 0;
-...
         mJobs = new ArrayList<>();
         mJobs.add(new Job(CREATE,numFloatUniforms,numIntUniforms, false,null)); // create the stuff that depends on max number
         mJobs.add(new Job(CREATE,numFloatUniforms,numIntUniforms,useUBO,null)); // create the stuff that depends on max number
         InternalMaster.newSlave(this);                                          // of uniforms later, on first render.
+        }
-...
                          if( max>0 )
+                           {
                            mEffects= new Effect[max];
                            mUBF    = new UniformBlockFloatUniforms(job.num1, max);
                            mUBI    = new UniformBlockIntUniforms  (job.num2, max);
                            mUBF    = new UniformBlockFloatUniforms(job.num1, max, job.bool);
                            mUBI    = new UniformBlockIntUniforms  (job.num2, max, job.bool);
+                           }
                          mCreated = true;
-...
                            mEffects[j] = null;
+                           }
                          // TODO: notify listeners?
                          /* if( job.bool )
+                              {
                               // ...
+                              }
                           */
                          mNumEffects= 0;
                          break;
+            }

src/main/java/org/distorted/library/effectqueue/EffectQueueFragment.java
31	31	{
32	32	private static final int NUM_FLOAT_UNIFORMS = FragmentEffect.NUM_FLOAT_UNIFORMS;
33	33	private static final int NUM_INT_UNIFORMS = FragmentEffect.NUM_INT_UNIFORMS;
34
	34	private static final boolean USE_UBO = false;
35	35	private static final int INDEX = EffectType.FRAGMENT.ordinal();
36	36
37	37	private final static int[] mNumEffectsH = new int[MAIN_VARIANTS];
38		private final static int[] mIntBlockIndex= new int[MAIN_VARIANTS];
39		private final static int[] mFloBlockIndex= new int[MAIN_VARIANTS];
	38	private final static int[] mIntUniformsH = new int[MAIN_VARIANTS];
	39	private final static int[] mFloUniformsH = new int[MAIN_VARIANTS];
40	40
41	41	///////////////////////////////////////////////////////////////////////////////////////////////////
42	42
43	43	EffectQueueFragment()
44	44	{
45		super(NUM_FLOAT_UNIFORMS, NUM_INT_UNIFORMS, INDEX);
	45	super(NUM_FLOAT_UNIFORMS, NUM_INT_UNIFORMS, USE_UBO, INDEX);
46	46	}
47	47
48	48	///////////////////////////////////////////////////////////////////////////////////////////////////
...	...
57	57	static void uniforms(int mProgramH, int variant)
58	58	{
59	59	mNumEffectsH[variant] = GLES30.glGetUniformLocation ( mProgramH, "fNumEffects");
60		mIntBlockIndex[variant] = GLES30.glGetUniformBlockIndex( mProgramH, "fUniformProperties");
61		mFloBlockIndex[variant] = GLES30.glGetUniformBlockIndex( mProgramH, "fUniformFloats");
	60	mIntUniformsH[variant] = GLES30.glGetUniformLocation ( mProgramH, "fProperties");
	61	mFloUniformsH[variant] = GLES30.glGetUniformLocation ( mProgramH, "fUniforms");
62	62	}
63	63
64	64	///////////////////////////////////////////////////////////////////////////////////////////////////
...	...
80	80	EffectMessageSender.newMessage(mEffects[i]);
81	81	}
82	82	}
83
84		mUBF.invalidate();
85	83	}
86	84
87	85	mTime = currTime;
...	...
95	93
96	94	if( mNumEffects>0 )
97	95	{
98		GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, FRAG_INT_UBO_BINDING, mUBI.getIndex());
99		GLES30.glUniformBlockBinding(programH, mIntBlockIndex[variant], FRAG_INT_UBO_BINDING);
	96	int[] arrayI = mUBI.getBackingArray();
	97	float[] arrayF = mUBF.getBackingArray();
100	98
101		GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, FRAG_FLO_UBO_BINDING, mUBF.getIndex());
102		GLES30.glUniformBlockBinding(programH, mFloBlockIndex[variant], FRAG_FLO_UBO_BINDING);
	99	GLES30.glUniform4iv( mIntUniformsH[variant], mNumEffects, arrayI, 0);
	100	GLES30.glUniform4fv( mFloUniformsH[variant],(NUM_FLOAT_UNIFORMS/4)*mNumEffects, arrayF, 0);
103	101	}
104	102	}
105	103	}

src/main/java/org/distorted/library/effectqueue/EffectQueueMatrix.java
32	32	{
33	33	private static final int NUM_FLOAT_UNIFORMS = MatrixEffect.NUM_FLOAT_UNIFORMS;
34	34	private static final int NUM_INT_UNIFORMS = MatrixEffect.NUM_INT_UNIFORMS;
35
	35	private static final boolean USE_UBO = false;
36	36	private static final int INDEX = EffectType.MATRIX.ordinal();
37	37
38	38	private static final float[] mMVPMatrix = new float[16];
...	...
47	47
48	48	EffectQueueMatrix()
49	49	{
50		super(NUM_FLOAT_UNIFORMS, NUM_INT_UNIFORMS, INDEX);
	50	super(NUM_FLOAT_UNIFORMS, NUM_INT_UNIFORMS, USE_UBO, INDEX);
51	51	}
52	52
53	53	///////////////////////////////////////////////////////////////////////////////////////////////////

src/main/java/org/distorted/library/effectqueue/EffectQueuePostprocess.java
49	49	{
50	50	private static final int NUM_FLOAT_UNIFORMS = PostprocessEffect.NUM_FLOAT_UNIFORMS;
51	51	private static final int NUM_INT_UNIFORMS = PostprocessEffect.NUM_INT_UNIFORMS;
52
	52	private static final boolean USE_UBO = false;
53	53	private static final int INDEX = EffectType.POSTPROCESS.ordinal();
54	54
55	55	private int mHalo;
...	...
64	64
65	65	EffectQueuePostprocess()
66	66	{
67		super(NUM_FLOAT_UNIFORMS, NUM_INT_UNIFORMS, INDEX );
	67	super(NUM_FLOAT_UNIFORMS, NUM_INT_UNIFORMS, USE_UBO, INDEX );
68	68	}
69	69
70	70	///////////////////////////////////////////////////////////////////////////////////////////////////

src/main/java/org/distorted/library/effectqueue/EffectQueueVertex.java
35	35	{
36	36	private static final int NUM_FLOAT_UNIFORMS = VertexEffect.NUM_FLOAT_UNIFORMS;
37	37	private static final int NUM_INT_UNIFORMS = VertexEffect.NUM_INT_UNIFORMS;
	38	private static final boolean USE_UBO = true;
38	39
39	40	private static final int INDEX = EffectType.VERTEX.ordinal();
40	41
...	...
47	48
48	49	public EffectQueueVertex()
49	50	{
50		super(NUM_FLOAT_UNIFORMS, NUM_INT_UNIFORMS, INDEX);
	51	super(NUM_FLOAT_UNIFORMS, NUM_INT_UNIFORMS, USE_UBO, INDEX);
51	52	}
52	53
53	54	///////////////////////////////////////////////////////////////////////////////////////////////////

      */
     public class UniformBlockFloatUniforms
+      {
       private final InternalBuffer mUBO;
       private InternalBuffer mUBO;
       private final float[] mArray;
       private final int mNumUniforms, mSize;
       private final boolean mReallyUseUBO;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public UniformBlockFloatUniforms(int numUniforms, int size)
       public UniformBlockFloatUniforms(int numUniforms, int size, boolean reallyUse)
+        {
         mNumUniforms = numUniforms;
         mSize        = size;
         mArray= new float[mNumUniforms*mSize];
         mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ);
         mReallyUseUBO= reallyUse;
         if( mReallyUseUBO )
+          {
           mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         mNumUniforms = original.mNumUniforms;
         mSize        = original.mSize;
         mArray= new float[mNumUniforms*mSize];
         mReallyUseUBO= original.mReallyUseUBO;
         System.arraycopy(original.mArray, 0, mArray, 0, 3*mSize);
         mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ);
         if( mReallyUseUBO )
+          {
           mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public void remove(int pos, int numEffects)
+        {
         System.arraycopy(mArray, mNumUniforms*(pos+1), mArray, mNumUniforms*pos, mNumUniforms*(numEffects-pos) );
         mUBO.invalidate();
         if( mReallyUseUBO )
+          {
           mUBO.invalidate();
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void markForDeletion()
+        {
         mUBO.markForDeletion();
         if( mReallyUseUBO )
+          {
           mUBO.markForDeletion();
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void invalidate()
+        {
         mUBO.invalidate();
         if( mReallyUseUBO )
+          {
           mUBO.invalidate();
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        {
         StringBuilder builder = new StringBuilder();
         builder.append(mUBO.getID());
         builder.append( mReallyUseUBO ? mUBO.getID() : "NOT USED");
         builder.append(':');
         for(int i=0; i<6; i++)

      */
     public class UniformBlockIntUniforms
+      {
       private final InternalBuffer mUBO;
       private InternalBuffer mUBO;
       private final int[] mArray;
       private final int mNumUniforms, mSize;
       private final boolean mReallyUseUBO;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public UniformBlockIntUniforms(int numUniforms, int size)
       public UniformBlockIntUniforms(int numUniforms, int size, boolean reallyUse)
+        {
         mNumUniforms = numUniforms;
         mSize        = size;
         mArray= new int[mNumUniforms*mSize];
         mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ);
         mReallyUseUBO= reallyUse;
         if( mReallyUseUBO )
+          {
           mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         mNumUniforms = original.mNumUniforms;
         mSize        = original.mSize;
         mArray= new int[mNumUniforms*mSize];
         mReallyUseUBO= original.mReallyUseUBO;
         System.arraycopy(original.mArray, 0, mArray, 0, mSize);
         mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ);
         if( mReallyUseUBO )
+          {
           mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public void remove(int pos, int numEffects)
+        {
         System.arraycopy(mArray, mNumUniforms*(pos+1), mArray, mNumUniforms*pos, mNumUniforms*(numEffects-pos) );
         mUBO.invalidate();
         if( mReallyUseUBO )
+          {
           mUBO.invalidate();
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public void makeHole(int pos, int numEffects)
+        {
         System.arraycopy(mArray, mNumUniforms*pos, mArray, mNumUniforms*(pos+1), mNumUniforms*(numEffects-pos) );
         mUBO.invalidate();
         if( mReallyUseUBO )
+          {
           mUBO.invalidate();
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public void addOrdinal(int pos, int ordinal)
+        {
         mArray[mNumUniforms*pos] = ordinal;
         mUBO.invalidate();
         if( mReallyUseUBO )
+          {
           mUBO.invalidate();
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public void addAssociations(int pos, Effect effect)
+        {
         effect.writeAssociations(mArray, mNumUniforms*pos+1, mNumUniforms*pos+3);
         mUBO.invalidate();
         if( mReallyUseUBO )
+          {
           mUBO.invalidate();
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void markForDeletion()
+        {
         mUBO.markForDeletion();
         if( mReallyUseUBO )
+          {
           mUBO.markForDeletion();
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[] getBackingArray()
+        {
         return mArray;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        {
         StringBuilder builder = new StringBuilder();
         builder.append(mUBO.getID());
         builder.append( mReallyUseUBO ? mUBO.getID() : "NOT USED");
         builder.append(':');
         for(int i=0; i<6; i++)

     #if NUM_FRAGMENT>0
     uniform int fNumEffects;                     // total number of fragment effects
     layout (std140) uniform fUniformProperties
+      {
       ivec4 fProperties[NUM_FRAGMENT];           // their properties, 4 ints:
     uniform ivec4 fProperties[NUM_FRAGMENT];     // their properties, 4 ints:
                                                  // name of the effect, unused, unused, unused
       };
     layout (std140) uniform fUniformFloats
+      {
       vec4 fUniforms[3*NUM_FRAGMENT];            // i-th effect is 3 consecutive vec4's: [3*i], [3*i+1], [3*i+2].
     uniform vec4 fUniforms[3*NUM_FRAGMENT];      // i-th effect is 3 consecutive vec4's: [3*i], [3*i+1], [3*i+2].
                                                  // The first vec4 is the Interpolated values,
                                                  // second vec4: first float - cache, next 3: Center, the third - the Region.
       };
     #endif    // NUM_FRAGMENT>0

Project

General

Profile

Distorted Android

Revision 2b7d2abb

Added by Leszek Koltunski over 3 years ago