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;

import android.content.res.Resources;

import android.opengl.GLES20;

import android.opengl.Matrix;

import org.distorted.library.message.EffectListener;

import org.distorted.library.program.DistortedProgram;

import org.distorted.library.program.FragmentCompilationException;

import org.distorted.library.program.FragmentUniformsException;

import org.distorted.library.program.LinkingException;

import org.distorted.library.program.VertexCompilationException;

import org.distorted.library.program.VertexUniformsException;

import org.distorted.library.type.Data1D;

import org.distorted.library.type.Data2D;

import org.distorted.library.type.Data3D;

import org.distorted.library.type.Data4D;

import org.distorted.library.type.Data5D;

import org.distorted.library.type.Static3D;

import java.io.InputStream;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

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

/**

 * Class containing {@link EffectTypes#LENGTH} queues, each a class derived from EffectQueue.

 * <p>

 * The queues hold actual effects to be applied to a given (DistortedTexture,MeshObject) combo.

 */

public class DistortedEffects

  {

  private static final int POSITION_DATA_SIZE= 3; // Main Program: size of the position data in elements

  private static final int NORMAL_DATA_SIZE  = 3; // Main Program: size of the normal data in elements

  private static final int TEX_DATA_SIZE     = 2; // Main Program: size of the texture coordinate data in elements.

  private static DistortedProgram mProgram;

  /// DEBUG ONLY /////

  private static DistortedProgram mDebugProgram;

  private static final FloatBuffer mQuadPositions;

  static

    {

    float[] positionData= { -0.5f, -0.5f,  -0.5f, 0.5f,  0.5f,-0.5f,  0.5f, 0.5f };

    mQuadPositions = ByteBuffer.allocateDirect(32).order(ByteOrder.nativeOrder()).asFloatBuffer();

    mQuadPositions.put(positionData).position(0);

    }

  private static int mObjDH;

  private static int mMVPMatrixH;

  /// END DEBUG //////

  private static float[] mMVPMatrix = new float[16];

  private static float[] mTmpMatrix = new float[16];

  private static long mNextID =0;

  private long mID;

  private static DistortedFramebuffer mBufferFBO = new DistortedFramebuffer(1,1);

  private EffectQueueMatrix      mM;

  private EffectQueueFragment    mF;

  private EffectQueueVertex      mV;

  private EffectQueuePostprocess mP;

  private boolean matrixCloned, vertexCloned, fragmentCloned, postprocessCloned;

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

  static void createProgram(Resources resources)

  throws FragmentCompilationException,VertexCompilationException,VertexUniformsException,FragmentUniformsException,LinkingException

    {

    final InputStream mainVertexStream   = resources.openRawResource(R.raw.main_vertex_shader);

    final InputStream mainFragmentStream = resources.openRawResource(R.raw.main_fragment_shader);

    String mainVertexHeader= ("#version 100\n#define NUM_VERTEX "  + getMaxVertex()+"\n");

    for(EffectNames name: EffectNames.values() )

      {

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

        mainVertexHeader += ("#define "+name.name()+" "+name.ordinal()+"\n");

      }

    String mainFragmentHeader= ("#version 100\n#define NUM_FRAGMENT "  + getMaxFragment()+"\n");

    for(EffectNames name: EffectNames.values() )

      {

      if( name.getType()== EffectTypes.FRAGMENT)

        mainFragmentHeader += ("#define "+name.name()+" "+name.ordinal()+"\n");

      }

    mProgram = new DistortedProgram(mainVertexStream,mainFragmentStream, mainVertexHeader, mainFragmentHeader);

    int mainProgramH = mProgram.getProgramHandle();

    EffectQueueFragment.getUniforms(mainProgramH);

    EffectQueueVertex.getUniforms(mainProgramH);

    EffectQueueMatrix.getUniforms(mainProgramH);

    DistortedTexture.getUniforms(mainProgramH);

    // DEBUG ONLY //////////////////////////////////////

    final InputStream debugVertexStream   = resources.openRawResource(R.raw.test_vertex_shader);

    final InputStream debugFragmentStream = resources.openRawResource(R.raw.test_fragment_shader);

    mDebugProgram = new DistortedProgram(debugVertexStream,debugFragmentStream, "#version 100\n", "#version 100\n");

    int debugProgramH = mDebugProgram.getProgramHandle();

    mObjDH      = GLES20.glGetUniformLocation( debugProgramH, "u_objD");

    mMVPMatrixH = GLES20.glGetUniformLocation( debugProgramH, "u_MVPMatrix");

    // END DEBUG  //////////////////////////////////////

    }

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

  private void initializeEffectLists(DistortedEffects d, int flags)

    {

    if( (flags & Distorted.CLONE_MATRIX) != 0 )

      {

      mM = d.mM;

      matrixCloned = true;

      }

    else

      {

      mM = new EffectQueueMatrix(mID);

      matrixCloned = false;

      }

    if( (flags & Distorted.CLONE_VERTEX) != 0 )

      {

      mV = d.mV;

      vertexCloned = true;

      }

    else

      {

      mV = new EffectQueueVertex(mID);

      vertexCloned = false;

      }

    if( (flags & Distorted.CLONE_FRAGMENT) != 0 )

      {

      mF = d.mF;

      fragmentCloned = true;

      }

    else

      {

      mF = new EffectQueueFragment(mID);

      fragmentCloned = false;

      }

    if( (flags & Distorted.CLONE_POSTPROCESS) != 0 )

      {

      mP = d.mP;

      postprocessCloned = true;

      }

    else

      {

      mP = new EffectQueuePostprocess(mID);

      postprocessCloned = false;

      }

    }

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

// DEBUG ONLY

  @SuppressWarnings("unused")

  private void displayBoundingRect(float halfX, float halfY, float halfZ, DistortedFramebuffer df, float[] mvp, float[] vertices)

    {

    int len  = vertices.length/3;

    int minx = Integer.MAX_VALUE;

    int maxx = Integer.MIN_VALUE;

    int miny = Integer.MAX_VALUE;

    int maxy = Integer.MIN_VALUE;

    int wx,wy;

    float x,y,z, X,Y,W, ndcX,ndcY;

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

      {

      x = 2*halfX*vertices[3*i  ];

      y = 2*halfY*vertices[3*i+1];

      z = 2*halfZ*vertices[3*i+2];

      X = mvp[ 0]*x + mvp[ 4]*y + mvp[ 8]*z + mvp[12];

      Y = mvp[ 1]*x + mvp[ 5]*y + mvp[ 9]*z + mvp[13];

      W = mvp[ 3]*x + mvp[ 7]*y + mvp[11]*z + mvp[15];

      ndcX = X/W;

      ndcY = Y/W;

      wx = (int)(df.mWidth *(ndcX+1)/2);

      wy = (int)(df.mHeight*(ndcY+1)/2);

      if( wx<minx ) minx = wx;

      if( wx>maxx ) maxx = wx;

      if( wy<miny ) miny = wy;

      if( wy>maxy ) maxy = wy;

      }

    mDebugProgram.useProgram();

    df.setAsOutput();

    Matrix.setIdentityM( mTmpMatrix, 0);

    Matrix.translateM  ( mTmpMatrix, 0, minx-df.mWidth/2, maxy-df.mHeight/2, -df.mDistance);

    Matrix.scaleM      ( mTmpMatrix, 0, (float)(maxx-minx)/(2*halfX), (float)(maxy-miny)/(2*halfY), 1.0f);

    Matrix.translateM  ( mTmpMatrix, 0, halfX,-halfY, 0);

    Matrix.multiplyMM  ( mMVPMatrix, 0, df.mProjectionMatrix, 0, mTmpMatrix, 0);

    GLES20.glUniform2f( mObjDH , 2*halfX, 2*halfY);

    GLES20.glUniformMatrix4fv(mMVPMatrixH, 1, false, mMVPMatrix , 0);

    GLES20.glVertexAttribPointer(mDebugProgram.mAttribute[0], 2, GLES20.GL_FLOAT, false, 0, mQuadPositions);

    GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);

    }

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

  void drawPriv(float halfInputW, float halfInputH, MeshObject mesh, DistortedFramebuffer df, long currTime)

    {

    mM.compute(currTime);

    mV.compute(currTime);

    mF.compute(currTime);

    mP.compute(currTime);

    float halfZ = halfInputW*mesh.zFactor;

    GLES20.glViewport(0, 0, df.mWidth, df.mHeight);

    if( mP.mNumEffects==0 )

      {

      mProgram.useProgram();

      df.setAsOutput();

      mM.send(df,halfInputW,halfInputH,halfZ);

      mV.send(halfInputW,halfInputH,halfZ);

      mF.send(halfInputW,halfInputH);

      GLES20.glVertexAttribPointer(mProgram.mAttribute[0], POSITION_DATA_SIZE, GLES20.GL_FLOAT, false, 0, mesh.mMeshPositions);

      GLES20.glVertexAttribPointer(mProgram.mAttribute[1], NORMAL_DATA_SIZE  , GLES20.GL_FLOAT, false, 0, mesh.mMeshNormals);

      GLES20.glVertexAttribPointer(mProgram.mAttribute[2], TEX_DATA_SIZE     , GLES20.GL_FLOAT, false, 0, mesh.mMeshTexture);

      GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, mesh.dataLength);

      }

    else

      {

      if( mV.mNumEffects==0 && mF.mNumEffects==0 && (mesh instanceof MeshFlat) && mM.canUseShortcut() )

        {

        mM.constructMatrices(df,halfInputW,halfInputH);

        mP.render(2*halfInputW, 2*halfInputH, mM.getMVP(), df);

        }

      else

        {

        mProgram.useProgram();

        mBufferFBO.resizeFast(df.mWidth, df.mHeight);

        mBufferFBO.setAsOutput();

        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

        GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

        mM.send(mBufferFBO,halfInputW,halfInputH,halfZ);

        mV.send(halfInputW,halfInputH,halfZ);

        mF.send(halfInputW,halfInputH);

        GLES20.glVertexAttribPointer(mProgram.mAttribute[0], POSITION_DATA_SIZE, GLES20.GL_FLOAT, false, 0, mesh.mMeshPositions);

        GLES20.glVertexAttribPointer(mProgram.mAttribute[1], NORMAL_DATA_SIZE  , GLES20.GL_FLOAT, false, 0, mesh.mMeshNormals);

        GLES20.glVertexAttribPointer(mProgram.mAttribute[2], TEX_DATA_SIZE     , GLES20.GL_FLOAT, false, 0, mesh.mMeshTexture);

        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, mesh.dataLength);

        Matrix.setIdentityM(mTmpMatrix, 0);

        Matrix.translateM(mTmpMatrix, 0, 0, 0, -df.mDistance);

        Matrix.multiplyMM(mMVPMatrix, 0, df.mProjectionMatrix, 0, mTmpMatrix, 0);

        mBufferFBO.setAsInput();

        mP.render(df.mWidth, df.mHeight, mMVPMatrix, df);

        }

      }

    /// DEBUG ONLY //////

    // displayBoundingRect(halfInputW, halfInputH, halfZ, df, mM.getMVP(), mesh.getBoundingVertices() );

    /// END DEBUG ///////

    }

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

  static void drawNoEffectsPriv(float halfInputW, float halfInputH, MeshObject mesh, DistortedFramebuffer df)

    {

    GLES20.glViewport(0, 0, df.mWidth, df.mHeight);

    Matrix.setIdentityM(mTmpMatrix, 0);

    Matrix.translateM(mTmpMatrix, 0, 0, 0, -df.mDistance);

    Matrix.multiplyMM(mMVPMatrix, 0, df.mProjectionMatrix, 0, mTmpMatrix, 0);

    EffectQueueMatrix.sendZero(df,halfInputW,halfInputH,halfInputW*mesh.zFactor);

    EffectQueueVertex.sendZero();

    EffectQueueFragment.sendZero();

    EffectQueuePostprocess.sendZero(df.mWidth, df.mHeight, mMVPMatrix);

    GLES20.glVertexAttribPointer(mProgram.mAttribute[0], POSITION_DATA_SIZE, GLES20.GL_FLOAT, false, 0, mesh.mMeshPositions);

    GLES20.glVertexAttribPointer(mProgram.mAttribute[1], NORMAL_DATA_SIZE  , GLES20.GL_FLOAT, false, 0, mesh.mMeshNormals);

    GLES20.glVertexAttribPointer(mProgram.mAttribute[2], TEX_DATA_SIZE     , GLES20.GL_FLOAT, false, 0, mesh.mMeshTexture);

    GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, mesh.dataLength);

    }

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

  private void releasePriv()

    {

    if( !matrixCloned     ) mM.abortAll(false);

    if( !vertexCloned     ) mV.abortAll(false);

    if( !fragmentCloned   ) mF.abortAll(false);

    if( !postprocessCloned) mP.abortAll(false);

    mM = null;

    mV = null;

    mF = null;

    mP = null;

    }

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

  static void onDestroy()

    {

    mNextID = 0;

    }

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

