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.effect;

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

/**

 * Names of Effects one can add to the DistortedEffects queues.

 * <p>

 * Effect's 'Type' is one of the constants defined in {@link EffectType}.

 * </p>

 * <p>

 * Effect's 'Uniforms' are a vector of 7 (matrix effects) 12 (vertex) or 8 (fragment) floats, which

 * together form full information how to compute a given effect.

 * Typically, some of those values will be Interpolated in CPU (by one of the 'EffectQueueX.compute()'

 * methods) and the effect of such Interpolation sent to the Shaders.

 * </p>

 * <p>

 * Effect's 'Unity' is such a particular vector of its 'interpolated values' which makes the

 * effect NULL. For example, if the effect is 'MOVE' by a 3-dimensional vector, then a 'NULL

 * MOVE' is a MOVE by vector (0,0,0), thus (0,0,0) is the unity of the MOVE effect.

 * This is used by the EffectQueue classes to decide if the final form of the Effect is NULL - and

 * thus if it can safely be removed from Effect Queues without affecting the visual in any way.

 * </p>

 */

public enum EffectName

  {

  // EFFECT NAME /////// EFFECT TYPE ////////// EFFECT UNITY //////////// DIM REGION CENTER

  ROTATE           ( EffectType.MATRIX  ,   new float[] {0.0f}           , 4, false, true  , MatrixEffectRotate.class       ),

  QUATERNION       ( EffectType.MATRIX  ,   new float[] {0.0f,0.0f,0.0f} , 4, false, true  , MatrixEffectQuaternion.class   ),

  MOVE             ( EffectType.MATRIX  ,   new float[] {0.0f,0.0f,0.0f} , 3, false, false , MatrixEffectMove.class         ),

  SCALE            ( EffectType.MATRIX  ,   new float[] {1.0f,1.0f,1.0f} , 3, false, false , MatrixEffectScale.class        ),

  SHEAR            ( EffectType.MATRIX  ,   new float[] {0.0f,0.0f,0.0f} , 3, false, true  , MatrixEffectShear.class        ),

  DISTORT          ( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 3, true , true  , VertexEffectDistort.class      ),

  DEFORM           ( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 3, true , true  , VertexEffectDeform.class       ),

  SINK             ( EffectType.VERTEX  ,   new float[] {1.0f}           , 1, true , true  , VertexEffectSink.class         ),

  PINCH            ( EffectType.VERTEX  ,   new float[] {1.0f}           , 2, true , true  , VertexEffectPinch.class        ),

  SWIRL            ( EffectType.VERTEX  ,   new float[] {0.0f}           , 1, true , true  , VertexEffectSwirl.class        ),

  WAVE             ( EffectType.VERTEX  ,   new float[] {0.0f}           , 5, true , true  , VertexEffectWave.class         ),

  ALPHA            ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false , FragmentEffectAlpha.class      ),

  SMOOTH_ALPHA     ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false , FragmentEffectAlpha.class      ),

  CHROMA           ( EffectType.FRAGMENT,   new float[] {0.0f}           , 4, true , false , FragmentEffectChroma.class     ),

  SMOOTH_CHROMA    ( EffectType.FRAGMENT,   new float[] {0.0f}           , 4, true , false , FragmentEffectChroma.class     ),

  BRIGHTNESS       ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false , FragmentEffectBrightness.class ),

  SMOOTH_BRIGHTNESS( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false , FragmentEffectBrightness.class ),

  SATURATION       ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false , FragmentEffectSaturation.class ),

  SMOOTH_SATURATION( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false , FragmentEffectSaturation.class ),

  CONTRAST         ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false , FragmentEffectContrast.class   ),

  SMOOTH_CONTRAST  ( EffectType.FRAGMENT,   new float[] {1.0f}           , 1, true , false , FragmentEffectContrast.class   ),

  BLUR             ( EffectType.POSTPROCESS,new float[] {0.0f}           , 1, false, false , PostprocessEffectBlur.class    ),

  GLOW             ( EffectType.POSTPROCESS,new float[] {0.0f}           , 5, false, false , PostprocessEffectGlow.class    );

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

  public static final int LENGTH = values().length;

  private final EffectType type;

  private final float[] unity;

  private final int dimension;

  private final boolean supportsR;

  private final boolean supportsC;

  private final Class<? extends Effect> effectClass;

  private static final int[] dimensions;

  private static final boolean[] supportsRegion;

  private static final boolean[] supportsCenter;

  private static final EffectName[] names;  // copy the values() to a local variable so that we

                                            // don't have to keep recreating the array every time

  static

    {

    int i=0;

    dimensions      = new int[LENGTH];

    supportsRegion  = new boolean[LENGTH];

    supportsCenter  = new boolean[LENGTH];

    names           = new EffectName[LENGTH];

    for(EffectName name: EffectName.values())

      {

      dimensions[i]      = name.dimension;

      supportsRegion[i]  = name.supportsR;

      supportsCenter[i]  = name.supportsC;

      names[i]           = name;

      i++;

      }

    }

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

  float[] getUnity()

    {

    return unity;

    }

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

  EffectName(EffectType type, float[] unity, int dimension, boolean supportsR,

             boolean supportsC, Class<? extends Effect> effectClass )

    {

    this.type        = type;

    this.unity       = unity;

    this.dimension   = dimension;

    this.supportsR   = supportsR;

    this.supportsC   = supportsC;

    this.effectClass = effectClass;

    }

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

// PUBLIC API

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

/**

 * Returns the Type of an individual Effect. For example, EffectName.ROTATION.getType() will

 * return EffectType.MATRIX.

 * @return type of the effect.

 */

  public EffectType getType()

    {

    return type;

    }

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

  /**

   * Returns the Class of an individual Effect. For example, EffectName.ROTATION.getType() will

   * return MatrixEffectRotation.class.

   * @return effect class.

   */

  public Class<? extends Effect> getEffectClass()

    {

    return effectClass;

    }

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

/**

 * Returns the i-th EffectName.

 * <p>

 * If you want to loop over all possible Effects, you need this.

 */

  public static EffectName getName(int ordinal)

    {

    return names[ordinal];

    }

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

/**

 * Returns the dimension of an Effect (in other words, the number of interpolated values).

 * @return dimension of the Effect.

 */

  public int getDimension() { return dimensions[ordinal()]; }

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

/**

 * Do we support being masked by a Region?

 * @return true if the Effect supports being masked with a Region.

 */

  public boolean supportsRegion() { return supportsRegion[ordinal()]; }

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

/**

 * Does this Effect have a center?

 * @return true if the Effect has a center.

 */

  public boolean supportsCenter() { return supportsCenter[ordinal()]; }

  }