commit 0a046359a04c84edbf74868743443ef9e58c7028
Author: Leszek Koltunski <leszek@distoretedandroid.org>
Date:   Mon Dec 12 13:23:01 2016 +0000

    The EffectQueues are now totally independent of the size of the underlying Bitmap.

diff --git a/src/main/java/org/distorted/library/DistortedObject.java b/src/main/java/org/distorted/library/DistortedObject.java
index a9d26b5..8ba143a 100644
--- a/src/main/java/org/distorted/library/DistortedObject.java
+++ b/src/main/java/org/distorted/library/DistortedObject.java
@@ -71,6 +71,7 @@ public abstract class DistortedObject
   private boolean matrixCloned, vertexCloned, fragmentCloned;
   private long mID;
   private int mSizeX, mSizeY, mSizeZ; // in screen space
+  private int mHalfX, mHalfY, mHalfZ; // halfs of the above
 
   protected DistortedObjectGrid mGrid = null;
 
@@ -104,9 +105,9 @@ public abstract class DistortedObject
 
   protected void initializeData(int x, int y, int z)
     {
-    mSizeX= x;
-    mSizeY= y;
-    mSizeZ= z;
+    mSizeX= x; mHalfX = x/2;
+    mSizeY= y; mHalfY = y/2;
+    mSizeZ= z; mHalfZ = z/2;
 
     mID = mNextID++;
     mObjects.put(mID,this);
@@ -127,6 +128,8 @@ public abstract class DistortedObject
     
   private void initializeEffectLists(DistortedObject d, int flags)
     {
+    long objID = d.getID();
+
     if( (flags & Distorted.CLONE_MATRIX) != 0 )
       {
       mM = d.mM;
@@ -134,7 +137,7 @@ public abstract class DistortedObject
       }
     else
       {
-      mM = new EffectQueueMatrix(d);
+      mM = new EffectQueueMatrix(objID);
       matrixCloned = false;
       }
     
@@ -145,7 +148,7 @@ public abstract class DistortedObject
       }
     else
       {
-      mV = new EffectQueueVertex(d);
+      mV = new EffectQueueVertex(objID);
       vertexCloned = false;
       }
     
@@ -156,7 +159,7 @@ public abstract class DistortedObject
       }
     else
       {
-      mF = new EffectQueueFragment(d);
+      mF = new EffectQueueFragment(objID);
       fragmentCloned = false;
       }
     }
@@ -192,15 +195,15 @@ public abstract class DistortedObject
     DistortedFramebuffer.deleteAllMarked();
 
     GLES20.glViewport(0, 0, df.mWidth, df.mHeight);
-      
+
     mM.compute(currTime);
-    mM.send(df);
+    mM.send(df,mHalfX,mHalfY,mHalfZ);
       
     mV.compute(currTime);
-    mV.send();
+    mV.send(mHalfX,mHalfY,mHalfZ);
         
     mF.compute(currTime);
-    mF.send();
+    mF.send(mHalfX,mHalfY);
        
     mGrid.draw();
     }