// PUBLIC API

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

/**

 * Create empty effect queue.

 */

  public DistortedEffects()

    {

    mID = mNextID++;

    initializeEffectLists(this,0);

    }

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

/**

 * Copy constructor.

 * <p>

 * Whatever we do not clone gets created just like in the default constructor.

 *

 * @param dc    Source object to create our object from

 * @param flags A bitmask of values specifying what to copy.

 *              For example, CLONE_VERTEX | CLONE_MATRIX.

 */

  public DistortedEffects(DistortedEffects dc, int flags)

    {

    mID = mNextID++;

    initializeEffectLists(dc,flags);

    }

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

/**

 * Releases all resources. After this call, the queue should not be used anymore.

 */

  public synchronized void delete()

    {

    releasePriv();

    }

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

/**

 * Returns unique ID of this instance.

 *

 * @return ID of the object.

 */

  public long getID()

      {

      return mID;

      }

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

/**

 * Adds the calling class to the list of Listeners that get notified each time some event happens 

 * to one of the Effects in those queues. Nothing will happen if 'el' is already in the list.

 * 

 * @param el A class implementing the EffectListener interface that wants to get notifications.

 */

  public void registerForMessages(EffectListener el)

    {

    mV.registerForMessages(el);

    mF.registerForMessages(el);

    mM.registerForMessages(el);

    mP.registerForMessages(el);

    }

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

