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/>.                            //

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

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

 * Names of Effects one can apply to DistortedObjects.

 * </p>

 * <p>

 * 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 EffectNames

  // EFFECT NAME /////// EFFECT TYPE ////////////// UNITY /////////////////////////

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

  // MATRIX EFFECTS.

  // Always 7 Uniforms: 4 per-effect interpolated values + 3 dimensional center.

 /**

   * Rotate the whole Object around a center point (in angle-axis notation).

   * <p>

   */

   * Rotate the whole Object around a center point (in quaternion notation).

   * <p>

   */

  QUATERNION       ( EffectTypes.MATRIX  ,   new float[] {0.0f,0.0f,0.0f} ),

 /**

   * Move the whole Object by a vector.

   * <p>

   */

   * Scale the whole Object independently in all 3 dimensions.

   * <p>

   */

   * Shear the whole Object in 3 dimensions around a center point.

   * <p>

   */

  // add new Matrix effects here...

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

 // VERTEX EFFECTS

 // the effect, 4-dimensional Region

   * Apply a 3D vector of force to area around a point on the surface of the Object.

   * <p>

   *            regionX,regionY,regionRX,regionRY)

   * <p>

   */

   * Deform the whole Object by applying a 2D vector of force to a center point.

   * <p>

   *            UNUSED,UNUSED,centerX,centerY,

   *            UNUSED,UNUSED,UNUSED,UNUSED)

   */

   * Pull (or push away) all points around a center point to (from) it.

   * <p>

   *            UNUSED,UNUSED,centerX,centerY,

   *            regionX,regionY,regionRX,regionRY)

   */

   * Smoothly rotate a limited area around a center point.

   * <p>

   */

   * Directional sinusoidal wave effect. The direction of the wave is given by the 'angle'

   *            angleBeta, UNUSED,centerX,centerY,

   */

  WAVE             ( EffectTypes.VERTEX  ,   new float[] {0.0f}           ),

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

 // FRAGMENT EFFECTS

 // Always 8 Uniforms: 4-per effect interpolated values, 4 dimensional Region.

 /**

   * Make a given Region (partially) transparent.

   * <p>

   */

   * Make a given Region (partially) transparent.

   * Effect smoothly fades towards the edges of the region.

   * <p>

   */

   * Blend current color in the texture with a given color.

   * <p>

   */

   * Smoothly blend current color in the texture with a given color.

   * <p>

   */

   * Change brightness level of a given Region.

   * <p>

   */

   * Smoothly change brightness level of a given Region.

   * <p>

   */

   * Change saturation level of a given Region.

   * <p>

   */

   * Smoothly change saturation level of a given Region.

   * <p>

   */

   * Change contrast level of a given Region.

   * <p>

   */

   * Smoothly change contrast level of a given Region.

   * <p>

   */

  SMOOTH_CONTRAST  ( EffectTypes.FRAGMENT,   new float[] {1.0f}           );

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

  private static final int MAXDIM = 4;  // maximum supported dimension of an effect  

  private final float[] unity;

  private static final int[] dimensions;

  private static final EffectNames[] names;

    {

    int len = values().length;

    int i=0;

    dimensions = new int[len];

    unities    = new float[MAXDIM*len];

      {

        {

        case 4: unities[MAXDIM*i+3] = name.unity[3];

        case 3: unities[MAXDIM*i+2] = name.unity[2];

        case 2: unities[MAXDIM*i+1] = name.unity[1];

        }

      i++;  

      }

    }

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

    this.type = type;  

    this.unity= unity;

    }

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

    }

  static EffectNames getName(int ordinal)

    {

    return names[ordinal];

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

  static void fillWithUnities(int ordinal, float[] buffer, int index)

    {

    switch(dimensions[ordinal])

      {

      case 0: break;

              break;

              buffer[index+2]=unities[MAXDIM*ordinal+2];

              break;

              buffer[index+2]=unities[MAXDIM*ordinal+2];

              buffer[index+3]=unities[MAXDIM*ordinal+3];

              break;

      }  

    }

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

  static boolean isUnity(int ordinal, float[] buffer, int index)

    {

    switch(dimensions[ordinal])

      {

      case 0: return true;

      case 2: return buffer[index  ]==unities[MAXDIM*ordinal  ] &&

                     buffer[index+2]==unities[MAXDIM*ordinal+2];

                     buffer[index+2]==unities[MAXDIM*ordinal+2] &&

                     buffer[index+3]==unities[MAXDIM*ordinal+3];

      }

    return false;

    }

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

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

/**

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

 * return EffectTypes.MATRIX.

 * @return type of the effect.

 */

  public EffectTypes getType()

    {

    return type;

    }

/**

 * 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()]; }