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

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

import org.distorted.library.effect.EffectType;

import org.distorted.library.message.EffectMessage;

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

  private static final int ATTACH = 1;

  private static final int DETACH = 2;

  private static final int DETALL = 3;

  int mNumEffectsToBe;  // added them yet (or less if it hasn't removed some yet)

  float[] mUniforms;

  long[] mCurrentDuration;

  Effect[] mEffects;

  int[] mName;

  long mTime=0;

  ArrayList<EffectListener> mListeners =null;

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

  long mDistortedEffectsID;

  private static HashMap<ArrayList<Long>,Long> mMapID = new HashMap<>(); // maps lists of Effect IDs (longs) to a

                                                                         // single long - the queue ID.

  private long mID;

    {

    int type;

    Effect effect;

      type  = t;

      effect= e;

      }

    }

  private ArrayList<Job> mJobs = new ArrayList<>();

    {

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

    mIndex              = index;

    DistortedMaster.newSlave(this);                     // of uniforms later, on first render.

// (this is a speedup: then both queues can be applied once, which seriously speeds up stuff -

// especially important in case of postprocessing)

      {

      ArrayList<Long> list = new ArrayList<>();

      for (int i = 0; i < mNumEffects; i++) list.add(mEffects[i].getID());

      Long id = mMapID.get(list);

      if( id!=null )

        {

        mID = id;

        }

      else

        {

        mMapID.put(list,mNextID);

        mID = mNextID++;

        }

      }

    else

      {

      mID = 0;

      }

    int numNodes = (mNodes==null ? 0: mNodes.size());

    for(int i=0; i<numNodes; i++) mNodes.get(i).sort();

    if( mIndex == EffectType.MATRIX.ordinal() )

      android.util.Log.d("queue", "queueM id="+mID);

    if( mIndex == EffectType.VERTEX.ordinal() )

      android.util.Log.d("queue", "queueV id="+mID);

    if( mIndex == EffectType.FRAGMENT.ordinal() )

      android.util.Log.d("queue", "queueF id="+mID);

    if( mIndex == EffectType.POSTPROCESS.ordinal() )

      android.util.Log.d("queue", "queueP id="+mID);

*/

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

  void newNode(DistortedNode node)

    {

    if( mNodes==null ) mNodes = new ArrayList<>();

    mNodes.add(node);

    }

    {

    return mNumEffects;  

    }

  long getID()

    {

    return mID;

    }

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

  static boolean setMax(int index, int m)

    {

      }

    return false;

    }

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

  static int getMax(int index)

    {

    return mMax[index];

    }

    if( !mListeners.contains(el) )

      {

      mListeners.add(el);

      mNumListeners++;

      }

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

      mNumListeners--;

      }

    }

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

    mMapID.clear();

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

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

      }

    mEffects[mNumEffects] = null;

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

      EffectMessageSender.newMessage( mListeners.get(i), EffectMessage.EFFECT_REMOVED, removedID, mDistortedEffectsID);

    }

  synchronized int removeByName(EffectName name)

    {

      {

      if( mEffects[i].getName() == name )

        {

      }

      {

      DistortedMaster.newSlave(this);

      mNumEffectsToBe-=ret;

      }

    return ret;

  synchronized int removeById(long id)

    {

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

      {

      if( mEffects[i].getID() == id )

        {

        mNumEffectsToBe--;

        return 1;

      }

  synchronized int removeEffect(Effect effect)

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

      {

        mNumEffectsToBe--;

        return 1;

      }

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

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

  synchronized int abortAll(boolean notify)

    mNumEffectsToBe = 0;

    return mNumEffects;

    }

  boolean add(Effect effect)

    {

    if( mMax[mIndex]>mNumEffectsToBe )

      //android.util.Log.e("queue", "queue id="+mDistortedEffectsID);

      mNumEffectsToBe++;

      return true;

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

 * This is not really part of the public API. Has to be public only because it is a part of the

 * DistortedSlave interface, which should really be a class that we extend here instead but

 * Java has no multiple inheritance.

 *

 * @y.exclude

 */

  public void doWork()

    Job job;

        {

                       {

                       mUniforms        = new float[max*job.num];

                       mCurrentDuration = new long[max];

                       mEffects         = new Effect[max];

                       mName            = new int[max];

                       }

                     break;

        case ATTACH: if( mMax[mIndex]>mNumEffects ) // it is possible that we have first

                       {                            // added effects and then lowered mMax

                       mCurrentDuration[mNumEffects] = 0;

                       mEffects[mNumEffects] = job.effect;

                       mName[mNumEffects] = job.effect.getName().ordinal();

                       mNumEffects++;

                       }

                     else

                       {

                       android.util.Log.e("queue", "failed to add effect "+job.effect.getName());

                       }

                       if (mEffects[j] == job.effect)

                         {

                         remove(j);

                         break;

                         }

                       }

        case DETALL: for(int j=0; j<mNumEffects; j++ )

                       {

                       if( job.notify )

                         {

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

                           EffectMessageSender.newMessage( mListeners.get(k), EffectMessage.EFFECT_REMOVED, mEffects[j].getID(), mDistortedEffectsID);

                         }

                       mEffects[j] = null;

                       }

                     mNumEffects= 0;

                     break;

        }

  }