/**

 * Removes the calling class from the list of Listeners.

 * 

 * @param el A class implementing the EffectListener interface that no longer wants to get notifications.

 */

  public void deregisterForMessages(EffectListener el)

    {

    mV.deregisterForMessages(el);

    mF.deregisterForMessages(el);

    mM.deregisterForMessages(el);

    mP.deregisterForMessages(el);

    }

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

/**

 * Aborts all Effects.

 * @return Number of effects aborted.

 */

  public int abortAllEffects()

      {

      return mM.abortAll(true) + mV.abortAll(true) + mF.abortAll(true) + mP.abortAll(true);

      }

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

/**

 * Aborts all Effects of a given type, for example all MATRIX Effects.

 * 

 * @param type one of the constants defined in {@link EffectTypes}

 * @return Number of effects aborted.

 */

  public int abortEffects(EffectTypes type)

    {

    switch(type)

      {

      case MATRIX     : return mM.abortAll(true);

      case VERTEX     : return mV.abortAll(true);

      case FRAGMENT   : return mF.abortAll(true);

      case POSTPROCESS: return mP.abortAll(true);

      default         : return 0;

      }

    }

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

/**

 * Aborts a single Effect.

 * 

 * @param id ID of the Effect we want to abort.

 * @return number of Effects aborted. Always either 0 or 1.

 */

  public int abortEffect(long id)

    {

    int type = (int)(id&EffectTypes.MASK);

    if( type==EffectTypes.MATRIX.type      ) return mM.removeByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.VERTEX.type      ) return mV.removeByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.FRAGMENT.type    ) return mF.removeByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.POSTPROCESS.type ) return mP.removeByID(id>>EffectTypes.LENGTH);

    return 0;

    }

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

