/ - Diff - Distorted Android

           if( mInter[1][i]!=null )
+            {
             mInter[1][i].interpolateMain( mUniforms, NUM_UNIFORMS*i+4, mCurrentDuration[i]);
             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]);
           if( mInter[2][i]!=null ) mInter[2][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+1, mCurrentDuration[i], step);
           mCurrentDuration[i] += step;
+          }
-...
           EffectNames.fillWithUnities(eln.ordinal(), mUniforms, NUM_UNIFORMS*mNumEffects);
           if( data instanceof Dynamic1D)
+            {
             mInter[0][mNumEffects] = (Dynamic1D)data;
+            }
           else if( data instanceof Static1D )
+            {
             mInter[0][mNumEffects] = null;
-...
           EffectNames.fillWithUnities(eln.ordinal(), mUniforms, NUM_UNIFORMS*mNumEffects);
           if( data instanceof Dynamic1D)
+            {
             mInter[0][mNumEffects] = (Dynamic1D)data;
+            }
           else if( data instanceof Static1D )
+            {
             mInter[0][mNumEffects] = null;
-...
           else return -1;
           if( region instanceof Dynamic4D)
+            {
             mInter[1][mNumEffects] = (Dynamic4D)region;
+            }
           else if( region instanceof Static4D )
+            {
             mInter[1][mNumEffects]  = null;
-...
           EffectNames.fillWithUnities(eln.ordinal(), mUniforms, NUM_UNIFORMS*mNumEffects);
           if( level instanceof Dynamic1D)
+            {
             mInter[0][mNumEffects] = (Dynamic1D)level;
+            }
           else if( level instanceof Static1D )
+            {
             mInter[0][mNumEffects] = null;
-...
           else return -1;
           if( region instanceof Dynamic4D)
+            {
             mInter[1][mNumEffects] = (Dynamic4D)region;
+            }
           else if( region instanceof Static4D )
+            {
             mInter[1][mNumEffects]  = null;
-...
           EffectNames.fillWithUnities(eln.ordinal(), mUniforms, NUM_UNIFORMS*mNumEffects);
           if( level instanceof Dynamic1D)
+            {
             mInter[0][mNumEffects] = (Dynamic1D)level;
+            }
           else if( level instanceof Static1D )
+            {
             mInter[0][mNumEffects] = null;

           if( mInter[1][i]!=null )
+            {
             mInter[1][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+4, mCurrentDuration[i]);
             mInter[1][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+4, mCurrentDuration[i], step);
+            }
           mCurrentDuration[i] += step;
-...
+          {
           mInter[1][mNumEffects] = null;
                if( vector instanceof Dynamic3D) mInter[0][mNumEffects] = (Dynamic3D)vector;
           if( vector instanceof Dynamic3D)
+            {
             mInter[0][mNumEffects] = (Dynamic3D)vector;
+            }
           else if( vector instanceof Static3D )
+            {
             mInter[0][mNumEffects] = null;
-...
+        {
         if( mMax[INDEX]>mNumEffects )
+          {
                if( angle instanceof Dynamic1D) mInter[0][mNumEffects] = (Dynamic1D)angle;
           if( angle instanceof Dynamic1D)
+            {
             mInter[0][mNumEffects] = (Dynamic1D)angle;
+            }
           else if( angle instanceof Static1D)
+            {
             mInter[0][mNumEffects] = null;
-...
           mUniforms[NUM_UNIFORMS*mNumEffects+2] = axis.getY();
           mUniforms[NUM_UNIFORMS*mNumEffects+3] = axis.getZ();
           if( center instanceof Dynamic3D) mInter[1][mNumEffects] = (Dynamic3D)center;
           if( center instanceof Dynamic3D)
+            {
             mInter[1][mNumEffects] = (Dynamic3D)center;
+            }
           else if( center instanceof Static3D )
+            {
             mInter[1][mNumEffects] = null;
-...
+        {
         if( mMax[INDEX]>mNumEffects )
+          {
                if( data instanceof Dynamic4D  ) mInter[0][mNumEffects] = (Dynamic4D)data;
           else if( data instanceof DynamicQuat) mInter[0][mNumEffects] = (DynamicQuat)data;
           if( data instanceof Dynamic4D  )
+            {
             mInter[0][mNumEffects] = (Dynamic4D)data;
+            }
           else if( data instanceof DynamicQuat)
+            {
             mInter[0][mNumEffects] = (DynamicQuat)data;
+            }
           else if( data instanceof Static4D   )
+            {
             mInter[0][mNumEffects] = null;
-...
+            }
           else return -1;
           if( center instanceof Dynamic3D) mInter[1][mNumEffects] = (Dynamic3D)center;
           if( center instanceof Dynamic3D)
+            {
             mInter[1][mNumEffects] = (Dynamic3D)center;
+            }
           else if( center instanceof Static3D )
+            {
             mInter[1][mNumEffects] = null;
-...
+        {
         if( mMax[INDEX]>mNumEffects )
+          {
                if( shear instanceof Dynamic3D) mInter[0][mNumEffects] = (Dynamic3D)shear;
           if( shear instanceof Dynamic3D)
+            {
             mInter[0][mNumEffects] = (Dynamic3D)shear;
+            }
           else if( shear instanceof Static3D )
+            {
             mInter[0][mNumEffects] = null;
-...
+            }
           else return -1;
           if( center instanceof Dynamic3D) mInter[1][mNumEffects] = (Dynamic3D)center;
           if( center instanceof Dynamic3D)
+            {
             mInter[1][mNumEffects] = (Dynamic3D)center;
+            }
           else if( center instanceof Static3D )
+            {
             mInter[1][mNumEffects] = null;

           if( mInter[1][i]!=null )  // region
+            {
             mInter[1][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+8, mCurrentDuration[i]);
             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+6, mCurrentDuration[i]);
             mInter[2][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+6, mCurrentDuration[i], step);
             mUniforms[NUM_UNIFORMS*i+6] = mUniforms[NUM_UNIFORMS*i+6]-mObjHalfX;
             mUniforms[NUM_UNIFORMS*i+7] =-mUniforms[NUM_UNIFORMS*i+7]+mObjHalfY;
-...
           EffectNames.fillWithUnities(eln.ordinal(), mUniforms, NUM_UNIFORMS*mNumEffects);
           if( data instanceof Dynamic5D)
+            {
             mInter[0][mNumEffects] = (Dynamic5D)data;
+            }
           else if( data instanceof Static5D)
+            {
             Static5D tmp = (Static5D)data;
-...
           EffectNames.fillWithUnities(eln.ordinal(), mUniforms, NUM_UNIFORMS*mNumEffects);
           if( data instanceof Dynamic3D)
+            {
             mInter[0][mNumEffects] = (Dynamic3D)data;
+            }
           else if( data instanceof Static3D)
+            {
             Static3D tmp = (Static3D)data;
-...
           EffectNames.fillWithUnities(eln.ordinal(), mUniforms, NUM_UNIFORMS*mNumEffects);
           if( data instanceof Dynamic1D)
+            {
             mInter[0][mNumEffects] = (Dynamic1D)data;
+            }
           else if( data instanceof Static1D)
+            {
             mInter[0][mNumEffects] = null;
-...
           EffectNames.fillWithUnities(eln.ordinal(), mUniforms, NUM_UNIFORMS*mNumEffects);
           if( data instanceof Dynamic1D)
+            {
             mInter[0][mNumEffects] = (Dynamic1D)data;
+            }
           else if( data instanceof Static1D)
+            {
             mInter[0][mNumEffects] = null;
-...
+          }
         if( center instanceof Dynamic2D)
+          {
           mInter[2][mNumEffects] = (Dynamic2D)center;
+          }
         else if( center instanceof Static2D)
+          {
           mInter[2][mNumEffects] = null;

        */
       public static final int MODE_JUMP = 2;
       /**
        * The default mode of access. When in this mode, we are able to call interpolate() with points in time
        * in any random order. This means one single Dynamic can be used in many effects simultaneously.
        * On the other hand, when in this mode, it is not possible to smoothly interpolate when mDuration suddenly
        * changes.
        */
       public static final int ACCESS_RANDOM     = 0;
       /**
        * Set the mode to ACCESS_SEQUENTIAL if you need to change mDuration and you would rather have the Dynamic
        * keep on smoothly interpolating.
        * On the other hand, in this mode, a Dynamic can only be accessed in sequential manner, which means one
        * one Dynamic can only be used in one effect at a time.
        */
       public static final int ACCESS_SEQUENTIAL = 1;
       protected int mDimension;
       protected int numPoints;
       protected int mSegment;       // between which pair of points are we currently? (in case of PATH this is a bit complicated!)
-...
       protected int mMode;          // LOOP, PATH or JUMP
       protected long mDuration;     // number of milliseconds it takes to do a full loop/path from first vector to the last and back to the first
       protected float mCount;       // number of loops/paths we will do; mCount = 1.5 means we go from the first vector to the last, back to first, and to the last again.
       protected double mLastPos;
       protected int mAccessMode;
       protected class VectorNoise
+        {
-...
         mCount     = count;
         mDimension = dimension;
         mSegment   = -1;
         mLastPos   = -1;
         mAccessMode= ACCESS_RANDOM;
         baseV      = new float[mDimension][mDimension];
         buf        = new float[mDimension];
         old        = new float[mDimension];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void interpolateMain(float[] buffer, int offset, long currentDuration)
+        {
         if( mDuration<=0.0f )
+          {
           interpolate(buffer,offset,mCount-(int)mCount);
+          }
         else
+          {
           double x = (double)currentDuration/mDuration;
           if( x<=mCount || mCount<=0.0f )
+            {
             interpolate(buffer,offset, (float)(x-(int)x) );
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean interpolateMain(float[] buffer, int offset, long currentDuration, long step)
+        {
         if( mDuration<=0.0f )
+          {
           interpolate(buffer,offset,mCount-(int)mCount);
           return false;
+          }
         double x = (double)currentDuration/mDuration;
         if( x<=mCount || mCount<=0.0f )
+          {
           interpolate(buffer,offset, (float)(x-(int)x) );
           if( currentDuration+step > mDuration*mCount && mCount>0.0f )
+            {
             interpolate(buffer,offset,mCount-(int)mCount);
             return true;
+            }
+          }
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected float noise(float time,int vecNum)
-...
         mDuration = duration;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the access mode this Dynamic will be working in.
+     *
      * @param mode ACCESS_RANDOM or ACCESS_SEQUENTIAL.
      *             see {@link Dynamic#ACCESS_RANDOM}.
      *             see {@link Dynamic#ACCESS_SEQUENTIAL}.
      */
       public void setAccessMode(int mode)
+        {
         mAccessMode = mode;
         mLastPos = -1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Writes the results of interpolation between the Points at time 'time' to the passed float buffer.
+     *
      * @param buffer Float buffer we will write the resulting Static1D to.
      * @param offset Offset in the buffer where to write the result.
      * @param time Time of interpolation. Time=0.0 would return the first Point, Time=0.5 - the last,
      *             time=1.0 - the first again, and time 0.1 would be 1/5 of the way between the first and the last Points.
      */
       public void interpolateMain(float[] buffer, int offset, long time)
+        {
         if( mDuration<=0.0f )
+          {
           interpolate(buffer,offset,mCount-(int)mCount);
+          }
         else
+          {
           double pos = (double)time/mDuration;
           if( pos<=mCount || mCount<=0.0f )
+            {
             interpolate(buffer,offset, (float)(pos-(int)pos) );
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Writes the results of interpolation between the Points at time 'time' to the passed float buffer.
      * <p>
      * This version differs from the previous in that it returns a boolean value which indicates whether
      * the interpolation is finished.
+     *
      * @param buffer Float buffer we will write the resulting Static1D to.
      * @param offset Offset in the buffer where to write the result.
      * @param time Time of interpolation. Time=0.0 would return the first Point, Time=0.5 - the last,
      *             time=1.0 - the first again, and time 0.1 would be 1/5 of the way between the first and the last Points.
      * @param step Time difference between now and the last time we called this function. Needed to figure out
      *             if the previous time we were called the effect wasn't finished yet, but now it is.
      * @return true if the interpolation reached its end.
      */
       public boolean interpolateMain(float[] buffer, int offset, long time, long step)
+        {
         if( mDuration<=0.0f )
+          {
           interpolate(buffer,offset,mCount-(int)mCount);
           return false;
+          }
         double pos;
         if( mAccessMode==ACCESS_SEQUENTIAL )
+          {
           pos = mLastPos<0 ? (double)time/mDuration : (double)step/mDuration + mLastPos;
           mLastPos = pos;
+          }
         else
+          {
           pos = (double)time/mDuration;
+          }
         if( pos<=mCount || mCount<=0.0f )
+          {
           interpolate(buffer,offset, (float)(pos-(int)pos) );
           if( time+step > mDuration*mCount && mCount>0.0f )
+            {
             interpolate(buffer,offset,mCount-(int)mCount);
             return true;
+            }
+          }
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // end of DistortedInterpolator
+      }

+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Writes the results of interpolation between the Points at time 'time' to the passed float buffer.
      * <p>
      * Since this is a 1-dimensional Dynamic, the resulting interpolated Static1D gets written
      * to a single location in the buffer: buffer[offset].
+     *
      * @param buffer Float buffer we will write the resulting Static1D to.
      * @param offset Offset in the buffer where to write the result.
      * @param time Time of interpolation. Time=0.0 would return the first Point, Time=0.5 - the last,
      *             time=1.0 - the first again, and time 0.1 would be 1/5 of the way between the first and the last Points.
      */
       synchronized void interpolate(float[] buffer, int offset, float time)
+        {
         switch(numPoints)

+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Writes the results of interpolation between the Points at time 'time' to the passed float buffer.
      * <p>
      * Since this is a 2-dimensional Dynamic, the resulting interpolated Static2D gets written
      * to two locations in the buffer: buffer[offset] and buffer[offset+1].
+     *
      * @param buffer Float buffer we will write the resulting Static2D to.
      * @param offset Offset in the buffer where to write the result.
      * @param time Time of interpolation. Time=0.0 would return the first Point, Time=0.5 - the last,
      *             time=1.0 - the first again, and time 0.1 would be 1/5 of the way between the first and the last Points.
      */
       synchronized void interpolate(float[] buffer, int offset, float time)
+        {
         switch(numPoints)

+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Writes the results of interpolation between the Points at time 'time' to the passed float buffer.
      * <p>
      * Since this is a 3-dimensional Dynamic, the resulting interpolated Static3D gets written
      * to three locations in the buffer: buffer[offset], buffer[offset+1] and buffer[offset+2].
+     *
      * @param buffer Float buffer we will write the resulting Static3D to.
      * @param offset Offset in the buffer where to write the result.
      * @param time Time of interpolation. Time=0.0 would return the first Point, Time=0.5 - the last,
      *             time=1.0 - the first again, and time 0.1 would be 1/5 of the way between the first and the last Points.
      */
       synchronized void interpolate(float[] buffer, int offset, float time)
+        {
         switch(numPoints)

+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Writes the results of interpolation between the Points at time 'time' to the passed float buffer.
      * <p>
      * Since this is a 4-dimensional Dynamic, the resulting interpolated Static4D gets written
      * to four locations in the buffer: buffer[offset], buffer[offset+1], buffer[offset+2] and buffer[offset+3].
+     *
      * @param buffer Float buffer we will write the resulting Static4D to.
      * @param offset Offset in the buffer where to write the result.
      * @param time Time of interpolation. Time=0.0 would return the first Point, Time=0.5 - the last,
      *             time=1.0 - the first again, and time 0.1 would be 1/5 of the way between the first and the last Points.
      */
       synchronized void interpolate(float[] buffer, int offset, float time)
+        {
         switch(numPoints)

+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Writes the results of interpolation between the Points at time 'time' to the passed float buffer.
      * <p>
      * Since this is a 5-dimensional Dynamic, the resulting interpolated Static5D gets written
      * to five locations in the buffer: buffer[offset],...,buffer[offset+4].
+     *
      * @param buffer Float buffer we will write the resulting Static5D to.
      * @param offset Offset in the buffer where to write the result.
      * @param time Time of interpolation. Time=0.0 would return the first Point, Time=0.5 - the last,
      *             time=1.0 - the first again, and time 0.1 would be 1/5 of the way between the first and the last Points.
      */
       synchronized void interpolate(float[] buffer, int offset, float time)
+        {
         switch(numPoints)

         mMode      = MODE_LOOP;
         mDuration  = duration;
         mCount     = count;
         mLastPos   = -1;
         mAccessMode= ACCESS_RANDOM;
         mDimension = 4;
+        }
-...
      * @param time Time of interpolation. Time=0.0 would return the first Point, Time=0.5 - the last,
      *             time=1.0 - the first again, and time 0.1 would be 1/5 of the way between the first and the last Points.
      */
       public synchronized void interpolate(float[] buffer, int offset, float time)
       synchronized void interpolate(float[] buffer, int offset, float time)
+        {
         switch(numPoints)
+          {

Project

General

Profile

Distorted Android

Revision bdb341bc

Added by Leszek Koltunski over 7 years ago