Distorted Android

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

// Copyright 2016 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

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

// Lesser General Public License for more details.                                               //

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

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

import org.distorted.library.uniformblock.UniformBlockFloatUniforms;

import org.distorted.library.uniformblock.UniformBlockIntUniforms;

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)

  static final int VERT_INT_UBO_BINDING = 5;

  static final int VERT_FLO_UBO_BINDING = 6;

  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)

  Effect[] mEffects;

  UniformBlockFloatUniforms mUBF;

  UniformBlockIntUniforms mUBI;

  private long mID;

  private final int mIndex;

  private boolean mCreated;

  private static class Job

    {

    int type;

    int num1, num2;

    boolean bool;

    Effect effect;

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

      {

      type  = t;

      num1  = m1;

      num2  = m2;

      bool  = n;

      effect= e;

      }

    }

  private final ArrayList<Job> mJobs;

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

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

    {

    mCreated        = false;

    mID             = 0;

    mNumEffects     = 0;

    mNumEffectsToBe = 0;

    mIndex          = index;

    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.

  EffectQueue(EffectQueue source)

    {

    if( !source.mCreated )

      {

      mCreated        = false;

      mID             = 0;

      mNumEffects     = 0;

      mNumEffectsToBe = 0;

      mIndex          = source.mIndex;

      mJobs = new ArrayList<>();

      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;

      mID             = source.mID;

      mNumEffects     = source.mNumEffects;

      mNumEffectsToBe = source.mNumEffectsToBe;

      mIndex          = source.mIndex;

      mJobs = new ArrayList<>();

      int max = InternalStackFrameList.getMax(mIndex);

      if( max>0 )

        {

        mEffects= new Effect[max];

        mUBI  = new UniformBlockIntUniforms(source.mUBI);

        mUBF  = new UniformBlockFloatUniforms(source.mUBF);

        if( mNumEffects>=0 )

          {

          System.arraycopy(source.mEffects, 0, mEffects, 0, mNumEffects);

          }

        }

      }

    }

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

  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, long step)

    {

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

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

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

    ((EffectQueuePostprocess)queues[3]).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);

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

    }

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

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

      {

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

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

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

      Long id = map.get(list);

      if( id!=null )

        {

        mID = id;

        }

      else

        {

        mID = InternalStackFrameList.getNextQueueID();

        map.put(list,mID);

        }

      }

    else

      {

      mID = 0;

      }

    }

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

  public long getID()

    {

    return mID;

    }

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

  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;

      }

    }

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

  private void addNow(int pos, Effect effect)

    {

    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++)

      {

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

        {

        mJobs.add(new Job(DETACH,0,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,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,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,0,notify,null));

    InternalMaster.newSlave(this);

    mNumEffectsToBe = 0;

    return mNumEffects;

    }

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

  public boolean add(Effect effect)

    {

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

      {

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

      InternalMaster.newSlave(this);

      mNumEffectsToBe++;

      return true;

      }

    return false;

    }

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

  public boolean add(Effect effect, int position)

    {

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

      {

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

      InternalMaster.newSlave(this);

      mNumEffectsToBe++;

      return true;

      }

    return false;

    }

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

  public boolean exists(long id)

    {

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

      {

      if( mEffects[i].getID() == id ) 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

      {

      DistortedLibrary.logMessage("EffectQueue: getEffect: out of range "+position);

      return null;

      }

    }

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

  public void setAssociation(long effectID)

    {

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

      {

      if (mEffects[j].getID() == effectID)

        {

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

        }

      }

    }

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

  public void markForDeletion()

    {

    mUBI.markForDeletion();

    mUBF.markForDeletion();

    }

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

  public String retEffects()

    {

    String dbg="";

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

      {

      dbg += (i+": "+mEffects[i].getString()+" ");

      }

    return dbg;

    }

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

  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 = InternalStackFrameList.getMax(mIndex);

                     if( max>0 )

                       {

                       mEffects= new Effect[max];

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

                       mUBI    = new UniformBlockIntUniforms  (job.num2, max, job.bool);

                       }

                     mCreated = true;

                     break;

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

                       {                                                     // added effects and then lowered mMax

                       int position = job.num1;

                       if( position<0 )

                         {

                         addNow(mNumEffects,job.effect);

                         mNumEffects++;

                         changed = true;

                         }

                       else if( position<=mNumEffects )

                         {

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

                         mUBI.makeHole(position, mNumEffects);

                         addNow(position,job.effect);

                         mNumEffects++;

                         changed = true;

                         }

                       }

                     else

                       {

                       DistortedLibrary.logMessage("EffectQueue: failed to add effect "+job.effect.getName());

                       }

                     break;

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

                       {

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

                         {

                         removeNow(j);

                         changed = true;

                         break;

                         }

                       }

                     break;

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

                       {

                       changed = true;

                       mEffects[j] = null;

                       }

                     // TODO: notify listeners?

                     /* if( job.bool )

                          {

                          // ...

                          }

                      */

                     mNumEffects= 0;

                     break;

        }

      }

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

    }

  }

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

