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.main;

import org.distorted.library.effect.Effect;

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[] mName;

  protected int[] mType;

  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 static int[] mMax = new int[Effect.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;

  private static boolean mCreated;

  static

    {

    onDestroy();

    }

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

  EffectQueue(long id, int numUniforms, int numCache, int index)

    {

    mNumEffects   = 0;

    mTotalEffects = 0;

    mMaxIndex     = index;

    mObjectID     = id;

    int max = mMax[mMaxIndex];

    if( max>0 )

      {

      mName            = new int[max];

      mType            = new int[max];

      mUniforms        = new float[numUniforms*max];

      mInter           = new Dynamic[3][max];

      mCurrentDuration = new long[max];

      mID              = new long[max];

      mIDIndex         = new byte[max];

      mFreeIndexes     = new byte[max];

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

      if( numCache>0 )

        {

        mCache = new float[numCache*max];

        }

      }

    mCreated = true;  

    }

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

  @SuppressWarnings("unused")

  int getNumEffects()

    {

    return mNumEffects;  

    }

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

// Only max Byte.MAX_VALUE concurrent effects per DistortedEffects object.

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

// (although probably this many uniforms will not fit in the shaders anyway!)

  static boolean setMax(int index, int m)

    {

    if( (!mCreated && !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 registerForMessages(EffectListener el)

    {

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

    if( !mListeners.contains(el) )

      {

      mListeners.add(el);

      mNumListeners++;

      }

    }

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

  void deregisterForMessages(EffectListener el)

    {

    if( mListeners.remove(el) )

      {

      mNumListeners--;

      }

    }

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

  static void onDestroy()

    {

    Effect.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(Effect effect)

    {

    int ret  = 0;

    int name = effect.getName();

    int type = effect.getType();

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

      {

      if( mName[i]==name && mType[i]==type )

        {

        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 removedName, 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];

        removedName= mName[i];

        removedType= mType[i];

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

          EffectMessageSender.newMessage( mListeners.elementAt(j),

                                          EffectMessage.EFFECT_REMOVED,

                                          (removedID<<Effect.LENGTH)+removedType,

                                          removedName,

                                          mObjectID);

        }

      }

    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 removedName= mName[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++ ) 

      {

      mName[j]            = mName[j+1];

      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<<Effect.LENGTH)+removedType,

                                      removedName,

                                      mObjectID);

    }

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

  protected long addBase(Effect effect)

    {

    int type = effect.getType();

    mName[mNumEffects] = effect.getName();

    mType[mNumEffects] = type;

    mCurrentDuration[mNumEffects] = 0;

    int index = mFreeIndexes[mNumEffects];

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

    mID[mNumEffects] = id;

    mIDIndex[index] = mNumEffects;  

    mNumEffects++; 

    mTotalEffects++;

    return (id<<Effect.LENGTH)+type;

    }

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

// used only for debugging

  @SuppressWarnings("unused")

  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 ) android.util.Log.e("EffectQueue","inter[0]: "+mInter[0][index].print());

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

      if( !inter2 ) 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);

  }

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