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;

import org.distorted.library.effectqueue.EffectQueue;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.library.type.Static5D;

import java.lang.reflect.Method;

import java.util.ArrayList;

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

/**

 * Abstract class that represents an Effect that works by injecting certain code into the main Vertex shader.

 */

public abstract class VertexEffect extends Effect

  {

  /**

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

   */

  public static final int NUM_FLOAT_UNIFORMS = 12;

  /**

   * 4: name, AND association, reserved, EQU Association

   */

  public static final int NUM_INT_UNIFORMS = 4;

  static final int VALUES_OFFSET = 0;

  static final int CENTER_OFFSET = 5;

  static final int REGION_OFFSET = 8;

  private static String mGLSL = "";

  private static int mNumEnabled = 0;

  private static String mFullGLSL = "";

  private static int mFullEnabled = 0;

  private static boolean mFullPrepared = false;

  final static Static4D MAX_REGION = new Static4D(0,0,0,1000000);

  ArrayList<EffectQueue> mQueues;

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

  VertexEffect(EffectName name)

    {

    super(name);

    }

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

  private static String retSection(int effect, String code)

    {

    return

        "if( vProperties[i].x =="+effect+" )\n" +

          "{\n" +

           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)

          {

          DistortedLibrary.logMessage("VertexEffect: exception getting method: "+ex.getMessage());

          method = null;

          }

        try

          {

          if( method!=null )

            {

            Object value = method.invoke(null);

            String code = (String)value;

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

            mFullEnabled++;

            }

          }

        catch(Exception ex)

          {

          DistortedLibrary.logMessage("VertexEffect: exception invoking method: "+ex.getMessage());

          }

        }

      }

    }

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

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

 */

  public static String getGLSL()

    {

    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()

    {

    mNumEnabled = 0;

    mGLSL = "";

    mFullEnabled= 0;

    mFullGLSL = "";

    mFullPrepared = false;

    }

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

// PUBLIC API

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

/**

 * Return the number of Vertex effects enabled.

 */

  public static int getNumEnabled()

    {

    return mNumEnabled;

    }

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

/**

 * 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);

    }

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

/**

 * Set Mesh association.

 *

 * This creates an association between a Component of a Mesh and this Vertex Effect.

 * 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

 *

 * (effect andAssoc) & (component andAssoc) != 0 || (effect equAssoc) == (mesh equAssoc)

 *

 * (see main_vertex_shader)

 *

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

 * subset of a Mesh, thus potentially significantly reducing the number of render calls.

 */

  public void setMeshAssociation(int andAssociation, int equAssociation)

    {

    mAndAssociation = andAssociation;

    mEquAssociation = equAssociation;

    long id = getID();

    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;

    }

  }