// Copyright 2016 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

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

// Lesser General Public License for more details.                                               //

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

package org.distorted.library.effectqueue;

import android.opengl.GLES30;

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.FragmentEffect;

import org.distorted.library.message.EffectMessageSender;

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

class EffectQueueFragment extends EffectQueue

  {

  private static final int NUM_FLOAT_UNIFORMS = FragmentEffect.NUM_FLOAT_UNIFORMS;

  private static final int NUM_INT_UNIFORMS   = FragmentEffect.NUM_INT_UNIFORMS;

  private static final boolean USE_UBO        = false;

  private static final int INDEX = EffectType.FRAGMENT.ordinal();

  private final static int[] mNumEffectsH  = new int[MAIN_VARIANTS];

  private final static int[] mIntUniformsH = new int[MAIN_VARIANTS];

  private final static int[] mFloUniformsH = new int[MAIN_VARIANTS];

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

  EffectQueueFragment()

    { 

    super(NUM_FLOAT_UNIFORMS, NUM_INT_UNIFORMS, USE_UBO, INDEX);

    }

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

  EffectQueueFragment(EffectQueueFragment source)

    {

    super(source);

    }

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

  static void uniforms(int mProgramH, int variant)

    {

    mNumEffectsH[variant]   = GLES30.glGetUniformLocation  ( mProgramH, "fNumEffects");

    mIntUniformsH[variant]  = GLES30.glGetUniformLocation  ( mProgramH, "fProperties");

    mFloUniformsH[variant]  = GLES30.glGetUniformLocation  ( mProgramH, "fUniforms");

    }

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

  void compute(long currTime, long step)

    {

    if( mNumEffects>0 )

      {

      float[] array = mUBF.getBackingArray();

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

        {

        if( mEffects[i].compute(array, NUM_FLOAT_UNIFORMS*i, currTime, step) )

          {

          EffectMessageSender.newMessage(mEffects[i]);

          }

        }

      }

    }

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

  void send(int variant)

    {

    GLES30.glUniform1i( mNumEffectsH[variant], mNumEffects);

    if( mNumEffects>0 )

      {

      int[]   arrayI = mUBI.getBackingArray();

      float[] arrayF = mUBF.getBackingArray();

      GLES30.glUniform4iv( mIntUniformsH[variant],                       mNumEffects, arrayI, 0);

      GLES30.glUniform4fv( mFloUniformsH[variant],(NUM_FLOAT_UNIFORMS/4)*mNumEffects, arrayF, 0);

      }  

    }

  }

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

// Copyright 2016 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

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

// Lesser General Public License for more details.                                               //

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

package org.distorted.library.effectqueue;

import android.opengl.GLES30;

import org.distorted.library.helpers.MatrixHelper;

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.MatrixEffect;

import org.distorted.library.message.EffectMessageSender;

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

