Distorted Android

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

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

// Lesser General Public License for more details.                                               //

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

import org.distorted.library.type.Static3D;

  {

   * 12: 5 per-effect interpolated values, 3-dimensional center, 4-dimensional Region

   */

  public static final int NUM_FLOAT_UNIFORMS = 12;

  /**

  static final int CENTER_OFFSET = 5;

  static final int REGION_OFFSET = 8;

  private static int mNumEnabled = 0;

  private static int mFullEnabled = 0;

  private static boolean mFullPrepared = false;

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

           code +"\n" +

          "}\n" +

        "else\n";

    }

// prepare the code to be injected into the Full program, i.e. code of ALL vertex effects.

  private static void prepareFull()

    {

    Method method;

    for(EffectName name: EffectName.values())

      {

      if( name.getType() == EffectType.VERTEX )

        {

        Class<? extends Effect> cls = name.getEffectClass();

        try

          {

          method = cls.getDeclaredMethod("code");

          }

        catch(NoSuchMethodException ex)

          {

          }

        try

          {

          if( method!=null )

            {

            Object value = method.invoke(null);

            String code = (String)value;

            mFullGLSL += retSection(name.ordinal(),code);

            mFullEnabled++;

            }

          }

        catch(Exception ex)

          {

        }

      }

    }

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

// prepare code to be injected into the 'main_vertex_shader' main() function.

  static void addEffect(EffectName name, String code)

    {

    int effect = name.ordinal();

    if( !mEnabled[effect] )

      {

      mEnabled[effect] = true;

      mNumEnabled ++;

      mGLSL += retSection(effect,code);

      }

    }

 * Only for use by the library itself.

 *

 * @y.exclude

 */

    {

    return mGLSL + "{}";

    }

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public static String getAllGLSL()

    {

    if( !mFullPrepared )

      {

      prepareFull();

      mFullPrepared = true;

      }

    return mFullGLSL + "{}";

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public static int getAllEnabled()

    {

    if( !mFullPrepared )

      {

      prepareFull();

      mFullPrepared = true;

      }

    return mFullEnabled;

    }

  static void destroyStatics()

    mGLSL = "";

    mFullGLSL = "";

    mFullPrepared = false;

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

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

/**

  public static int getNumEnabled()

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public void addQueue(EffectQueue queue)

    {

    if( mQueues==null ) mQueues = new ArrayList<>();

    mQueues.add(queue);

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public void remQueue(EffectQueue queue)

    {

    if( mQueues==null ) mQueues = new ArrayList<>();

    mQueues.remove(queue);

    }

/**

 * One can set two types of associations - an 'logical and' and a 'equal' associations and the Effect

 * will only be active on vertices of Components such that

 * (see main_vertex_shader)

 * The point: this way we can configure the system so that each Vertex Effect acts only on a certain

    mEquAssociation = equAssociation;

    int numQueues = mQueues==null ? 0: mQueues.size();

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

      {

      EffectQueue queue = mQueues.get(i);

      queue.setAssociation(id);

      }

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

/**

 * Return a constructed VertexEffect based on its name, the 5 variables, center & region.

 */

  public static VertexEffect constructEffect(String name,float[] vars, float[] center, float[] region)

    {

    Static3D staCenter = new Static3D(center[0],center[1],center[2]);

    Static4D staRegion = new Static4D(region[0],region[1],region[2],region[3]);

    if( name.equals(EffectName.DISTORT.name()) )

      {

      Static3D staVars = new Static3D(vars[2],vars[3],vars[4]);

      return new VertexEffectDistort(staVars,staCenter,staRegion);

      }

    if( name.equals(EffectName.DEFORM.name()) )

      {

      Static3D staVars   = new Static3D(vars[1],vars[2],vars[3]);

      Static1D staRadius = new Static1D(vars[4]);

      return new VertexEffectDeform(staVars,staRadius,staCenter,staRegion);

      }

    if( name.equals(EffectName.SINK.name()) )

      {

      Static1D staSink = new Static1D(vars[4]);

      return new VertexEffectSink(staSink,staCenter,staRegion);

      }

    if( name.equals(EffectName.PINCH.name()) )

      {

      Static3D staVars = new Static3D(vars[2],vars[3],vars[4]);

      return new VertexEffectPinch(staVars,staCenter,staRegion);

      }

    if( name.equals(EffectName.SWIRL.name()) )

      {

      Static1D staSwirl = new Static1D(vars[4]);

      return new VertexEffectSwirl(staSwirl,staCenter,staRegion);

      }

    if( name.equals(EffectName.WAVE.name()) )

      {

      Static5D staWave = new Static5D(vars[0],vars[1],vars[2],vars[3],vars[4]);

      return new VertexEffectWave(staWave,staCenter,staRegion);

      }

    if( name.equals(EffectName.DISAPPEAR.name()) )

      {

      return new VertexEffectDisappear();

      }

    if( name.equals(EffectName.VERTEX_MOVE.name()) )

      {

      Static3D staVector = new Static3D(vars[2],vars[3],vars[4]);

      return new VertexEffectMove(staVector);

      }

    if( name.equals(EffectName.VERTEX_QUATERNION.name()) )

      {

      Static4D staQuat = new Static4D(vars[1],vars[2],vars[3],vars[4]);

      return new VertexEffectQuaternion(staQuat,staCenter);

      }

    if( name.equals(EffectName.VERTEX_ROTATE.name()) )

      {

      Static1D staAngle = new Static1D(vars[1]);

      Static3D staAxis  = new Static3D(vars[2],vars[3],vars[4]);

      return new VertexEffectRotate(staAngle,staAxis,staCenter);

      }

    if( name.equals(EffectName.VERTEX_SCALE.name()) )

      {

      Static3D staScale = new Static3D(vars[2],vars[3],vars[4]);

      return new VertexEffectScale(staScale);

      }

    if( name.equals(EffectName.VERTEX_SHEAR.name()) )

      {

      Static3D staShear = new Static3D(vars[2],vars[3],vars[4]);

      return new VertexEffectShear(staShear,staCenter);

      }

    return null;

    }