/**

 * Abort all Effects of a given name, for example all rotations.

 * 

 * @param name one of the constants defined in {@link EffectNames}

 * @return number of Effects aborted.

 */

  public int abortEffects(EffectNames name)

    {

    switch(name.getType())

      {

      case MATRIX     : return mM.removeByType(name);

      case VERTEX     : return mV.removeByType(name);

      case FRAGMENT   : return mF.removeByType(name);

      case POSTPROCESS: return mP.removeByType(name);

      default         : return 0;

      }

    }

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

/**

 * Print some info about a given Effect to Android's standard out. Used for debugging only.

 * 

 * @param id Effect ID we want to print info about

 * @return <code>true</code> if a single Effect of type effectType has been found.

 */

  public boolean printEffect(long id)

    {

    int type = (int)(id&EffectTypes.MASK);

    if( type==EffectTypes.MATRIX.type      )  return mM.printByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.VERTEX.type      )  return mV.printByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.FRAGMENT.type    )  return mF.printByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.POSTPROCESS.type )  return mP.printByID(id>>EffectTypes.LENGTH);

    return false;

    }

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

/**

 * Returns the maximum number of Matrix effects.

 *

 * @return The maximum number of Matrix effects

 */

  public static int getMaxMatrix()

    {

    return EffectQueue.getMax(EffectTypes.MATRIX.ordinal());

    }

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

