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

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.EffectName;

import org.distorted.library.effect.EffectType;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.InternalMaster;

import org.distorted.library.mesh.MeshBase;

import java.util.ArrayList;

import java.util.HashMap;

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

/**

 * Not part of public API, do not document

 *

 * @y.exclude

 */

public abstract class EffectQueue implements InternalMaster.Slave

  {

  public static final int MAIN_VARIANTS = 4; // Number of Main program variants (ATM 4: MAIN, MAIN OIT, PREPROCESS, FULL)

  private static final int CREATE = 0;

  private static final int ATTACH = 1;

  private static final int DETACH = 2;

  private static final int DETALL = 3;

  int mNumEffects;              // 'ToBe' will be more than mNumEffects if doWork() hasn't

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

  float[] mUniforms;

  private int mNumUniforms;

  long[] mCurrentDuration;

  Effect[] mEffects;

  int[] mName;

  int[] mAssociation;

  int[] mComponent;

  long mTime;

  private static int[] mMax = new int[EffectType.LENGTH];

  private static long mNextID;

  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;

  private int mIndex;

  private boolean mCreated;

  private static class Job

    {

    int type;

    int num;

    boolean notify;

    Effect effect;

    Job(int t, int m, boolean n, Effect e)

      {

      type  = t;

      num   = m;

      notify= n;

      effect= e;

      }

    }

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

  static

    {

    onDestroy();

    }

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

  EffectQueue(int numUniforms, int index)

    {

    mCreated            = false;

    mTime               = 0;

    mID                 = 0;

    mNumEffects         = 0;

    mNumEffectsToBe     = 0;

    mIndex              = index;

    mNumUniforms        = numUniforms;

    mJobs.add(new Job(CREATE,numUniforms,false,null)); // create the stuff that depends on max number

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

    }

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

  EffectQueue(EffectQueue source)

    {

    if( !source.mCreated )

      {

      mCreated            = false;

      mTime               = 0;

      mID                 = 0;

      mNumEffects         = 0;

      mNumEffectsToBe     = 0;

      mIndex              = source.mIndex;

      mNumUniforms        = source.mNumUniforms;

      int numJobs = source.mJobs.size();

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

        {

        Job job = source.mJobs.get(i);

        mJobs.add(job);

        }

      InternalMaster.newSlave(this);

      }

    else

      {

      mCreated            = true;

      mTime               = source.mTime;

      mID                 = source.mID;

      mNumEffects         = source.mNumEffects;

      mNumEffectsToBe     = source.mNumEffectsToBe;

      mIndex              = source.mIndex;

      mNumUniforms        = source.mNumUniforms;

      int max = mMax[mIndex];

      if( max>0 )

        {

        mUniforms        = new float[max*source.mNumUniforms];

        mCurrentDuration = new long[max];

        mEffects         = new Effect[max];

        mName            = new int[max];

        mAssociation     = new int[max];

        mComponent       = new int[max];

        }

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

        {

        mEffects[i]         = source.mEffects[i];

        mCurrentDuration[i] = source.mCurrentDuration[i];

        mName[i]            = source.mName[i];

        mAssociation[i]     = source.mAssociation[i];

        mComponent[i]       = source.mComponent[i];

        }

      }

    }

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

  public static void allocateQueues(EffectQueue[] queues, EffectQueue[] from, int flags)

    {

    queues[0] = (flags & DistortedLibrary.CLONE_MATRIX     ) != 0 ? from[0] : new EffectQueueMatrix();

    queues[1] = (flags & DistortedLibrary.CLONE_VERTEX     ) != 0 ? from[1] : new EffectQueueVertex();

    queues[2] = (flags & DistortedLibrary.CLONE_FRAGMENT   ) != 0 ? from[2] : new EffectQueueFragment();

    queues[3] = (flags & DistortedLibrary.CLONE_POSTPROCESS) != 0 ? from[3] : new EffectQueuePostprocess();

    }

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

  public static void compute(EffectQueue[] queues, long currTime)

    {

    ((EffectQueueMatrix     )queues[0]).compute(currTime);

    ((EffectQueueVertex     )queues[1]).compute(currTime);

    ((EffectQueueFragment   )queues[2]).compute(currTime);

    ((EffectQueuePostprocess)queues[3]).compute(currTime);

    }

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

  public static void send(EffectQueue[] queues, float distance, float mipmap,

                          float[] projection, float inflate, MeshBase mesh, int variant )

    {

    ((EffectQueueMatrix  )queues[0]).send(distance, mipmap, projection, mesh, variant);

    ((EffectQueueVertex  )queues[1]).send(inflate, variant);

    ((EffectQueueFragment)queues[2]).send(variant);

    }

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

  public static float[] getMVP(EffectQueue[] queues)

    {

    return ((EffectQueueMatrix)queues[0]).getMVP();

    }

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

// variant: 0 --> MAIN  1 --> OIT  2 --> prePOST  3 --> FULL

  public static void getUniforms(int programH, int variant)

    {

    EffectQueueFragment.uniforms(programH,variant);

    EffectQueueVertex  .uniforms(programH,variant);

    EffectQueueMatrix  .uniforms(programH,variant);

    }

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

// Every effect queue has an ID, which should be the same iff two queues hold the same effects.

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

// especially important in case of postprocessing)

  private void regenerateID()

    {

    if( mNumEffects>0 )

      {

      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;

      }

    }

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

  public long getID()

    {

    return mID;

    }

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

  public static boolean setMax(int index, int m)

    {

    if( !DistortedLibrary.isInitialized() || m<=mMax[index] )

      {

      mMax[index] = m<0 ? 0:m;

      return true;

      }

    return false;

    }

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

  public static int getMax(int index)

    {

    return mMax[index];

    }

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

  public static void onDestroy()

    {

    mNextID = 1;

    mMapID.clear();

    EffectType.reset(mMax);

    }

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

// this assumes 0<=effect<mNumEffects

  protected void remove(int effect)

    {

    mNumEffects--;

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

      {

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

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

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

      mAssociation[j]     = mAssociation[j+1];

      mComponent[j]       = mComponent[j+1];

      }

    mEffects[mNumEffects] = null;

    }

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

  public synchronized int removeByName(EffectName name)

    {

    int ret = 0;

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

      {

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

        {

        mJobs.add(new Job(DETACH,0,true,mEffects[i]));

        ret++;

        }

      }

    if( ret>0 )

      {

      InternalMaster.newSlave(this);

      mNumEffectsToBe-=ret;

      }

    return ret;

    }

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

  public synchronized int removeById(long id)

    {

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

      {

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

        {

        mJobs.add(new Job(DETACH,0,true,mEffects[i]));

        InternalMaster.newSlave(this);

        mNumEffectsToBe--;

        return 1;

        }

      }

    return 0;

    }

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

  public synchronized int removeEffect(Effect effect)

    {

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

      {

      if( mEffects[i]==effect )

        {

        mJobs.add(new Job(DETACH,0,true,mEffects[i]));

        InternalMaster.newSlave(this);

        mNumEffectsToBe--;

        return 1;

        }

      }

    return 0;

    }

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

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

  public synchronized int removeAll(boolean notify)

    {

    mJobs.add(new Job(DETALL,0,notify,null));

    InternalMaster.newSlave(this);

    mNumEffectsToBe = 0;

    return mNumEffects;

    }

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

  public boolean add(Effect effect)

    {

    if( mMax[mIndex]>mNumEffectsToBe || !mCreated )

      {

      mJobs.add(new Job(ATTACH,-1,false,effect));

      InternalMaster.newSlave(this);

      mNumEffectsToBe++;

      return true;

      }

    return false;

    }

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

  public boolean add(Effect effect, int position)

    {

    if( mMax[mIndex]>mNumEffectsToBe || !mCreated )

      {

      mJobs.add(new Job(ATTACH,position,false,effect));

      InternalMaster.newSlave(this);

      mNumEffectsToBe++;

      return true;

      }

    return false;

    }

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

  public int getNumEffects()

    {

    return mNumEffects;

    }

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

  public int getNumEffectsToBe()

    {

    return mNumEffectsToBe;

    }

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

  public Effect getEffect(int position)

    {

    if( position>=0 && position< mNumEffects )

      {

      return mEffects[position];

      }

    else

      {

      android.util.Log.e("queue", "getEffect: out of range "+position);

      return null;

      }

    }

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

  public void doWork()

    {

    boolean changed = false;

    int num = mJobs.size();

    Job job;

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

      {

      job = mJobs.remove(0);

      switch(job.type)

        {

        case CREATE: int max = mMax[mIndex];

                     if( max>0 )

                       {

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

                       mCurrentDuration = new long[max];

                       mEffects         = new Effect[max];

                       mName            = new int[max];

                       mAssociation     = new int[max];

                       mComponent       = new int[max];

                       }

                     mCreated = true;

                     break;

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

                       {                            // added effects and then lowered mMax

                       int position = job.num;

                       if( position==-1 )

                         {

                         mCurrentDuration[mNumEffects] = 0;

                         mEffects[mNumEffects]    = job.effect;

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

                         mAssociation[mNumEffects]= job.effect.getAssociation();

                         mComponent[mNumEffects]  = job.effect.getComponent();

                         mNumEffects++;

                         changed = true;

                         }

                       else if( position>=0 && position<=mNumEffects )

                         {

                         for(int j=mNumEffects; j>position; j--)

                           {

                           mCurrentDuration[j] = mCurrentDuration[j-1];

                           mEffects[j]         = mEffects[j-1];

                           mName[j]            = mName[j-1];

                           mAssociation[j]     = mAssociation[j-1];

                           mComponent[j]       = mComponent[j-1];

                           }

                         mCurrentDuration[position] = 0;

                         mEffects[position]    = job.effect;

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

                         mAssociation[position]= job.effect.getAssociation();

                         mComponent[position]  = job.effect.getComponent();

                         mNumEffects++;

                         changed = true;

                         }

                       }

                     else

                       {

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

                       }

                     break;

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

                       {

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

                         {

                         remove(j);

                         changed = true;

                         break;

                         }

                       }

                     break;

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

                       {

                       changed = true;

                       mEffects[j] = null;

                       }

                     mNumEffects= 0;

                     break;

        }

      }

    if( changed && mIndex==EffectType.POSTPROCESS.ordinal() ) regenerateID();

    }

  }