Distorted Android

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

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

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

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

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

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

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

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

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

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

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

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

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

  DISAPPEAR        ( EffectType.VERTEX  ,   new float[] {}               , 0, 0,     0    , VertexEffectDisappear.class    ),

  PIPE             ( EffectType.VERTEX  ,   new float[] {1,0f}           , 5, 0,     3    , VertexEffectPipe.class         ),

  VERTEX_MOVE      ( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 3, 0,     0    , VertexEffectMove.class         ),

  VERTEX_QUATERNION( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 4, 0,     3    , VertexEffectQuaternion.class   ),

  VERTEX_ROTATE    ( EffectType.VERTEX  ,   new float[] {0.0f}           , 4, 0,     3    , VertexEffectRotate.class       ),

  VERTEX_SCALE     ( EffectType.VERTEX  ,   new float[] {1.0f,1.0f,1.0f} , 3, 0,     0    , VertexEffectScale.class        ),

  VERTEX_SHEAR     ( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 3, 0,     3    , VertexEffectShear.class        ),

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

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

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

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

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

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

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

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

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

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

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

  GLOW             ( EffectType.POSTPROCESS,new float[] {0.0f}           , 6, 0,     0    , PostprocessEffectGlow.class    ),

  BORDER           ( EffectType.POSTPROCESS,new float[] {0.0f}           , 5, 0,     0    , PostprocessEffectBorder.class  ),

  ;

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

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

  private final EffectType type;

  private final float[] unity;

  private final int dimension;

  private final int regionDim;

  private final int centerDim;

  private final Class<? extends Effect> effectClass;

  private static final int[] dimensions;

  private static final int[] regionDimension;

  private static final int[] centerDimension;

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

    regionDimension = new int[LENGTH];

    centerDimension = new int[LENGTH];

    names           = new EffectName[LENGTH];

    for(EffectName name: EffectName.values())

      {

      dimensions[i]      = name.dimension;

      regionDimension[i] = name.regionDim;

      centerDimension[i] = name.centerDim;

      names[i]           = name;

      i++;

      }

    }

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

  float[] getUnity()

    {

    return unity;

    }

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

  EffectName(EffectType type, float[] unity, int dimension, int regionDim,

             int centerDim, Class<? extends Effect> effectClass )

    {

    this.type        = type;

    this.unity       = unity;

    this.dimension   = dimension;

    this.regionDim   = regionDim;

    this.centerDim   = centerDim;

    this.effectClass = effectClass;

    }

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

// PUBLIC API

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

/**

 * Returns the Type of an individual Effect. For example, EffectName.ROTATE.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.ROTATE.getEffectClass()

 * returns MatrixEffectRotate.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 getEffectDimension() { return dimensions[ordinal()]; }

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

/**

 * What is the dimension of the Region supported by this effect?

 * @return Dimension of the Region supported (0-region not supported at all).

 */

  public int getRegionDimension() { return regionDimension[ordinal()]; }

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

/**

 * What is the dimension of the Center supported by this effect?

 * @return Dimension of the Center supported (0-center not supported at all).

 */

  public int getCenterDimension() { return centerDimension[ordinal()]; }

  }