/**

 * Returns the maximum number of Vertex effects.

 *

 * @return The maximum number of Vertex effects

 */

  public static int getMaxVertex()

    {

    return EffectQueue.getMax(EffectTypes.VERTEX.ordinal());

    }

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

/**

 * Returns the maximum number of Fragment effects.

 *

 * @return The maximum number of Fragment effects

 */

  public static int getMaxFragment()

    {

    return EffectQueue.getMax(EffectTypes.FRAGMENT.ordinal());

    }

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

/**

 * Returns the maximum number of Postprocess effects.

 *

 * @return The maximum number of Postprocess effects

 */

  public static int getMaxPostprocess()

    {

    return EffectQueue.getMax(EffectTypes.POSTPROCESS.ordinal());

    }

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

/**

 * Sets the maximum number of Matrix effects that can be stored in a single EffectQueue at one time.

 * This can fail if:

 * <ul>

 * <li>the value of 'max' is outside permitted range (0 &le; max &le; Byte.MAX_VALUE)

 * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called

 *     before the Vertex Shader gets compiled, i.e. before the call to {@link Distorted#onCreate}. After this

 *     time only decreasing the value of 'max' is permitted.

 * <li>Furthermore, this needs to be called before any instances of the DistortedEffects class get created.

 * </ul>

 *

 * @param max new maximum number of simultaneous Matrix Effects. Has to be a non-negative number not greater

 *            than Byte.MAX_VALUE

 * @return <code>true</code> if operation was successful, <code>false</code> otherwise.

 */

  public static boolean setMaxMatrix(int max)

    {

    return EffectQueue.setMax(EffectTypes.MATRIX.ordinal(),max);

    }

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