class EffectQueueMatrix extends EffectQueue

  {

  private static final int NUM_FLOAT_UNIFORMS = MatrixEffect.NUM_FLOAT_UNIFORMS;

  private static final int NUM_INT_UNIFORMS   = MatrixEffect.NUM_INT_UNIFORMS;

  private static final boolean USE_UBO        = false;

  private static final int INDEX = EffectType.MATRIX.ordinal();

  private static final float[] mMVPMatrix       = new float[16];

  private static final float[] mModelViewMatrixP= new float[16];

  private static final float[] mModelViewMatrixV= new float[16];

  private static final int[] mMVPMatrixH = new int[MAIN_VARIANTS];

  private static final int[] mMVMatrixPH = new int[MAIN_VARIANTS];

  private static final int[] mMVMatrixVH = new int[MAIN_VARIANTS];

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

  EffectQueueMatrix()

    { 

    super(NUM_FLOAT_UNIFORMS, NUM_INT_UNIFORMS, USE_UBO, INDEX);

    }

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

  EffectQueueMatrix(EffectQueueMatrix source)

    {

    super(source);

    }

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

  static void uniforms(int mProgramH, int variant)

    {

    mMVPMatrixH[variant]= GLES30.glGetUniformLocation(mProgramH, "u_MVPMatrix");

    mMVMatrixPH[variant]= GLES30.glGetUniformLocation(mProgramH, "u_MVMatrixP");

    mMVMatrixVH[variant]= GLES30.glGetUniformLocation(mProgramH, "u_MVMatrixV");

    }

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

  void compute(long currTime, long step)

    {

    if( mNumEffects>0 )

      {

      float[] array = mUBF.getBackingArray();

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

        {

        if( mEffects[i].compute(array, NUM_FLOAT_UNIFORMS*i, currTime, step) )

          {

          EffectMessageSender.newMessage(mEffects[i]);

          }

        }

      }

    }  

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

  void send(float distance, float mipmap, float[] projection, int variant)

    {

    // i.e. setIdentity(); translate(0,0,-distance); scale(mipmap,mipmap,mipmap)

    mModelViewMatrixV[ 0] = mModelViewMatrixP[ 0] = mipmap;

    mModelViewMatrixV[ 1] = mModelViewMatrixP[ 1] = 0;

    mModelViewMatrixV[ 2] = mModelViewMatrixP[ 2] = 0;

    mModelViewMatrixV[ 3] = mModelViewMatrixP[ 3] = 0;

    mModelViewMatrixV[ 4] = mModelViewMatrixP[ 4] = 0;

    mModelViewMatrixV[ 5] = mModelViewMatrixP[ 5] = mipmap;

    mModelViewMatrixV[ 6] = mModelViewMatrixP[ 6] = 0;

    mModelViewMatrixV[ 7] = mModelViewMatrixP[ 7] = 0;

    mModelViewMatrixV[ 8] = mModelViewMatrixP[ 8] = 0;

    mModelViewMatrixV[ 9] = mModelViewMatrixP[ 9] = 0;

    mModelViewMatrixV[10] = mModelViewMatrixP[10] = mipmap;

    mModelViewMatrixV[11] = mModelViewMatrixP[11] = 0;

    mModelViewMatrixV[12] = mModelViewMatrixP[12] = 0;

    mModelViewMatrixV[13] = mModelViewMatrixP[13] = 0;

    mModelViewMatrixV[14] = mModelViewMatrixP[14] = -distance;

    mModelViewMatrixV[15] = mModelViewMatrixP[15] = 1;

    float[] array = mUBF.getBackingArray();

    // the 'Model' part of the MV matrix

    for(int i=mNumEffects-1; i>=0; i--)

      {

      ((MatrixEffect)mEffects[i]).apply(mModelViewMatrixP,mModelViewMatrixV,array,i);

      }

    // combined Model-View-Projection matrix

    MatrixHelper.multiply(mMVPMatrix, projection, mModelViewMatrixP);

    GLES30.glUniformMatrix4fv(mMVMatrixVH[variant], 1, false, mModelViewMatrixV, 0);

    GLES30.glUniformMatrix4fv(mMVMatrixPH[variant], 1, false, mModelViewMatrixP, 0);

    GLES30.glUniformMatrix4fv(mMVPMatrixH[variant], 1, false, mMVPMatrix       , 0);

    }

  }