Distorted Android

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.library;

import org.distorted.library.message.EffectListener;

import org.distorted.library.message.EffectMessage;

import org.distorted.library.type.Dynamic;

import java.util.Vector;

///////////////////////////////////////////////////////////////////////////////////////////////////

abstract class EffectQueue

  {

  protected byte mNumEffects;   // number of effects at the moment

  protected long mTotalEffects; // total number of effects ever created

  protected int[] mType;

  protected float[] mUniforms;

  protected Dynamic[][] mInter;  // center of the effect

  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 mBitmapID;

  private static boolean mCreated;

  static

    {

    reset();

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public EffectQueue(DistortedObject obj, int numUniforms, 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;

      mBitmapID = obj.getID();

      }

    if( mMax[mMaxIndex]>0 )

      {

      mType            = new int[mMax[mMaxIndex]];

      mUniforms        = new float[numUniforms*mMax[mMaxIndex]];

      mInter           = new Dynamic[3][mMax[mMaxIndex]];

      mCurrentDuration = new long[mMax[mMaxIndex]];

      mID              = new long[mMax[mMaxIndex]];

      mIDIndex         = new byte[mMax[mMaxIndex]];

      mFreeIndexes     = new byte[mMax[mMaxIndex]];

      for(byte i=0; i<mMax[mMaxIndex]; i++) mFreeIndexes[i] = i;

      }

    mCreated = true;  

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  int getNumEffects()

    {

    return mNumEffects;  

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// Only max Byte.MAX_VALUE concurrent effects per DistortedObject.

// If you want more, change type of the mNumEffects, mIDIndex and mFreeIndexes variables to shorts.

  static boolean setMax(int index, int m)

    {

    if( (mCreated==false && !Distorted.isInitialized()) || m<=mMax[index] )

      {

      if( m<0              ) m = 0;

      else if( m>Byte.MAX_VALUE ) m = Byte.MAX_VALUE;

      mMax[index] = m;

      return true;

      }

    return false;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  static int getMax(int index)

    {

    return mMax[index];

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  void addListener(EffectListener el)

    {

    if( mListeners==null ) mListeners = new Vector<>(2,2);

    mListeners.add(el);

    mNumListeners++;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  void removeListener(EffectListener el)

    {

    if( mNumListeners>0 )  

      {

      mListeners.remove(el);

      mNumListeners--;

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  static void reset()

    {

    EffectTypes.reset(mMax);

    mCreated = false;  

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  synchronized int removeByID(long id)

    {

    int i = getEffectIndex(id);

    if( i>=0 ) 

      {

      remove(i);

      return 1;

      }

    return 0;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  synchronized int removeByType(EffectNames effect)

    {

    int ret = 0;

    int ord = effect.ordinal();  

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

      {

      if( mType[i]==ord )

        {

        remove(i);

        i--;

        ret++;

        }

      }

    return ret;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private synchronized int getEffectIndex(long id)

    {

    int index = mIDIndex[(int)(id%mMax[mMaxIndex])];

    return (index<mNumEffects && mID[index]==id ? index : -1);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// we do want to notify Listeners if they called 'abortAll' themselves but don't want to notify

// them if it is the library itself which is releasing resources.

  synchronized int abortAll(boolean notify)

    {

    int ret = mNumEffects;

    long removedID;

    int removedType;

    for(int i=0; i<ret; i++ )

      {

      mInter[0][i] = null;

      mInter[1][i] = null;

      mInter[2][i] = null;

      if( notify )

        {

        removedID = mID[i];

        removedType= mType[i];

        for(int j=0; j<mNumListeners; j++)

          EffectMessageSender.newMessage( mListeners.elementAt(j),

                                          EffectMessage.EFFECT_REMOVED,

                                          (removedID<<EffectTypes.LENGTH)+EffectNames.getType(removedType).type,

                                          removedType,

                                          mBitmapID,

                                          null);

        }

      }

    mNumEffects= 0;

    return ret;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// this assumes 0<=effect<mNumEffects

  protected void remove(int effect)

    {

    mNumEffects--;     

    byte removedIndex = (byte)(mID[effect]%mMax[mMaxIndex]);

    byte removedPosition = mIDIndex[removedIndex];

    mFreeIndexes[mNumEffects] = removedIndex;

    long removedID = mID[effect];

    int removedType= mType[effect];

    for(int j=0; j<mMax[mMaxIndex]; j++)

      {

      if( mIDIndex[j] > removedPosition ) mIDIndex[j]--; 

      }

    for(int j=effect; j<mNumEffects; j++ ) 

      {

      mType[j]            = mType[j+1];

      mInter[0][j]        = mInter[0][j+1];

      mInter[1][j]        = mInter[1][j+1];

      mInter[2][j]        = mInter[2][j+1];

      mCurrentDuration[j] = mCurrentDuration[j+1];

      mID[j]              = mID[j+1];

      moveEffect(j);

      }

    mInter[0][mNumEffects] = null;

    mInter[1][mNumEffects] = null;

    mInter[2][mNumEffects] = null;

    for(int i=0; i<mNumListeners; i++) 

      EffectMessageSender.newMessage( mListeners.elementAt(i),

                                      EffectMessage.EFFECT_REMOVED,

                                      (removedID<<EffectTypes.LENGTH)+EffectNames.getType(removedType).type,

                                      removedType,

                                      mBitmapID,

                                      null);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  protected long addBase(EffectNames eln)

    {    

    mType[mNumEffects]  = eln.ordinal();  

    mCurrentDuration[mNumEffects] = 0;

    int index = mFreeIndexes[mNumEffects];

    long id = mTotalEffects*mMax[mMaxIndex] + index;

    mID[mNumEffects] = id;

    mIDIndex[index] = mNumEffects;  

    mNumEffects++; 

    mTotalEffects++;

    return (id<<EffectTypes.LENGTH)+eln.getType().type;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// used only for debugging

  protected String printEffects(int max)

    {

    long[] indexes = new long[mMax[mMaxIndex]];

    for(int g=0; g<mMax[mMaxIndex]; g++)

      {

      indexes[g] = -1;  

      }

    String ret="(";

    int f;

    for(int g=0; g<max; g++) 

      {

      f = getEffectIndex(g);

      if( f>=0 ) indexes[f] = g;

      }

    for(int g=0; g<mMax[mMaxIndex]; g++)

      {

      ret += (g>0 ? ",":"")+(indexes[g]>=0 ? indexes[g] : " ");   

      }

    ret += ")";

    return ret;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// Only used for debugging

  protected boolean printByID(long id)

    {

    int index = getEffectIndex(id);

    if( index>=0 ) 

      {

      boolean inter0 = mInter[0][index]==null;

      boolean inter1 = mInter[1][index]==null;

      boolean inter2 = mInter[2][index]==null;

      android.util.Log.e("EffectQueue", "numEffects="+mNumEffects+" effect id="+id+" index="+index+

                         " duration="+mCurrentDuration[index]+" inter[0] null="+inter0+" inter[1] null="+inter1+" inter[2] null="+inter2);

      if( inter0==false )

        {

        android.util.Log.e("EffectQueue","inter[0]: "+mInter[0][index].print());

        }

      if( inter1==false )

        {

        android.util.Log.e("EffectQueue","inter[1]: "+mInter[1][index].print());

        }

      if( inter2==false )

        {

        android.util.Log.e("EffectQueue","inter[2]: "+mInter[2][index].print());

        }

      return true;

      }

    android.util.Log.e("EffectQueue", "effect id="+id+" not found");

    return false;  

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  abstract void moveEffect(int index);

  }

///////////////////////////////////////////////////////////////////////////////////////////////////