/**

 * Sets the maximum number of Vertex effects that can be stored in a single EffectQueue at one time.

 * This can fail if:

 * <ul>

 * <li>the value of 'max' is outside permitted range (0 &le; max &le; Byte.MAX_VALUE)

 * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called

 *     before the Vertex Shader gets compiled, i.e. before the call to {@link Distorted#onCreate}. After this

 *     time only decreasing the value of 'max' is permitted.

* <li>Furthermore, this needs to be called before any instances of the DistortedEffects class get created.

 * </ul>

 *

 * @param max new maximum number of simultaneous Vertex Effects. Has to be a non-negative number not greater

 *            than Byte.MAX_VALUE

 * @return <code>true</code> if operation was successful, <code>false</code> otherwise.

 */

  public static boolean setMaxVertex(int max)

    {

    return EffectQueue.setMax(EffectTypes.VERTEX.ordinal(),max);

    }

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

/**

 * Sets the maximum number of Fragment effects that can be stored in a single EffectQueue at one time.

 * This can fail if:

 * <ul>

 * <li>the value of 'max' is outside permitted range (0 &le; max &le; Byte.MAX_VALUE)

 * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called

 *     before the Fragment Shader gets compiled, i.e. before the call to {@link Distorted#onCreate}. After this

 *     time only decreasing the value of 'max' is permitted.

 * <li>Furthermore, this needs to be called before any instances of the DistortedEffects class get created.

 * </ul>

 *

 * @param max new maximum number of simultaneous Fragment Effects. Has to be a non-negative number not greater

 *            than Byte.MAX_VALUE

 * @return <code>true</code> if operation was successful, <code>false</code> otherwise.

 */

  public static boolean setMaxFragment(int max)

    {

    return EffectQueue.setMax(EffectTypes.FRAGMENT.ordinal(),max);

    }

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

/**

 * Sets the maximum number of Postprocess effects that can be stored in a single EffectQueue at one time.

 * This can fail if:

 * <ul>

 * <li>the value of 'max' is outside permitted range (0 &le; max &le; Byte.MAX_VALUE)

 * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called

 *     before the Fragment Shader gets compiled, i.e. before the call to {@link Distorted#onCreate}. After this

 *     time only decreasing the value of 'max' is permitted.

 * <li>Furthermore, this needs to be called before any instances of the DistortedEffects class get created.

 * </ul>

 *

 * @param max new maximum number of simultaneous Postprocess Effects. Has to be a non-negative number not greater

 *            than Byte.MAX_VALUE

 * @return <code>true</code> if operation was successful, <code>false</code> otherwise.

 */

  public static boolean setMaxPostprocess(int max)

    {

    return EffectQueue.setMax(EffectTypes.POSTPROCESS.ordinal(),max);

    }

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

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

// Individual effect functions.

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

// Matrix-based effects

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

/**

 * Moves the Object by a (possibly changing in time) vector.

 * 

 * @param vector 3-dimensional Data which at any given time will return a Static3D

 *               representing the current coordinates of the vector we want to move the Object with.

 * @return       ID of the effect added, or -1 if we failed to add one.

 */

  public long move(Data3D vector)

    {   

    return mM.add(EffectNames.MOVE,vector);

    }

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

/**

 * Scales the Object by (possibly changing in time) 3D scale factors.

 * 

 * @param scale 3-dimensional Data which at any given time returns a Static3D

 *              representing the current x- , y- and z- scale factors.

 * @return      ID of the effect added, or -1 if we failed to add one.

 */

  public long scale(Data3D scale)

    {   

    return mM.add(EffectNames.SCALE,scale);

    }

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

/**

 * Scales the Object by one uniform, constant factor in all 3 dimensions. Convenience function.

 *

 * @param scale The factor to scale all 3 dimensions with.

 * @return      ID of the effect added, or -1 if we failed to add one.

 */

  public long scale(float scale)

    {

    return mM.add(EffectNames.SCALE, new Static3D(scale,scale,scale));

    }

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

/**

 * Rotates the Object by 'angle' degrees around the center.

 * Static axis of rotation is given by the last parameter.

 *

 * @param angle  Angle that we want to rotate the Object to. Unit: degrees

 * @param axis   Axis of rotation

 * @param center Coordinates of the Point we are rotating around.

 * @return       ID of the effect added, or -1 if we failed to add one.

 */

  public long rotate(Data1D angle, Static3D axis, Data3D center )

    {   

    return mM.add(EffectNames.ROTATE, angle, axis, center);

    }

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

