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.type.Data1D;

import org.distorted.library.type.Data4D;

import java.util.ArrayList;

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

/**

 * Class containing the queue of postprocessing effects.

 * <p>

 * This better be separate from the main DistortedEffects class, because we want to be able to apply

 * the same postprocessing effects (i.e. not only the same effects, but the very same instance of this

 * object) to several Children of a Node. Reason for that: if several children have the same Object,

 * it is easy to group them into 'Buckets' where each bucket has the same postprocessing effects and

 * is therefore rendered to the same buffer, which is then postprocessed in one go.

 * <p>

 * The queue holds actual effects to be applied to a given bucket of several (DistortedTexture,MeshObject) combos.

 */

public class DistortedEffectsPostprocess implements DistortedSlave

  {

  private static final int MIPMAP = 0;

  private static long mNextID =0;

  private long mID;

  private EffectQueuePostprocess mP;

  private boolean postprocessCloned;

  private class Job

    {

    int type;

    int level;

    Job(int t, int l)

      {

      type = t;

      level= l;

      }

    }

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

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

  private void initializeEffectLists(DistortedEffectsPostprocess d, int flags)

    {

    if( (flags & Distorted.CLONE_POSTPROCESS) != 0 )

      {

      mP = d.mP;

      postprocessCloned = true;

      }

    else

      {

      mP = new EffectQueuePostprocess(mID);

      postprocessCloned = false;

      }

    }

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

  int postprocess(long time, DistortedOutputSurface surface)

    {

    return mP.postprocess(time,surface);

    }

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

  long getBucket()

    {

    return mP.mNumEffects==0 ? 0: mID;

    }

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

  private void releasePriv()

    {

    if( !postprocessCloned) mP.abortAll(false);

    mP = null;

    }

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

  int getQuality()

    {

    return mP.mQualityLevel;

    }

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

  int getHalo()

    {

    return mP.getHalo();

    }

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

  static void onDestroy()

    {

    mNextID = 0;

    }

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

// PUBLIC API

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

/**

 * Create empty effect queue.

 */

  public DistortedEffectsPostprocess()

    {

    mID = ++mNextID;

    initializeEffectLists(this,0);

    }

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

/**

 * Copy constructor.

 * <p>

 * Whatever we do not clone gets created just like in the default constructor.

 *

 * @param dc    Source object to create our object from

 * @param flags A bitmask of values specifying what to copy.

 *              Currently the only values possible are CLONE_NOTHING or CLONE_POSTPROCESS.

 */

  public DistortedEffectsPostprocess(DistortedEffectsPostprocess dc, int flags)

    {

    mID = ++mNextID;

    initializeEffectLists(dc,flags);

    }

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

/**

 * 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()

    {

    int num = mJobs.size();

    Job job;

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

      {

      job = mJobs.remove(0);

      switch(job.type)

        {

        case MIPMAP: int level = job.level;

                     mP.mQualityLevel = level;

                     mP.mQualityScale = 1.0f;

                     for(int j=0; j<level; j++) mP.mQualityScale*=EffectQuality.MULTIPLIER;

                     break;

        }

      }

    }

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

/**

 * Releases all resources. After this call, the queue should not be used anymore.

 */

  @SuppressWarnings("unused")

  public synchronized void delete()

    {

    releasePriv();

    }

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

/**

 * Returns unique ID of this instance.

 *

 * @return ID of the object.

 */

  @SuppressWarnings("unused")

  public long getID()

      {

      return mID;

      }

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

/**

 * Adds the calling class to the list of Listeners that get notified each time some event happens 

 * to one of the Effects in the queues. Nothing will happen if 'el' is already in the list.

 * 

 * @param el A class implementing the EffectListener interface that wants to get notifications.

 */

  @SuppressWarnings("unused")

  public void registerForMessages(EffectListener el)

    {

    mP.registerForMessages(el);

    }

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

/**

 * Removes the calling class from the list of Listeners.

 * 

 * @param el A class implementing the EffectListener interface that no longer wants to get notifications.

 */

  @SuppressWarnings("unused")

  public void deregisterForMessages(EffectListener el)

    {

    mP.deregisterForMessages(el);

    }

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

/**

 * Aborts all Effects.

 * @return Number of effects aborted.

 */

  @SuppressWarnings("unused")

  public int abortAllEffects()

      {

      return mP.abortAll(true);

      }

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

/**

 * Aborts all Effects of a given type (currently only POSTPROCESSING Effects).

 * 

 * @param type one of the constants defined in {@link org.distorted.library.effect.Effect}

 * @return Number of effects aborted.

 */

  @SuppressWarnings("unused")

  public int abortEffects(int type)

    {

    switch(type)

      {

      case Effect.POSTPROCESS: return mP.abortAll(true);

      default                : return 0;

      }

    }

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

/**

 * Aborts a single Effect.

 * 

 * @param id ID of the Effect we want to abort.

 * @return number of Effects aborted. Always either 0 or 1.

 */

  @SuppressWarnings("unused")

  public int abortEffect(long id)

    {

    int type = (int)(id&Effect.MASK);

    if( type==Effect.POSTPROCESS ) return mP.removeByID(id>>Effect.LENGTH);

    return 0;

    }

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

/**

 * Abort all Effects of a given name, for example all blurs.

 * 

 * @param name one of the constants defined in {@link org.distorted.library.effect.PostprocessEffect}

 * @return number of Effects aborted.

 */

  @SuppressWarnings("unused")

  public int abortEffects(int name)

    {

    switch(name.getType())

      {

      case POSTPROCESS: return mP.removeByType(name);

      default         : return 0;

      }

    }

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

/**

 * Print some info about a given Effect to Android's standard out. Used for debugging only.

 * 

 * @param id Effect ID we want to print info about

 * @return <code>true</code> if a single Effect of type effectType has been found.

 */

  @SuppressWarnings("unused")

  public boolean printEffect(long id)

    {

    int type = (int)(id&EffectTypes.MASK);

    if( type==EffectTypes.POSTPROCESS.type )  return mP.printByID(id>>EffectTypes.LENGTH);

    return false;

    }

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

/**

 * Returns the maximum number of Postprocess effects.

 *

 * @return The maximum number of Postprocess effects

 */

  @SuppressWarnings("unused")

  public static int getMaxPostprocess()

    {

    return EffectQueue.getMax(EffectTypes.POSTPROCESS.ordinal());

    }

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

/**

 * Sets the maximum number of Postprocess effects that can be stored in a single EffectQueue at one time.

 * This can fail if:

 * <ul>

 * <li>the value of 'max' is outside permitted range (0 &le; max &le; Byte.MAX_VALUE)

 * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called

 *     before the Fragment Shader gets compiled, i.e. before the call to {@link Distorted#onCreate}. After this

 *     time only decreasing the value of 'max' is permitted.

 * <li>Furthermore, this needs to be called before any instances of the DistortedEffects class get created.

 * </ul>

 *

 * @param max new maximum number of simultaneous Postprocess Effects. Has to be a non-negative number not greater

 *            than Byte.MAX_VALUE

 * @return <code>true</code> if operation was successful, <code>false</code> otherwise.

 */

  @SuppressWarnings("unused")

  public static boolean setMaxPostprocess(int max)

    {

    return EffectQueue.setMax(EffectTypes.POSTPROCESS.ordinal(),max);

    }

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

/**

 * The higher the quality, the better the effect will look like and the slower it will be.

 * <p>

 * This works by rendering into smaller and smaller intermediate buffers. Each step renders into a

 * buffer that's half the size of the previous one.

 * <p>

 * We cannot this during mid-render - thus, give it to the Master to assign us back this job on the

 * next render.

 */

  public void setQuality(EffectQuality quality)

    {

    mJobs.add(new Job(MIPMAP,quality.level));

    DistortedMaster.newSlave(this);

    }

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

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

// Individual effect functions.

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

// Postprocess-based effects

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

/**

 * Blur the object.

 *

 * @param radius The 'strength' if the effect, in pixels. 0 = no blur, 10 = when blurring a given pixel,

 *               take into account 10 pixels in each direction.

 * @return ID of the effect added, or -1 if we failed to add one.

 */

  public long blur(Data1D radius)

    {

    return mP.add(EffectNames.BLUR, radius);

    }

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

/**

 * Make the object glow with a specific color and a halo of specific radius.

 *

 * @param radius The 'strength' if the effect, in pixels. 0 = no halo, 10 = halo of roughly 10 pixels

 *               around the whole object.

 * @param color  RGBA of the color with which to draw the glow.

 * @return ID of the effect added, or -1 if we failed to add one.

 */

  public long glow(Data1D radius, Data4D color)

    {

    return mP.add(EffectNames.GLOW, radius, color);

    }

  }