Distorted Android

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

// Copyright 2017 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.effect;

import org.distorted.library.message.EffectListener;

import java.lang.reflect.Method;

import java.util.ArrayList;

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

/**

 * Abstract Effect of any type.

 */

public abstract class Effect

  {

  private final static int MAX_UNITY_DIM = 4;

  private final static int NUM_EFFECTS = EffectName.LENGTH;

  private final long mID;

  private final EffectType mType;

  private final EffectName mName;

  private final int mDimension;

  private final int mRegionDim;

  private final int mCenterDim;

  private ArrayList<EffectListener> mListeners =null;

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

  private static long mNextID = 0;

  private final static float[] mUnity= new float[MAX_UNITY_DIM*NUM_EFFECTS];

  private final static int[]   mUnityDim = new int[NUM_EFFECTS];

  int mAssociation;

  static boolean[] mEnabled = new boolean[NUM_EFFECTS];

  static

    {

    for(int i=0; i<NUM_EFFECTS; i++) mEnabled[i] = false;

    }

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

  Effect(EffectName name)

    {

    mName      = name;

    mType      = name.getType();

    mDimension = name.getEffectDimension();

    mCenterDim = name.getCenterDimension();

    mRegionDim = name.getRegionDimension();

    mAssociation = 0xffffffff;

    int n = name.ordinal();

    float[] u = name.getUnity();

    int l = u.length;

    System.arraycopy(u, 0, mUnity, MAX_UNITY_DIM*n, l);

    mUnityDim[n] = l;

    mID = ((mNextID++)<<EffectType.LENGTH) + mType.ordinal();

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public static void onDestroy()

    {

    mNextID = 0;

    for(int i=0; i<NUM_EFFECTS; i++) mEnabled[i] = false;

    MatrixEffect.destroyStatics();

    VertexEffect.destroyStatics();

    FragmentEffect.destroyStatics();

    PostprocessEffect.destroyStatics();

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public abstract boolean compute(float[] uniforms, int index, long currentDuration, long step );

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public int getNumListeners()

    {

    return mNumListeners;

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public EffectListener removeFirstListener()

    {

    if( mNumListeners>0 )

      {

      mNumListeners--;

      return mListeners.remove(0);

      }

    return null;

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public int getAssociation()

    {

    return mAssociation;

    }

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

// PUBLIC API

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

/**

 * Do the set of Uniforms written in buffer[index], buffer[index+1], etc represent a Unity, i.e a

 * null Effect?

 */

  public boolean isUnity(float[] buffer, int index)

    {

    int name = mName.ordinal();

    switch(mUnityDim[name])

      {

      case 0: return true;

      case 1: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ];

      case 2: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&

                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1];

      case 3: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&

                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&

                     buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2];

      case 4: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&

                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&

                     buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2] &&

                     buffer[index+3]==mUnity[MAX_UNITY_DIM*name+3];

      }

    return false;

    }

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

// this will enable() all Fragment Effects twice (once for smooth variant, once for non-smooth)

// but this shouldn't matter.

/**

 * Enable all effects of a given type.

 *

 * @param type EffectType to enable.

 */

  public static void enableEffects(EffectType type)

    {

    Method method;

    for(EffectName name: EffectName.values())

      {

      if( name.getType() == type )

        {

        Class<? extends Effect> cls = name.getEffectClass();

        try

          {

          method = cls.getMethod("enable");  // getMethod and NOT getDeclaredMethod because enable()

                                             // is public

          }

        catch(NoSuchMethodException ex)

          {

          android.util.Log.e("Effect", "exception getting method: "+ex.getMessage());

          method = null;

          }

        try

          {

          if( method!=null ) method.invoke(null);

          }

        catch(Exception ex)

          {

          android.util.Log.e("Effect", "exception invoking method: "+ex.getMessage());

          }

        }

      }

    }

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

/**

 * Return the EffectType enum corresponding to this Effect.

 *

 * @see EffectType

 */

  public EffectType getType()

    {

    return mType;

    }

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

/**

 * Return the EffectName enum corresponding to this Effect.

 *

 * @see EffectName

 */

  public EffectName getName()

    {

    return mName;

    }

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

/**

 * Return the unique ID of this Effect.

 */

  public long getID()

    {

    return mID;

    }

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

/**

 * Return a printable name of this Effect.

 */

  public String getString()

    {

    return mName.name();

    }

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

/**

 * Return the dimension of the Center supported by this effect (0- no center supported at all).

 */

  public int getCenterDimension()

    {

    return mCenterDim;

    }

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

/**

 * Return the dimension of the Region supported by this effect (0- no region supported at all).

 */

  public int getRegionDimension()

    {

    return mRegionDim;

    }

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

/**

 * Return the number of Uniforms needed to describe this effect.

 */

  public int getEffectDimension()

    {

    return mDimension;

    }

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

/**

 * Adds the calling class to the list of Listeners that get notified when this Effect gets 'finished'

 * i.e. when the Dynamic inside this Effect reaches its final point and stops moving. This will be sent

 * only once, on the first time the Dynamic reaches its final point.

 *

 * If there's no Dynamic, ths message will never be sent.

 *

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

 */

  public void notifyWhenFinished(EffectListener el)

    {

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

    if( !mListeners.contains(el) )

      {

      mListeners.add(el);

      mNumListeners++;

      }

    }

  }