/**

 * Rotates the Object by 'angle' degrees around the center.

 * Here both angle and axis can dynamically change.

 *

 * @param angleaxis Combined 4-tuple representing the (angle,axisX,axisY,axisZ).

 * @param center    Coordinates of the Point we are rotating around.

 * @return          ID of the effect added, or -1 if we failed to add one.

 */

  public long rotate(Data4D angleaxis, Data3D center)

    {

    return mM.add(EffectNames.ROTATE, angleaxis, center);

    }

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

/**

 * Rotates the Object by quaternion.

 *

 * @param quaternion The quaternion describing the rotation.

 * @param center     Coordinates of the Point we are rotating around.

 * @return           ID of the effect added, or -1 if we failed to add one.

 */

  public long quaternion(Data4D quaternion, Data3D center )

    {

    return mM.add(EffectNames.QUATERNION,quaternion,center);

    }

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

/**

 * Shears the Object.

 *

 * @param shear   The 3-tuple of shear factors. The first controls level

 *                of shearing in the X-axis, second - Y-axis and the third -

 *                Z-axis. Each is the tangens of the shear angle, i.e 0 -

 *                no shear, 1 - shear by 45 degrees (tan(45deg)=1) etc.

 * @param center  Center of shearing, i.e. the point which stays unmoved.

 * @return        ID of the effect added, or -1 if we failed to add one.

 */

  public long shear(Data3D shear, Data3D center)

    {

    return mM.add(EffectNames.SHEAR, shear, center);

    }

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

// Fragment-based effects  

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

/**

 * Makes a certain sub-region of the Object smoothly change all three of its RGB components.

 *        

 * @param blend  1-dimensional Data that returns the level of blend a given pixel will be

 *               mixed with the next parameter 'color': pixel = (1-level)*pixel + level*color.

 *               Valid range: <0,1>

 * @param color  Color to mix. (1,0,0) is RED.

 * @param region Region this Effect is limited to.

 * @param smooth If true, the level of 'blend' will smoothly fade out towards the edges of the region.

 * @return       ID of the effect added, or -1 if we failed to add one.

 */

  public long chroma(Data1D blend, Data3D color, Data4D region, boolean smooth)

    {

    return mF.add( smooth? EffectNames.SMOOTH_CHROMA:EffectNames.CHROMA, blend, color, region);

    }

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

/**

 * Makes the whole Object smoothly change all three of its RGB components.

 *

 * @param blend  1-dimensional Data that returns the level of blend a given pixel will be

 *               mixed with the next parameter 'color': pixel = (1-level)*pixel + level*color.

 *               Valid range: <0,1>

 * @param color  Color to mix. (1,0,0) is RED.

 * @return       ID of the effect added, or -1 if we failed to add one.

 */

  public long chroma(Data1D blend, Data3D color)

    {

    return mF.add(EffectNames.CHROMA, blend, color);

    }

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

/**

 * Makes a certain sub-region of the Object smoothly change its transparency level.

 *        

 * @param alpha  1-dimensional Data that returns the level of transparency we want to have at any given

 *               moment: pixel.a *= alpha.

 *               Valid range: <0,1>

 * @param region Region this Effect is limited to. 

 * @param smooth If true, the level of 'alpha' will smoothly fade out towards the edges of the region.

 * @return       ID of the effect added, or -1 if we failed to add one. 

 */

  public long alpha(Data1D alpha, Data4D region, boolean smooth)

    {

    return mF.add( smooth? EffectNames.SMOOTH_ALPHA:EffectNames.ALPHA, alpha, region);

    }

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

