Distorted Android

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

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

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

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

import org.distorted.library.main.InternalStackFrameList;

import org.distorted.library.uniformblock.UniformBlockFloatUniforms;

import java.util.ArrayList;

import java.util.HashMap;

/**

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)

  static final int VERT_INT_UBO_BINDING = 5;

  private static final int CREATE = 0;

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

  Effect[] mEffects;

  UniformBlockFloatUniforms mUBF;

  private long mID;

  private final int mIndex;

  private boolean mCreated;

  private static class Job

    {

    int num1, num2;

    boolean bool;

    Effect effect;

    Job(int t, int m1, int m2, boolean n, Effect e)

      {

      num1  = m1;

      bool  = n;

      effect= e;

  private final ArrayList<Job> mJobs;

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

  EffectQueue(int numFloatUniforms, int numIntUniforms, boolean useUBO, int index)

    {

    mCreated        = false;

    mJobs = new ArrayList<>();

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

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

    }

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

// this is not thread safe! The 'source' might change while we're copying it.

      mCreated        = false;

      mJobs = new ArrayList<>();

      mCreated        = true;

      mJobs = new ArrayList<>();

      int max = InternalStackFrameList.getMax(mIndex);

      if( max>0 )

        {

        mEffects= new Effect[max];

        }

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

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

    {

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

    }

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

    {

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

    }

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

                          float[] projection, float inflate, int variant )

    {

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

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

    }

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

  public static void getUniforms(int programH, int variant)

    {

    EffectQueueFragment.uniforms(programH,variant);

    }

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

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

  private void regenerateID()

    {

    if( mNumEffects>0 )

      HashMap<ArrayList<Long>,Long> map = InternalStackFrameList.getMap();

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

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

        mID = InternalStackFrameList.getNextQueueID();

        }

    }

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

  public long getID()

    {

  public static boolean setMax(int index, int m)

    {

    return InternalStackFrameList.setMax(index, Math.max(m,0));

    }

  public static int getMax(int index)

    {

    return InternalStackFrameList.getMax(index);

    }

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

// this assumes 0<=effect

  private void removeNow(int pos)

    {

    if( mNumEffects>pos )

      {

      mNumEffects--;

      mEffects[pos].remQueue(this);

      System.arraycopy(mEffects, pos+1, mEffects, pos, mNumEffects-pos);

      mUBI.remove(pos, mNumEffects);

      mEffects[mNumEffects] = null;

      }

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

    mEffects[pos] = effect;

    mUBI.addOrdinal(pos, effect.getName().ordinal() );

    effect.addQueue(this);

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

      mUBI.addAssociations(pos,effect);

      }

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

  public synchronized int removeByName(EffectName name)

    {

    int ret = 0;

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

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

        ret++;

        }

    if( ret>0 )

      InternalMaster.newSlave(this);

      mNumEffectsToBe-=ret;

    }

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

  public synchronized int removeById(long id)

    {

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

        InternalMaster.newSlave(this);

        mNumEffectsToBe--;

        }

    return 0;

    }

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

  public synchronized int removeEffect(Effect effect)

    {

      if( mEffects[i]==effect )

        {

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

        InternalMaster.newSlave(this);

        mNumEffectsToBe--;

        }

    return 0;

    }

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

  public synchronized int removeAll(boolean notify)

    {

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

    InternalMaster.newSlave(this);

    mNumEffectsToBe = 0;

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

  public boolean add(Effect effect)

    {

    if( InternalStackFrameList.getMax(mIndex)>mNumEffectsToBe || !mCreated )

      {

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

      InternalMaster.newSlave(this);

    if( InternalStackFrameList.getMax(mIndex)>mNumEffectsToBe || !mCreated )

      {

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

      InternalMaster.newSlave(this);

      mNumEffectsToBe++;

      }

    return false;

    }

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

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

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

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

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

        mUBI.addAssociations(j,mEffects[j]);

        }

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

    mUBI.markForDeletion();

    }

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

  public void doWork()

    {

    boolean changed = false;

    int num = mJobs.size();

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

      {

      job = mJobs.remove(0);

      switch(job.type)

        case CREATE: int max = InternalStackFrameList.getMax(mIndex);

                     if( max>0 )

                       mEffects= new Effect[max];

                       mUBF    = new UniformBlockFloatUniforms(job.num1, max, job.bool);

                       }

                     mCreated = true;

                     break;

        case ATTACH: if( InternalStackFrameList.getMax(mIndex)>mNumEffects ) // it is possible that we have first

                       int position = job.num1;

                       if( position<0 )

                         {

                         addNow(mNumEffects,job.effect);

                         mNumEffects++;

                         }

                       else if( position<=mNumEffects )

                         {

                         System.arraycopy(mEffects, position, mEffects, position+1, mNumEffects-position);

                         mUBI.makeHole(position, mNumEffects);

                         addNow(position,job.effect);

                         mNumEffects++;

                       }

                     break;

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

                       {

                         removeNow(j);

                         changed = true;

                         break;

                     break;

                       changed = true;

                       mEffects[j] = null;

                     // TODO: notify listeners?

                     mNumEffects= 0;

      }

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

    }