@@ -210,7 +213,8 @@ public abstract class DistortedObject
   void drawNoEffectsPriv(DistortedFramebuffer df)
     {
     GLES20.glViewport(0, 0, df.mWidth, df.mHeight);
-    mM.sendZero(df);
+
+    mM.sendZero(df,mHalfX,mHalfY,mHalfZ);
     mV.sendZero();
     mF.sendZero();
     mGrid.draw();
@@ -295,6 +299,9 @@ public abstract class DistortedObject
     mSizeX = dc.mSizeX;
     mSizeY = dc.mSizeY;
     mSizeZ = dc.mSizeZ;
+    mHalfX = dc.mHalfX;
+    mHalfY = dc.mHalfY;
+    mHalfZ = dc.mHalfZ;
     mGrid  = dc.mGrid;
 
     if( (flags & Distorted.CLONE_BITMAP) != 0 )
@@ -368,7 +375,10 @@ public abstract class DistortedObject
   public void setBitmap(Bitmap bmp)
     {
     mBitmapSet[0] = true;
-      
+
+    mSizeX= bmp.getWidth() ; mHalfX = mSizeX/2;
+    mSizeY= bmp.getHeight(); mHalfY = mSizeY/2;
+
     if( Distorted.isInitialized() )
       {
       GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
diff --git a/src/main/java/org/distorted/library/EffectQueue.java b/src/main/java/org/distorted/library/EffectQueue.java
index b394fed..0c932e4 100644
--- a/src/main/java/org/distorted/library/EffectQueue.java
+++ b/src/main/java/org/distorted/library/EffectQueue.java
@@ -31,21 +31,17 @@ abstract class EffectQueue
   {
   protected byte mNumEffects;   // number of effects at the moment
   protected long mTotalEffects; // total number of effects ever created
-  
   protected int[] mName;
   protected float[] mUniforms;
+  protected float[] mCache;
   protected Dynamic[][] mInter;
   protected long[] mCurrentDuration;
   protected byte[] mFreeIndexes;
   protected byte[] mIDIndex;
   protected long[] mID;
-  
   protected long mTime=0;
-  protected float mObjHalfX, mObjHalfY, mObjHalfZ;
-  
   protected static int[] mMax = new int[EffectTypes.LENGTH];
   protected int mMaxIndex;
-
   protected Vector<EffectListener> mListeners =null;
   protected int mNumListeners=0;  // ==mListeners.length(), but we only create mListeners if the first one gets added
   protected long mObjectID;
@@ -59,19 +55,12 @@ abstract class EffectQueue
   
 ///////////////////////////////////////////////////////////////////////////////////////////////////
    
-  EffectQueue(DistortedObject obj, int numUniforms, int index)
+  EffectQueue(long id, int numUniforms, int numCache, int index)
     {
     mNumEffects   = 0;
     mTotalEffects = 0;
     mMaxIndex     = index;
-
-    if( obj!=null )
-      {
-      mObjHalfX = obj.getWidth() / 2.0f;
-      mObjHalfY = obj.getHeight()/ 2.0f;
-      mObjHalfZ = obj.getDepth() / 2.0f;
-      mObjectID = obj.getID();
-      }
+    mObjectID     = id;
 
     if( mMax[mMaxIndex]>0 )
       {
@@ -84,6 +73,11 @@ abstract class EffectQueue
       mFreeIndexes     = new byte[mMax[mMaxIndex]];
      
       for(byte i=0; i<mMax[mMaxIndex]; i++) mFreeIndexes[i] = i;
+
+      if( numCache>0 )
+        {
+        mCache = new float[numCache*mMax[mMaxIndex]];
+        }
       }
    
     mCreated = true;  
diff --git a/src/main/java/org/distorted/library/EffectQueueFragment.java b/src/main/java/org/distorted/library/EffectQueueFragment.java
index babd491..943ba2f 100644
--- a/src/main/java/org/distorted/library/EffectQueueFragment.java
+++ b/src/main/java/org/distorted/library/EffectQueueFragment.java
@@ -37,6 +37,7 @@ import org.distorted.library.type.Static4D;
 class EffectQueueFragment extends EffectQueue
   {
   private static final int NUM_UNIFORMS = 8;
+  private static final int NUM_CACHE    = 4;
   private static final int INDEX = EffectTypes.FRAGMENT.ordinal();
   private static int mNumEffectsH;
   private static int mTypeH;
@@ -44,9 +45,9 @@ class EffectQueueFragment extends EffectQueue
   
 ///////////////////////////////////////////////////////////////////////////////////////////////////
    
-  EffectQueueFragment(DistortedObject obj)
+  EffectQueueFragment(long id)
     { 
-    super(obj,NUM_UNIFORMS,INDEX);
+    super(id,NUM_UNIFORMS,NUM_CACHE,INDEX);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -87,15 +88,8 @@ class EffectQueueFragment extends EffectQueue
         else mInter[0][i] = null;
         }
 
-      if( mInter[1][i]!=null )
-        {
-        mInter[1][i].interpolateMain( mUniforms, NUM_UNIFORMS*i+4, mCurrentDuration[i], step);
-
-        mUniforms[NUM_UNIFORMS*i+4] = mUniforms[NUM_UNIFORMS*i+4]-mObjHalfX;
-        mUniforms[NUM_UNIFORMS*i+5] =-mUniforms[NUM_UNIFORMS*i+5]+mObjHalfY;
-        }
-
-      if( mInter[2][i]!=null ) mInter[2][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+1, mCurrentDuration[i], step);
+      if( mInter[1][i]!=null ) mInter[1][i].interpolateMain( mCache   , NUM_CACHE*i     , mCurrentDuration[i], step);
+      if( mInter[2][i]!=null ) mInter[2][i].interpolateMain( mUniforms, NUM_UNIFORMS*i+1, mCurrentDuration[i], step);
 
       mCurrentDuration[i] += step;
       }
@@ -112,23 +106,28 @@ class EffectQueueFragment extends EffectQueue
     mUniforms[NUM_UNIFORMS*index+2] = mUniforms[NUM_UNIFORMS*(index+1)+2];
     mUniforms[NUM_UNIFORMS*index+3] = mUniforms[NUM_UNIFORMS*(index+1)+3];
 
-    if( mInter[1][index]==null )
-      {
-      mUniforms[NUM_UNIFORMS*index+4] = mUniforms[NUM_UNIFORMS*(index+1)+4];
-      mUniforms[NUM_UNIFORMS*index+5] = mUniforms[NUM_UNIFORMS*(index+1)+5];
-      mUniforms[NUM_UNIFORMS*index+6] = mUniforms[NUM_UNIFORMS*(index+1)+6];
-      mUniforms[NUM_UNIFORMS*index+7] = mUniforms[NUM_UNIFORMS*(index+1)+7];
-      }
+    mCache[NUM_CACHE*index  ] = mCache[NUM_CACHE*(index+1)  ];
+    mCache[NUM_CACHE*index+1] = mCache[NUM_CACHE*(index+1)+1];
+    mCache[NUM_CACHE*index+2] = mCache[NUM_CACHE*(index+1)+2];
+    mCache[NUM_CACHE*index+3] = mCache[NUM_CACHE*(index+1)+3];
     }
   
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   
-  synchronized void send() 
+  synchronized void send(int halfX, int halfY)
     {
     GLES20.glUniform1i( mNumEffectsH, mNumEffects);
-      
+
     if( mNumEffects>0 )
-      {     
+      {
+      for(int i=0; i<mNumEffects; i++)
+        {
+        mUniforms[NUM_UNIFORMS*i+4] = mCache[NUM_CACHE*i  ]-halfX;
+        mUniforms[NUM_UNIFORMS*i+5] =-mCache[NUM_CACHE*i+1]+halfY;
+        mUniforms[NUM_UNIFORMS*i+6] = mCache[NUM_CACHE*i+2];
+        mUniforms[NUM_UNIFORMS*i+7] = mCache[NUM_CACHE*i+3];
+        }
+
       GLES20.glUniform1iv( mTypeH    ,  mNumEffects, mName    ,0);
       GLES20.glUniform4fv( mUniformsH,2*mNumEffects, mUniforms,0);
       }  
@@ -162,8 +161,8 @@ class EffectQueueFragment extends EffectQueue
       else return -1;
 
       mInter[1][mNumEffects] = null;
-      mUniforms[NUM_UNIFORMS*mNumEffects+6] = Float.MAX_VALUE;
-      mUniforms[NUM_UNIFORMS*mNumEffects+7] = Float.MAX_VALUE;
+      mCache[NUM_CACHE*mNumEffects+2] = Float.MAX_VALUE;
+      mCache[NUM_CACHE*mNumEffects+3] = Float.MAX_VALUE;
 
       mInter[2][mNumEffects] = null;
 
@@ -200,10 +199,10 @@ class EffectQueueFragment extends EffectQueue
       else if( region instanceof Static4D )
         {
         mInter[1][mNumEffects]  = null;
-        mUniforms[NUM_UNIFORMS*mNumEffects+4] = ((Static4D)region).getX()-mObjHalfX;
-        mUniforms[NUM_UNIFORMS*mNumEffects+5] =-((Static4D)region).getY()+mObjHalfY;
-        mUniforms[NUM_UNIFORMS*mNumEffects+6] = ((Static4D)region).getZ();
-        mUniforms[NUM_UNIFORMS*mNumEffects+7] = ((Static4D)region).getW();
+        mCache[NUM_CACHE*mNumEffects  ] = ((Static4D)region).getX();
+        mCache[NUM_CACHE*mNumEffects+1] = ((Static4D)region).getY();
+        mCache[NUM_CACHE*mNumEffects+2] = ((Static4D)region).getZ();
+        mCache[NUM_CACHE*mNumEffects+3] = ((Static4D)region).getW();
         }
       else return -1;
 
@@ -255,10 +254,10 @@ class EffectQueueFragment extends EffectQueue
       else if( region instanceof Static4D )
         {
         mInter[1][mNumEffects]  = null;
-        mUniforms[NUM_UNIFORMS*mNumEffects+4] = ((Static4D)region).getX()-mObjHalfX;
-        mUniforms[NUM_UNIFORMS*mNumEffects+5] =-((Static4D)region).getY()+mObjHalfY;
-        mUniforms[NUM_UNIFORMS*mNumEffects+6] = ((Static4D)region).getZ();
-        mUniforms[NUM_UNIFORMS*mNumEffects+7] = ((Static4D)region).getW();
+        mCache[NUM_CACHE*mNumEffects  ] = ((Static4D)region).getX();
+        mCache[NUM_CACHE*mNumEffects+1] = ((Static4D)region).getY();
+        mCache[NUM_CACHE*mNumEffects+2] = ((Static4D)region).getZ();
+        mCache[NUM_CACHE*mNumEffects+3] = ((Static4D)region).getW();
         }
       else return -1;
 
@@ -302,8 +301,8 @@ class EffectQueueFragment extends EffectQueue
       else return -1;
 
       mInter[1][mNumEffects]  = null;
-      mUniforms[NUM_UNIFORMS*mNumEffects+6] = Float.MAX_VALUE;
-      mUniforms[NUM_UNIFORMS*mNumEffects+7] = Float.MAX_VALUE;
+      mCache[NUM_CACHE*mNumEffects+2] = Float.MAX_VALUE;
+      mCache[NUM_CACHE*mNumEffects+3] = Float.MAX_VALUE;
 
       return addBase(eln);
       }
diff --git a/src/main/java/org/distorted/library/EffectQueueMatrix.java b/src/main/java/org/distorted/library/EffectQueueMatrix.java
index 2e345ac..3ae44a3 100644
--- a/src/main/java/org/distorted/library/EffectQueueMatrix.java
+++ b/src/main/java/org/distorted/library/EffectQueueMatrix.java
@@ -39,6 +39,7 @@ import org.distorted.library.type.Static4D;
 class EffectQueueMatrix extends EffectQueue
   {   
   private static final int NUM_UNIFORMS = 7;
+  private static final int NUM_CACHE    = 0;
   private static final int INDEX = EffectTypes.MATRIX.ordinal();
 
   private static float[] mMVPMatrix = new float[16];
@@ -52,9 +53,9 @@ class EffectQueueMatrix extends EffectQueue
   
 ///////////////////////////////////////////////////////////////////////////////////////////////////
    
-  EffectQueueMatrix(DistortedObject obj)
+  EffectQueueMatrix(long id)
     { 
-    super(obj,NUM_UNIFORMS, INDEX );
+    super(id,NUM_UNIFORMS,NUM_CACHE,INDEX );
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -153,7 +154,7 @@ class EffectQueueMatrix extends EffectQueue
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // here construct the ModelView Matrix
 
-  synchronized void send(DistortedFramebuffer df)
+  synchronized void send(DistortedFramebuffer df, int halfX, int halfY, int halfZ)
     {
     Matrix.setIdentityM(mViewMatrix, 0);
     Matrix.translateM(mViewMatrix, 0, -df.mWidth/2, df.mHeight/2, -df.mDistance);
@@ -229,10 +230,10 @@ class EffectQueueMatrix extends EffectQueue
         }
       }
    
-    Matrix.translateM(mViewMatrix, 0, mObjHalfX,-mObjHalfY, 0);
+    Matrix.translateM(mViewMatrix, 0, halfX,-halfY, 0);
     Matrix.multiplyMM(mMVPMatrix, 0, df.mProjectionMatrix, 0, mViewMatrix, 0);
     
-    GLES20.glUniform3f( mObjDH , mObjHalfX, mObjHalfY, mObjHalfZ);
+    GLES20.glUniform3f( mObjDH , halfX, halfY, halfZ);
     GLES20.glUniform1f( mDepthH, df.mDepth);
     GLES20.glUniformMatrix4fv(mMVMatrixH , 1, false, mViewMatrix, 0);
     GLES20.glUniformMatrix4fv(mMVPMatrixH, 1, false, mMVPMatrix , 0);
@@ -241,13 +242,13 @@ class EffectQueueMatrix extends EffectQueue
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // here construct the ModelView Matrix, but without any effects
 
-  synchronized void sendZero(DistortedFramebuffer df)
+  synchronized void sendZero(DistortedFramebuffer df, int halfX, int halfY, int halfZ)
     {
     Matrix.setIdentityM(mTmpMatrix, 0);
-    Matrix.translateM(mTmpMatrix, 0, mObjHalfX-df.mWidth/2, df.mHeight/2-mObjHalfY, -df.mDistance);
+    Matrix.translateM(mTmpMatrix, 0, halfX-df.mWidth/2, df.mHeight/2-halfY, -df.mDistance);
     Matrix.multiplyMM(mMVPMatrix, 0, df.mProjectionMatrix, 0, mTmpMatrix, 0);
     
-    GLES20.glUniform3f( mObjDH , mObjHalfX, mObjHalfY, mObjHalfZ);
+    GLES20.glUniform3f( mObjDH , halfX, halfY, halfZ);
     GLES20.glUniform1f( mDepthH, df.mDepth);
     GLES20.glUniformMatrix4fv(mMVMatrixH , 1, false, mTmpMatrix, 0);
     GLES20.glUniformMatrix4fv(mMVPMatrixH, 1, false, mMVPMatrix, 0);
diff --git a/src/main/java/org/distorted/library/EffectQueueVertex.java b/src/main/java/org/distorted/library/EffectQueueVertex.java
index 3e184f7..90529db 100644
--- a/src/main/java/org/distorted/library/EffectQueueVertex.java
+++ b/src/main/java/org/distorted/library/EffectQueueVertex.java
@@ -43,6 +43,7 @@ import org.distorted.library.type.Static5D;
 class EffectQueueVertex extends EffectQueue
   { 
   private static final int NUM_UNIFORMS = 12;
+  private static final int NUM_CACHE    =  3;
   private static final int INDEX = EffectTypes.VERTEX.ordinal();
   private static int mNumEffectsH;
   private static int mTypeH;
@@ -50,9 +51,9 @@ class EffectQueueVertex extends EffectQueue
   
 ///////////////////////////////////////////////////////////////////////////////////////////////////
    
-  EffectQueueVertex(DistortedObject obj)
+  EffectQueueVertex(long id)
     { 
-    super(obj,NUM_UNIFORMS,INDEX);
+    super(id,NUM_UNIFORMS,NUM_CACHE,INDEX);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -102,19 +103,8 @@ class EffectQueueVertex extends EffectQueue
           }
         }
 
-      if( mInter[1][i]!=null )  // region
-        {
-        mInter[1][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+8, mCurrentDuration[i], step);
-        }
-
-      if( mInter[2][i]!=null )  // center
-        {
-        mInter[2][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+5, mCurrentDuration[i], step);
-
-        mUniforms[NUM_UNIFORMS*i+5] = mUniforms[NUM_UNIFORMS*i+5]-mObjHalfX;
-        mUniforms[NUM_UNIFORMS*i+6] =-mUniforms[NUM_UNIFORMS*i+6]+mObjHalfY;
-        mUniforms[NUM_UNIFORMS*i+7] = mUniforms[NUM_UNIFORMS*i+7]-mObjHalfZ;
-        }
+      if( mInter[1][i]!=null ) mInter[1][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+8, mCurrentDuration[i], step);
+      if( mInter[2][i]!=null ) mInter[2][i].interpolateMain(mCache   , NUM_CACHE*i     , mCurrentDuration[i], step);
 
       mCurrentDuration[i] += step;
       }
@@ -131,9 +121,11 @@ class EffectQueueVertex extends EffectQueue
     mUniforms[NUM_UNIFORMS*index+ 2] = mUniforms[NUM_UNIFORMS*(index+1)+ 2];
     mUniforms[NUM_UNIFORMS*index+ 3] = mUniforms[NUM_UNIFORMS*(index+1)+ 3];
     mUniforms[NUM_UNIFORMS*index+ 4] = mUniforms[NUM_UNIFORMS*(index+1)+ 4];
-    mUniforms[NUM_UNIFORMS*index+ 5] = mUniforms[NUM_UNIFORMS*(index+1)+ 5];
-    mUniforms[NUM_UNIFORMS*index+ 6] = mUniforms[NUM_UNIFORMS*(index+1)+ 6];
-    mUniforms[NUM_UNIFORMS*index+ 7] = mUniforms[NUM_UNIFORMS*(index+1)+ 7];
+
+    mCache[NUM_CACHE*index  ] = mCache[NUM_CACHE*(index+1)  ];
+    mCache[NUM_CACHE*index+1] = mCache[NUM_CACHE*(index+1)+1];
+    mCache[NUM_CACHE*index+2] = mCache[NUM_CACHE*(index+1)+2];
+
     mUniforms[NUM_UNIFORMS*index+ 8] = mUniforms[NUM_UNIFORMS*(index+1)+ 8];
     mUniforms[NUM_UNIFORMS*index+ 9] = mUniforms[NUM_UNIFORMS*(index+1)+ 9];
     mUniforms[NUM_UNIFORMS*index+10] = mUniforms[NUM_UNIFORMS*(index+1)+10];
@@ -142,12 +134,19 @@ class EffectQueueVertex extends EffectQueue
    
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  synchronized void send() 
+  synchronized void send(int halfX, int halfY, int halfZ)
     {
     GLES20.glUniform1i( mNumEffectsH, mNumEffects);
       
     if( mNumEffects>0 )
-      {     
+      {
+      for(int i=0; i<mNumEffects; i++)
+        {
+        mUniforms[NUM_UNIFORMS*i+5] = mCache[NUM_CACHE*i  ]-halfX;
+        mUniforms[NUM_UNIFORMS*i+6] =-mCache[NUM_CACHE*i+1]+halfY;
+        mUniforms[NUM_UNIFORMS*i+7] = mCache[NUM_CACHE*i+2]-halfZ;
+        }
+
       GLES20.glUniform1iv( mTypeH    ,  mNumEffects, mName    ,0);
       GLES20.glUniform4fv( mUniformsH,3*mNumEffects, mUniforms,0);
       }
@@ -391,9 +390,9 @@ class EffectQueueVertex extends EffectQueue
     else if( center instanceof Static3D)
       {
       mInter[2][mNumEffects] = null;
-      mUniforms[NUM_UNIFORMS*mNumEffects+5] = ((Static3D)center).getX()-mObjHalfX;
-      mUniforms[NUM_UNIFORMS*mNumEffects+6] =-((Static3D)center).getY()+mObjHalfY;
-      mUniforms[NUM_UNIFORMS*mNumEffects+7] = ((Static3D)center).getZ()-mObjHalfZ;
+      mCache[NUM_CACHE*mNumEffects  ] = ((Static3D)center).getX();
+      mCache[NUM_CACHE*mNumEffects+1] = ((Static3D)center).getY();
+      mCache[NUM_CACHE*mNumEffects+2] = ((Static3D)center).getZ();
       }
 
     long ret= addBase(eln);