/**

 * Makes the whole Object smoothly change its transparency level.

 *

 * @param alpha  1-dimensional Data that returns the level of transparency we want to have at any

 *               given moment: pixel.a *= alpha.

 *               Valid range: <0,1>

 * @return       ID of the effect added, or -1 if we failed to add one.

 */

  public long alpha(Data1D alpha)

    {

    return mF.add(EffectNames.ALPHA, alpha);

    }

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

/**

 * Makes a certain sub-region of the Object smoothly change its brightness level.

 *        

 * @param brightness 1-dimensional Data that returns the level of brightness we want to have

 *                   at any given moment. Valid range: <0,infinity)

 * @param region     Region this Effect is limited to.

 * @param smooth     If true, the level of 'brightness' will smoothly fade out towards the edges of the region.

 * @return           ID of the effect added, or -1 if we failed to add one.

 */

  public long brightness(Data1D brightness, Data4D region, boolean smooth)

    {

    return mF.add( smooth ? EffectNames.SMOOTH_BRIGHTNESS: EffectNames.BRIGHTNESS, brightness, region);

    }

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

/**

 * Makes the whole Object smoothly change its brightness level.

 *

 * @param brightness 1-dimensional Data that returns the level of brightness we want to have

 *                   at any given moment. Valid range: <0,infinity)

 * @return           ID of the effect added, or -1 if we failed to add one.

 */

  public long brightness(Data1D brightness)

    {

    return mF.add(EffectNames.BRIGHTNESS, brightness);

    }

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

/**

 * Makes a certain sub-region of the Object smoothly change its contrast level.

 *        

 * @param contrast 1-dimensional Data that returns the level of contrast we want to have

 *                 at any given moment. Valid range: <0,infinity)

 * @param region   Region this Effect is limited to.

 * @param smooth   If true, the level of 'contrast' will smoothly fade out towards the edges of the region.

 * @return         ID of the effect added, or -1 if we failed to add one.

 */

  public long contrast(Data1D contrast, Data4D region, boolean smooth)

    {

    return mF.add( smooth ? EffectNames.SMOOTH_CONTRAST:EffectNames.CONTRAST, contrast, region);

    }

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

/**

 * Makes the whole Object smoothly change its contrast level.

 *

 * @param contrast 1-dimensional Data that returns the level of contrast we want to have

 *                 at any given moment. Valid range: <0,infinity)

 * @return         ID of the effect added, or -1 if we failed to add one.

 */

  public long contrast(Data1D contrast)

    {

    return mF.add(EffectNames.CONTRAST, contrast);

    }

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

/**

 * Makes a certain sub-region of the Object smoothly change its saturation level.

 *        

 * @param saturation 1-dimensional Data that returns the level of saturation we want to have

 *                   at any given moment. Valid range: <0,infinity)

 * @param region     Region this Effect is limited to.

 * @param smooth     If true, the level of 'saturation' will smoothly fade out towards the edges of the region.

 * @return           ID of the effect added, or -1 if we failed to add one.

 */

  public long saturation(Data1D saturation, Data4D region, boolean smooth)

    {

    return mF.add( smooth ? EffectNames.SMOOTH_SATURATION:EffectNames.SATURATION, saturation, region);

    }

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

/**

 * Makes the whole Object smoothly change its saturation level.

 *

 * @param saturation 1-dimensional Data that returns the level of saturation we want to have

 *                   at any given moment. Valid range: <0,infinity)

 * @return           ID of the effect added, or -1 if we failed to add one.

 */

  public long saturation(Data1D saturation)

    {

    return mF.add(EffectNames.SATURATION, saturation);

    }

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

// Vertex-based effects  

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

/**

 * Distort a (possibly changing in time) part of the Object by a (possibly changing in time) vector of force.

 *

 * @param vector 3-dimensional Vector which represents the force the Center of the Effect is

 *               currently being dragged with.

 * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.

 * @param region Region that masks the Effect.

 * @return       ID of the effect added, or -1 if we failed to add one.

 */

  public long distort(Data3D vector, Data3D center, Data4D region)

    {  

    return mV.add(EffectNames.DISTORT, vector, center, region);

    }

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