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;

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

/**

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

 * <p>

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

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

  {

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

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

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

   * Uniforms: (angle,axisX,axisY,axisZ,centerX,centerY,centerZ)

   * <p>

   * Unity: angle==0

   */

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

 /**

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

   * <p>

   * Uniforms: (quatX,quatY,quatZ,quatW,centerX,centerY,centerZ)

   * <p>

   * Unity: (quatX,quatY,quatZ) = (0,0,0)

   */

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

 /**

   * Move the whole Object by a vector.

   * <p>

   * Uniforms: (vectorX,vectorY,vectorZ,UNUSED,UNUSED,UNUSED,UNUSED)

   * <p>

   * Unity: (vectorX,vectorY,vectorZ) = (0,0,0)

   */

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

 /**

   * Scale the whole Object independently in all 3 dimensions.

   * <p>

   * Uniforms: (scaleX,scaleY,scaleZ,UNUSED,UNUSED,UNUSED,UNUSED)

   * <p>

   * Unity: (scaleX,scaleY,scaleZ) = (1,1,1)

   */

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

 /**

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

   * <p>

   * Uniforms: (shearX,shearY,shearZ,UNUSED,centerX,centerY,centerZ)

   * <p>

   * Unity:  (shearX,shearY,shearZ) = (0,0,0)

   */

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

  // add new Matrix effects here...

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

 // VERTEX EFFECTS

 // Always 12 Uniforms: 6 per-effect interpolated values, 2-dimensional center of

 // the effect, 4-dimensional Region

 /**

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

   * <p>

   * Uniforms: (forceX,forceY,forceZ,UNUSED,

   *            UNUSED,centerX,centerY,centerZ,

   *            regionX,regionY,regionRX,regionRY)

   * <p>

   * Unity: (forceX,forceY,forceZ) = (0,0,0)

   */

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

 /**

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

   * <p>

   * Uniforms: (forceX,forceY,forceZ,UNUSED,

   *            UNUSED,centerX,centerY,centerZ,

   *            regionX,regionY,regionRX,regionRY)

   * <p>

   * Unity: (forceX,forceY,forceZ) = (0,0,0)

   */

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

 /**

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

   * <p>

   * Uniforms: (sinkFactor,UNUSED,UNUSED,UNUSED,

   *            UNUSED,centerX,centerY,centerZ,

   *            regionX,regionY,regionRX,regionRY)

   * <p>

   * Unity: sinkFactor = 1

   */

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

  /**

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

   * <p>

   * Uniforms: (pinchFactor,lineAngle,UNUSED,UNUSED,

   *            UNUSED,centerX,centerY,centerZ,

   *            regionX,regionY,regionRX,regionRY)

   * <p>

   * Unity: sinkFactor = 1

   */

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

 /**

   * Smoothly rotate a limited area around a center point.

   * <p>

   * Uniforms: (swirlAngle,UNUSED,UNUSED,UNUSED,

   *            UNUSED, centerX,centerY,centerZ,

   *            regionX,regionY,regionRX,regionRY)

   * <p>

   * Unity: swirlAngle = 0

   */

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

  /**

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

   * parameters. Details: {@link DistortedEffects#wave(org.distorted.library.type.Data5D,org.distorted.library.type.Data3D)}

   * <p>

   * Uniforms: (amplitude,length,phase,angleAlpha,

   *            angleBeta, centerX,centerY,centerZ,

   *            regionX,regionY,regionRX,regionRY)

   * <p>

   * Unity: amplitude  = 0

   */

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

  // add new Vertex Effects here...

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

 // FRAGMENT EFFECTS

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

 /**

   * Make a given Region (partially) transparent.

   * <p>

   * Uniforms: (transparencyLevel,UNUSED,UNUSED,UNUSED, regionX, regionY, regionRX, regionRY)

   * <p>

   * Unity: transparencyLevel = 1

   */

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

 /**

   * Make a given Region (partially) transparent.

   * Effect smoothly fades towards the edges of the region.

   * <p>

   * Uniforms: (transparencyLevel,UNUSED,UNUSED,UNUSED, regionX, regionY, regionRX, regionRY)

   * Unity: transparencyLevel = 1

   */

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

 /**

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

   * <p>

   * Uniforms: (blendLevel,colorR,colorG,colorB, regionX, regionY, regionRX, regionRY)

   * <p>

   * Unity: blendLevel = 0

   */

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

 /**

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

   * <p>

   * Uniforms: (blendLevel,colorR,colorG,colorB, regionX, regionY, regionRX, regionRY)

   * Unity: blendLevel = 0

   */

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

 /**

   * Change brightness level of a given Region.

   * <p>

   * Uniforms: (brightnessLevel,UNUSED,UNUSED,UNUSED, regionX, regionY, regionRX, regionRY)

   * <p>

   * Unity: brightnessLevel = 1

   */

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

 /**

   * Smoothly change brightness level of a given Region.

   * <p>

   * Uniforms: (brightnessLevel,UNUSED,UNUSED,UNUSED, regionX, regionY, regionRX, regionRY)

   * <p>

   * Unity: brightnessLevel = 1

   */

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

 /**

   * Change saturation level of a given Region.

   * <p>

   * Uniforms: (saturationLevel,UNUSED,UNUSED,UNUSED, regionX, regionY, regionRX, regionRY)

   * <p>

   * Unity: saturationLevel = 1

   */

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

 /**

   * Smoothly change saturation level of a given Region.

   * <p>

   * Uniforms: (saturationLevel,UNUSED,UNUSED,UNUSED, regionX, regionY, regionRX, regionRY)

   * <p>

   * Unity: saturationLevel = 1

   */

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

 /**

   * Change contrast level of a given Region.

   * <p>

   * Uniforms: (contrastLevel,UNUSED,UNUSED,UNUSED, regionX, regionY, regionRX, regionRY)

   * <p>

   * Unity: contrastLevel = 1

   */

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

 /**

   * Smoothly change contrast level of a given Region.

   * <p>

   * Uniforms: (contrastLevel,UNUSED,UNUSED,UNUSED, regionX, regionY, regionRX, regionRY)

   * <p>

   * Unity: contrastLevel = 1

   */

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

  // add new Fragment effects here...

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

  // POSTPROCESSING EFFECTS.

  // Always 4 Uniforms: 4 per-effect interpolated values.

 /**

   * Blur the area around the center.

   * <p>

   * Uniforms: (radius,UNUSED,UNUSED,UNUSED)

   * <p>

   * Unity: radius = 0

   */

  BLUR             ( EffectTypes.POSTPROCESS,new float[] {0.0f}          , 1, false, false );

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

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

  private final EffectTypes type;

  private final float[] unity;

  private final int dimension;

  private final boolean supportsR;

  private final boolean supportsC;

  private static final float[] unities;

  private static final int[] unityDimensions;

  private static final int[] dimensions;

  private static final boolean[] supportsRegion;

  private static final boolean[] supportsCenter;

  private static final EffectNames[] names;

  static

    {

    int len = values().length;

    int i=0;

    unityDimensions = new int[len];

    dimensions      = new int[len];

    supportsRegion  = new boolean[len];

    supportsCenter  = new boolean[len];

    unities         = new float[MAXDIM*len];

    names           = new EffectNames[len];

    for(EffectNames name: EffectNames.values())

      {

      unityDimensions[i] = (name.unity==null ? 0 : name.unity.length);

      dimensions[i]      = name.dimension;

      supportsRegion[i]  = name.supportsR;

      supportsCenter[i]  = name.supportsC;

      names[i]           = name;

      switch(unityDimensions[i])

        {

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

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

        case 0: break;

        }

      i++;  

      }

    }

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

  EffectNames(EffectTypes type, float[] unity, int dimension, boolean supportsR, boolean supportsC)

    {

    this.type      = type;

    this.unity     = unity;

    this.dimension = dimension;

    this.supportsR = supportsR;

    this.supportsC = supportsC;

    }

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

  static EffectTypes getType(int ordinal)

    {

    return names[ordinal].type;

    }

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

  static EffectNames getName(int ordinal)

    {

    return names[ordinal];

    }

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

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

    {

    switch(unityDimensions[ordinal])

      {

      case 0: break;

      case 1: buffer[index  ]=unities[MAXDIM*ordinal  ];

              break;

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

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

              break;

      case 3: buffer[index  ]=unities[MAXDIM*ordinal  ];

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

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

              break;

      case 4: buffer[index  ]=unities[MAXDIM*ordinal  ];

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

              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(unityDimensions[ordinal])

      {

      case 0: return true;

      case 1: return buffer[index  ]==unities[MAXDIM*ordinal  ];

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

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

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

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

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

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

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

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

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

      }

    return false;

    }

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

// PUBLIC API

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

/**

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

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

/**

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

  }