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 java.util.Vector;

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

abstract class EffectQueue

  {

  protected byte mNumEffects;

  protected float[] mUniforms;

  protected long[] mCurrentDuration;

  protected Effect[] mEffects;

  protected int[] mName;

  protected long mTime=0;

  protected static int[] mMax = new int[Effect.LENGTH];

  protected Vector<EffectListener> mListeners =null;

  protected int mNumListeners=0;  // ==mListeners.length(), but we only create mListeners if the first one gets added

  protected long mID;

  private static boolean mCreated;

  private int mIndex;

  private int mNumUniforms;

  static

    {

    onDestroy();

    }

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

  EffectQueue(long id, int numUniforms, int index)

    {

    mNumEffects  = 0;

    mID          = id;

    mIndex       = index;

    mNumUniforms = numUniforms;

    int max = mMax[mIndex];

    if( max>0 )

      {

      mUniforms        = new float[mNumUniforms*max];

      mCurrentDuration = new long[max];

      mEffects         = new Effect[max];

      mName            = new int[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 removeByType(Effect effect)

    {

    int ret = 0;

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

      {

      if( mEffects[i]==effect )

        {

        remove(i);

        i--;

        ret++;

        }

      }

    return ret;

    }

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

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

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

      {

      if( notify )

        {

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

          EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_REMOVED, mEffects[i].getID(), mID);

        }

      mEffects[i] = null;

      }

    mNumEffects= 0;

    return ret;

    }

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

// this assumes 0<=effect<mNumEffects

  protected void remove(int effect)

    {

    mNumEffects--;     

    long removedID = mEffects[effect].getID();

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

      {

      mEffects[j]         = mEffects[j+1];

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

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

      for(int k=0; k<mNumUniforms; k++)

        mUniforms[mNumUniforms*j+k] = mUniforms[mNumUniforms*(j+1)+k];

      }

    mEffects[mNumEffects] = null;

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

      EffectMessageSender.newMessage( mListeners.elementAt(i), EffectMessage.EFFECT_REMOVED, removedID, mID);

    }

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

  public void add(Effect effect)

    {

    if( mMax[mIndex]>mNumEffects )

      {

      mCurrentDuration[mNumEffects] = 0;

      mEffects[mNumEffects] = effect;

      mName[mNumEffects] = effect.getName();

      mNumEffects++;

      }

    }

  }