Project

General

Profile

« Previous | Next » 

Revision 0a046359

Added by Leszek Koltunski over 7 years ago

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

View differences:

src/main/java/org/distorted/library/EffectQueueVertex.java
43 43 
class EffectQueueVertex extends EffectQueue
44 44 
  {
45 45 
  private static final int NUM_UNIFORMS = 12;
46 
  private static final int NUM_CACHE    =  3;
46 47 
  private static final int INDEX = EffectTypes.VERTEX.ordinal();
47 48 
  private static int mNumEffectsH;
48 49 
  private static int mTypeH;
......
50 51
51 52 
///////////////////////////////////////////////////////////////////////////////////////////////////
52 53
53 
  EffectQueueVertex(DistortedObject obj)
54 
  EffectQueueVertex(long id)
54 55 
    {
55 
    super(obj,NUM_UNIFORMS,INDEX);
56 
    super(id,NUM_UNIFORMS,NUM_CACHE,INDEX);
56 57 
    }
57 58 

  		




  58
  59
  
    
///////////////////////////////////////////////////////////////////////////////////////////////////


  		




  ......




  102
  103
  
    
          }


  		




  103
  104
  
    
        }


  		




  104
  105
  
    

  		




  105
  
  
    
      if( mInter[1][i]!=null )  // region


  		




  106
  
  
    
        {


  		




  107
  
  
    
        mInter[1][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+8, mCurrentDuration[i], step);


  		




  108
  
  
    
        }


  		




  109
  
  
    

  		




  110
  
  
    
      if( mInter[2][i]!=null )  // center


  		




  111
  
  
    
        {


  		




  112
  
  
    
        mInter[2][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+5, mCurrentDuration[i], step);


  		




  113
  
  
    

  		




  114
  
  
    
        mUniforms[NUM_UNIFORMS*i+5] = mUniforms[NUM_UNIFORMS*i+5]-mObjHalfX;


  		




  115
  
  
    
        mUniforms[NUM_UNIFORMS*i+6] =-mUniforms[NUM_UNIFORMS*i+6]+mObjHalfY;


  		




  116
  
  
    
        mUniforms[NUM_UNIFORMS*i+7] = mUniforms[NUM_UNIFORMS*i+7]-mObjHalfZ;


  		




  117
  
  
    
        }


  		




  
  106
  
    
      if( mInter[1][i]!=null ) mInter[1][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+8, mCurrentDuration[i], step);


  		




  
  107
  
    
      if( mInter[2][i]!=null ) mInter[2][i].interpolateMain(mCache   , NUM_CACHE*i     , mCurrentDuration[i], step);


  		




  118
  108
  
    

  		




  119
  109
  
    
      mCurrentDuration[i] += step;


  		




  120
  110
  
    
      }


  		




  ......




  131
  121
  
    
    mUniforms[NUM_UNIFORMS*index+ 2] = mUniforms[NUM_UNIFORMS*(index+1)+ 2];


  		




  132
  122
  
    
    mUniforms[NUM_UNIFORMS*index+ 3] = mUniforms[NUM_UNIFORMS*(index+1)+ 3];


  		




  133
  123
  
    
    mUniforms[NUM_UNIFORMS*index+ 4] = mUniforms[NUM_UNIFORMS*(index+1)+ 4];


  		




  134
  
  
    
    mUniforms[NUM_UNIFORMS*index+ 5] = mUniforms[NUM_UNIFORMS*(index+1)+ 5];


  		




  135
  
  
    
    mUniforms[NUM_UNIFORMS*index+ 6] = mUniforms[NUM_UNIFORMS*(index+1)+ 6];


  		




  136
  
  
    
    mUniforms[NUM_UNIFORMS*index+ 7] = mUniforms[NUM_UNIFORMS*(index+1)+ 7];


  		




  
  124
  
    

  		




  
  125
  
    
    mCache[NUM_CACHE*index  ] = mCache[NUM_CACHE*(index+1)  ];


  		




  
  126
  
    
    mCache[NUM_CACHE*index+1] = mCache[NUM_CACHE*(index+1)+1];


  		




  
  127
  
    
    mCache[NUM_CACHE*index+2] = mCache[NUM_CACHE*(index+1)+2];


  		




  
  128
  
    

  		




  137
  129
  
    
    mUniforms[NUM_UNIFORMS*index+ 8] = mUniforms[NUM_UNIFORMS*(index+1)+ 8];


  		




  138
  130
  
    
    mUniforms[NUM_UNIFORMS*index+ 9] = mUniforms[NUM_UNIFORMS*(index+1)+ 9];


  		




  139
  131
  
    
    mUniforms[NUM_UNIFORMS*index+10] = mUniforms[NUM_UNIFORMS*(index+1)+10];


  		




  ......




  142
  134
  
    
   


  		




  143
  135
  
    
///////////////////////////////////////////////////////////////////////////////////////////////////


  		




  144
  136
  
    

  		




  145
  
  
    
  synchronized void send() 


  		




  
  137
  
    
  synchronized void send(int halfX, int halfY, int halfZ)


  		




  146
  138
  
    
    {


  		




  147
  139
  
    
    GLES20.glUniform1i( mNumEffectsH, mNumEffects);


  		




  148
  140
  
    
      


  		




  149
  141
  
    
    if( mNumEffects>0 )


  		




  150
  
  
    
      {     


  		




  
  142
  
    
      {


  		




  
  143
  
    
      for(int i=0; i<mNumEffects; i++)


  		




  
  144
  
    
        {


  		




  
  145
  
    
        mUniforms[NUM_UNIFORMS*i+5] = mCache[NUM_CACHE*i  ]-halfX;


  		




  
  146
  
    
        mUniforms[NUM_UNIFORMS*i+6] =-mCache[NUM_CACHE*i+1]+halfY;


  		




  
  147
  
    
        mUniforms[NUM_UNIFORMS*i+7] = mCache[NUM_CACHE*i+2]-halfZ;


  		




  
  148
  
    
        }


  		




  
  149
  
    

  		




  151
  150
  
    
      GLES20.glUniform1iv( mTypeH    ,  mNumEffects, mName    ,0);


  		




  152
  151
  
    
      GLES20.glUniform4fv( mUniformsH,3*mNumEffects, mUniforms,0);


  		




  153
  152
  
    
      }


  		




  ......




  391
  390
  
    
    else if( center instanceof Static3D)


  		




  392
  391
  
    
      {


  		




  393
  392
  
    
      mInter[2][mNumEffects] = null;


  		




  394
  
  
    
      mUniforms[NUM_UNIFORMS*mNumEffects+5] = ((Static3D)center).getX()-mObjHalfX;


  		




  395
  
  
    
      mUniforms[NUM_UNIFORMS*mNumEffects+6] =-((Static3D)center).getY()+mObjHalfY;


  		




  396
  
  
    
      mUniforms[NUM_UNIFORMS*mNumEffects+7] = ((Static3D)center).getZ()-mObjHalfZ;


  		




  
  393
  
    
      mCache[NUM_CACHE*mNumEffects  ] = ((Static3D)center).getX();


  		




  
  394
  
    
      mCache[NUM_CACHE*mNumEffects+1] = ((Static3D)center).getY();


  		




  
  395
  
    
      mCache[NUM_CACHE*mNumEffects+2] = ((Static3D)center).getZ();


  		




  397
  396
  
    
      }


  		




  398
  397
  
    

  		




  399
  398
  
    
    long ret= addBase(eln);


  		












Also available in:  Unified diff