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;

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

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 boolean mSupportsR;

  private final boolean mSupportsC;

  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];

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

  static

    {

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

    }

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

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

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

  public static void onDestroy()

    {

    mNextID = 0;

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

    }

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

  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;

    }

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

  public EffectType getType()

    {

    return mType;

    }

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

  public EffectName getName()

    {

    return mName;

    }

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

  public long getID()

    {

    return mID;

    }

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

  public String getString()

    {

    return mName.name();

    }

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

  public boolean supportsCenter()

    {

    return mSupportsC;

    }

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

  public boolean supportsRegion()

    {

    return mSupportsR;

    }

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

  public int getDimension()

    {

    return mDimension;

    }

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

  Effect(EffectName name)

    {

    mName      = name;

    mType      = name.getType();

    mDimension = name.getDimension();

    mSupportsC = name.supportsCenter();

    mSupportsR = name.supportsRegion();

    int n = name.ordinal();

    float[] u = name.getUnity();

    int l = name.getUnity().length;

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

      {

      mUnity[n*MAX_UNITY_DIM+i] = u[i];

      }

    mUnityDim[n] = l;

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

    }

  }