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.main;

import android.content.res.Resources;

import android.opengl.GLES31;

import android.util.Log;

import org.distorted.library.R;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.EffectName;

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.FragmentEffect;

import org.distorted.library.effect.VertexEffect;

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 java.io.InputStream;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import java.nio.IntBuffer;

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

/**

 * Class containing Matrix, Vertex, Fragment and Postprocessing effect queues.

 * <p>

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

 */

public class DistortedEffects

  {

  /// MAIN PROGRAM ///

  private static DistortedProgram mMainProgram;

  private static int mMainTextureH;

  /// BLIT PROGRAM ///

  private static DistortedProgram mBlitProgram;

  private static int mBlitTextureH;

  private static int mBlitDepthH;

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

    }

  /// BLIT DEPTH PROGRAM ///

  private static DistortedProgram mBlitDepthProgram;

  private static int mBlitDepthSizeH;

  private static int[] mLinkedListSSBO = new int[1];

  private static int[] mAtomicCounter = new int[1];

  static

    {

    mLinkedListSSBO[0]= -1;

    mAtomicCounter[0] = -1;

    }

  private static int mBufferSize=(0x1<<23);  // 8 million entries

  private static IntBuffer mIntBuffer;

private static ByteBuffer mBuf, mAtomicBuf;

private static IntBuffer mIntBuf, mAtomicIntBuf;

  /// BLIT DEPTH RENDER PROGRAM ///

  private static DistortedProgram mBlitDepthRenderProgram;

  private static int mBlitDepthRenderSizeH;

  /// NORMAL PROGRAM /////

  private static DistortedProgram mNormalProgram;

  private static int mNormalMVPMatrixH;

  /// END PROGRAMS //////

  private static long mNextID =0;

  private long mID;

  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

    {

    // MAIN PROGRAM ////////////////////////////////////

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

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

    int numF = FragmentEffect.getNumEnabled();

    int numV = VertexEffect.getNumEnabled();

    String mainVertHeader= Distorted.GLSL_VERSION + ("#define NUM_VERTEX "   + ( numV>0 ? getMax(EffectType.VERTEX  ) : 0 ) + "\n");

    String mainFragHeader= Distorted.GLSL_VERSION + ("#define NUM_FRAGMENT " + ( numF>0 ? getMax(EffectType.FRAGMENT) : 0 ) + "\n");

    String enabledEffectV= VertexEffect.getGLSL();

    String enabledEffectF= FragmentEffect.getGLSL();

    //android.util.Log.e("Effects", "vertHeader= "+mainVertHeader);

    //android.util.Log.e("Effects", "fragHeader= "+mainFragHeader);

    //android.util.Log.e("Effects", "enabledV= "+enabledEffectV);

    //android.util.Log.e("Effects", "enabledF= "+enabledEffectF);

    String[] feedback = { "v_Position", "v_endPosition" };

    try

      {

      mMainProgram = new DistortedProgram(mainVertStream, mainFragStream, mainVertHeader, mainFragHeader,

                                          enabledEffectV, enabledEffectF, Distorted.GLSL, feedback);

      }

    catch(Exception e)

      {

      Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile MAIN program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

      }

    int mainProgramH = mMainProgram.getProgramHandle();

    EffectQueueFragment.getUniforms(mainProgramH);

    EffectQueueVertex.getUniforms(mainProgramH);

    EffectQueueMatrix.getUniforms(mainProgramH);

    mMainTextureH= GLES31.glGetUniformLocation( mainProgramH, "u_Texture");

    // BLIT PROGRAM ////////////////////////////////////

    final InputStream blitVertStream = resources.openRawResource(R.raw.blit_vertex_shader);

    final InputStream blitFragStream = resources.openRawResource(R.raw.blit_fragment_shader);

    String blitVertHeader= (Distorted.GLSL_VERSION + "#define NUM_VERTEX 0\n"  );

    String blitFragHeader= (Distorted.GLSL_VERSION + "#define NUM_FRAGMENT 0\n");

    try

      {

      mBlitProgram = new DistortedProgram(blitVertStream,blitFragStream,blitVertHeader,blitFragHeader, Distorted.GLSL);

      }

    catch(Exception e)

      {

      Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile BLIT program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

      }

    int blitProgramH = mBlitProgram.getProgramHandle();

    mBlitTextureH  = GLES31.glGetUniformLocation( blitProgramH, "u_Texture");

    mBlitDepthH    = GLES31.glGetUniformLocation( blitProgramH, "u_Depth");

    // BLIT DEPTH PROGRAM ////////////////////////////////////

    final InputStream blitDepthVertStream = resources.openRawResource(R.raw.blit_depth_vertex_shader);

    final InputStream blitDepthFragStream = resources.openRawResource(R.raw.blit_depth_fragment_shader);

    try

      {

      mBlitDepthProgram = new DistortedProgram(blitDepthVertStream,blitDepthFragStream,blitVertHeader,blitFragHeader, Distorted.GLSL);

      }

    catch(Exception e)

      {

      Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile BLIT DEPTH program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

      }

    int blitDepthProgramH   = mBlitDepthProgram.getProgramHandle();

    mBlitDepthSizeH         = GLES31.glGetUniformLocation( blitDepthProgramH, "u_Size");

    mIntBuffer = ByteBuffer.allocateDirect(4).order(ByteOrder.nativeOrder()).asIntBuffer();

    mIntBuffer.put(0,0);

    if( mLinkedListSSBO[0]<0 )

      {

      GLES31.glGenBuffers(1,mLinkedListSSBO,0);

      GLES31.glBindBufferBase(GLES31.GL_SHADER_STORAGE_BUFFER, 1, mLinkedListSSBO[0]);

      GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, mLinkedListSSBO[0]);

      GLES31.glBufferData(GLES31.GL_SHADER_STORAGE_BUFFER, mBufferSize*4 , null, GLES31.GL_DYNAMIC_READ|GLES31.GL_DYNAMIC_DRAW);

      GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, 0);

      }

    if( mAtomicCounter[0]<0 )

      {

      GLES31.glGenBuffers(1,mAtomicCounter,0);

      GLES31.glBindBufferBase(GLES31.GL_ATOMIC_COUNTER_BUFFER, 0, mAtomicCounter[0]);

      GLES31.glBindBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER, mAtomicCounter[0] );

      GLES31.glBufferData(GLES31.GL_ATOMIC_COUNTER_BUFFER, 4, mIntBuffer, GLES31.GL_DYNAMIC_DRAW);

      GLES31.glBindBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER, 0);

      }

    // BLIT DEPTH RENDER PROGRAM ///////////////////////////

    final InputStream blitDepthRenderVertStream = resources.openRawResource(R.raw.blit_depth_vertex_shader);

    final InputStream blitDepthRenderFragStream = resources.openRawResource(R.raw.blit_depth_render_fragment_shader);

    try

      {

      mBlitDepthRenderProgram = new DistortedProgram(blitDepthRenderVertStream,blitDepthRenderFragStream,blitVertHeader,blitFragHeader, Distorted.GLSL);

      }

    catch(Exception e)

      {

      Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile BLIT DEPTH RENDER program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

      }

    int blitDepthRenderProgramH   = mBlitDepthRenderProgram.getProgramHandle();

    mBlitDepthRenderSizeH         = GLES31.glGetUniformLocation( blitDepthRenderProgramH, "u_Size");

    // NORMAL PROGRAM //////////////////////////////////////

    final InputStream normalVertexStream   = resources.openRawResource(R.raw.normal_vertex_shader);

    final InputStream normalFragmentStream = resources.openRawResource(R.raw.normal_fragment_shader);

    try

      {

      mNormalProgram = new DistortedProgram(normalVertexStream,normalFragmentStream, Distorted.GLSL_VERSION, Distorted.GLSL_VERSION, Distorted.GLSL);

      }

    catch(Exception e)

      {

      Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile NORMAL program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

      }

    int normalProgramH = mNormalProgram.getProgramHandle();

    mNormalMVPMatrixH  = GLES31.glGetUniformLocation( normalProgramH, "u_MVPMatrix");

    }

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

  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;

      }

    }

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

  EffectQueuePostprocess getPostprocess()

    {

    return mP;

    }

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

  void newNode(DistortedNode node)

    {

    mM.newNode(node);

    mF.newNode(node);

    mV.newNode(node);

    mP.newNode(node);

    }

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

  private void displayNormals(MeshObject mesh)

    {

    GLES31.glBindBufferBase(GLES31.GL_TRANSFORM_FEEDBACK_BUFFER, 0, mesh.mAttTFO[0]);

    GLES31.glBeginTransformFeedback( GLES31.GL_POINTS);

    DistortedRenderState.switchOffDrawing();

    GLES31.glDrawArrays( GLES31.GL_POINTS, 0, mesh.numVertices);

    DistortedRenderState.restoreDrawing();

    GLES31.glEndTransformFeedback();

    GLES31.glBindBufferBase(GLES31.GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);

    mNormalProgram.useProgram();

    GLES31.glUniformMatrix4fv(mNormalMVPMatrixH, 1, false, mM.getMVP() , 0);

    GLES31.glBindBuffer(GLES31.GL_ARRAY_BUFFER, mesh.mAttTFO[0]);

    GLES31.glVertexAttribPointer(mNormalProgram.mAttribute[0], MeshObject.POS_DATA_SIZE, GLES31.GL_FLOAT, false, 0, 0);

    GLES31.glBindBuffer(GLES31.GL_ARRAY_BUFFER, 0);

    GLES31.glLineWidth(8.0f);

    GLES31.glDrawArrays(GLES31.GL_LINES, 0, 2*mesh.numVertices);

    }

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

  void drawPriv(float halfW, float halfH, MeshObject mesh, DistortedOutputSurface surface, long currTime, float marginInPixels)

    {

    float halfZ = halfW*mesh.zFactor;

    mM.compute(currTime);

    mV.compute(currTime,halfW,halfH,halfZ);

    mF.compute(currTime,halfW,halfH);

    mP.compute(currTime);

    GLES31.glViewport(0, 0, surface.mWidth, surface.mHeight );

    mMainProgram.useProgram();

    GLES31.glUniform1i(mMainTextureH, 0);

    GLES31.glBindBuffer(GLES31.GL_ARRAY_BUFFER, mesh.mAttVBO[0]);

    GLES31.glVertexAttribPointer(mMainProgram.mAttribute[0], MeshObject.POS_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET0);

    GLES31.glVertexAttribPointer(mMainProgram.mAttribute[1], MeshObject.NOR_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET1);

    GLES31.glVertexAttribPointer(mMainProgram.mAttribute[2], MeshObject.TEX_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET2);

    GLES31.glBindBuffer(GLES31.GL_ARRAY_BUFFER, 0);

    mM.send(surface,halfW,halfH,halfZ,marginInPixels);

    mV.send();

    mF.send();

    GLES31.glDrawArrays(GLES31.GL_TRIANGLE_STRIP, 0, mesh.numVertices);

    if( mesh.mShowNormals ) displayNormals(mesh);

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public static void blitPriv(DistortedOutputSurface surface)

    {

    mBlitProgram.useProgram();

    GLES31.glViewport(0, 0, surface.mWidth, surface.mHeight );

    GLES31.glUniform1i(mBlitTextureH, 0);

    GLES31.glUniform1f( mBlitDepthH , 1.0f-surface.mNear);

    GLES31.glVertexAttribPointer(mBlitProgram.mAttribute[0], 2, GLES31.GL_FLOAT, false, 0, mQuadPositions);

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

    }

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

  static void blitDepthPriv(DistortedOutputSurface surface, float corrW, float corrH)

    {

    mBlitDepthProgram.useProgram();

    GLES31.glViewport(0, 0, surface.mWidth, surface.mHeight );

    GLES31.glUniform2f(mBlitDepthSizeH, surface.mWidth, surface.mHeight);

    GLES31.glVertexAttribPointer(mBlitDepthProgram.mAttribute[0], 2, GLES31.GL_FLOAT, false, 0, mQuadPositions);

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

    }

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

// render all the transparent pixels from the per-pixel linked lists. This is in the 'merge

// postprocessing buckets' stage.

  static void blitDepthRenderPriv(DistortedOutputSurface surface, float corrW, float corrH)

    {

    mBlitDepthRenderProgram.useProgram();

    //analyzeBuffer(surface.mWidth, surface.mHeight);

    GLES31.glViewport(0, 0, surface.mWidth, surface.mHeight );

    GLES31.glUniform2f(mBlitDepthRenderSizeH, surface.mWidth, surface.mHeight);

    GLES31.glVertexAttribPointer(mBlitDepthRenderProgram.mAttribute[0], 2, GLES31.GL_FLOAT, false, 0, mQuadPositions);

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

    // reset atomic counter to 0

    GLES31.glBindBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER, mAtomicCounter[0] );

    mAtomicBuf = (ByteBuffer)GLES31.glMapBufferRange( GLES31.GL_ATOMIC_COUNTER_BUFFER, 0, 4,

                                                      GLES31.GL_MAP_READ_BIT|GLES31.GL_MAP_WRITE_BIT);

    if( mAtomicBuf!=null )

      {

      mAtomicIntBuf = mAtomicBuf.order(ByteOrder.nativeOrder()).asIntBuffer();

      int counter = mAtomicIntBuf.get(0);

      mAtomicIntBuf.put(0, 0);

      //android.util.Log.e("counter", "now = "+counter+" w="+surface.mWidth+" h="+surface.mHeight

      //                             +" diff="+(counter-surface.mWidth*surface.mHeight));

      }

    else

      {

      android.util.Log.e("counter", "failed to map buffer");

      }

    GLES31.glUnmapBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER);

    GLES31.glBindBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER, 0);

    }

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

  private static void analyzeBuffer(int w, int h)

    {

    int ptr, index;

    int errors = 0;

    GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, mLinkedListSSBO[0]);

    mBuf = (ByteBuffer)GLES31.glMapBufferRange(GLES31.GL_SHADER_STORAGE_BUFFER, 0, mBufferSize*4, GLES31.GL_MAP_READ_BIT);

    mIntBuf = mBuf.order(ByteOrder.nativeOrder()).asIntBuffer();

    for(int col=0; col<w; col++)

      for(int row=0; row<h; row++)

        {

        index = col+row*w;

        ptr = mIntBuf.get(index);

        if( ptr!=0 )

          {

          if( ptr>0 && ptr<mBufferSize )

            {

            ptr = mIntBuf.get(ptr);

            if( ptr != index )

              {

              android.util.Log.d("surface", "col="+col+" row="+row+" val="+ptr+" expected: "+index);

              errors++;

              }

            }

          else

            {

            android.util.Log.d("surface", "overflow!");

            }

          }

        }

    GLES31.glUnmapBuffer(GLES31.GL_SHADER_STORAGE_BUFFER);

    GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, 0);

    if( errors>0 ) android.util.Log.e("surface", "errors: "+errors);

    }

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

  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;

    mLinkedListSSBO[0]= -1;

    mAtomicCounter[0] = -1;

    }

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

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

 */

  @SuppressWarnings("unused")

  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 our queues. Nothing will happen if 'el' is already in the list.

 * 

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

 */

  @SuppressWarnings("unused")

  public void registerForMessages(EffectListener el)

    {

    mM.registerForMessages(el);

    mV.registerForMessages(el);

    mF.registerForMessages(el);

    mP.registerForMessages(el);

    }

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

/**

 * Removes the calling class from the list of Listeners that get notified if something happens to Effects in our queue.

 * 

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

 */

  @SuppressWarnings("unused")

  public void deregisterForMessages(EffectListener el)

    {

    mM.deregisterForMessages(el);

    mV.deregisterForMessages(el);

    mF.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);

    }

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

/**

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

 * 

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

 * @return Number of effects aborted.

 */

  public int abortByType(EffectType 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 an Effect by its ID.

 *

 * @param id the Id of the Effect to be removed, as returned by getID().

 * @return Number of effects aborted.

 */

  public int abortById(long id)

    {

    long type = id&EffectType.MASK;

    if( type == EffectType.MATRIX.ordinal()      ) return mM.removeById(id);

    if( type == EffectType.VERTEX.ordinal()      ) return mV.removeById(id);

    if( type == EffectType.FRAGMENT.ordinal()    ) return mF.removeById(id);

    if( type == EffectType.POSTPROCESS.ordinal() ) return mP.removeById(id);

    return 0;

    }

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

/**

 * Aborts a single Effect.

 * 

 * @param effect the Effect we want to abort.

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

 */

  public int abortEffect(Effect effect)

    {

    switch(effect.getType())

      {

      case MATRIX     : return mM.removeEffect(effect);

      case VERTEX     : return mV.removeEffect(effect);

      case FRAGMENT   : return mF.removeEffect(effect);

      case POSTPROCESS: return mP.removeEffect(effect);

      default         : return 0;

      }

    }

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

/**

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

 * 

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

 * @return number of Effects aborted.

 */

  public int abortByName(EffectName name)

    {

    switch(name.getType())

      {

      case MATRIX     : return mM.removeByName(name);

      case VERTEX     : return mV.removeByName(name);

      case FRAGMENT   : return mF.removeByName(name);

      case POSTPROCESS: return mP.removeByName(name);

      default                : return 0;

      }

    }

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

/**

 * Returns the maximum number of effects of a given type that can be simultaneously applied to a

 * single (InputSurface,MeshObject) combo.

 *

 * @param type {@link EffectType}

 * @return The maximum number of effects of a given type.

 */

  @SuppressWarnings("unused")

  public static int getMax(EffectType type)

    {

    return EffectQueue.getMax(type.ordinal());

    }

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

/**

 * Sets the maximum number of 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 type {@link EffectType}

 * @param max new maximum number of simultaneous 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.

 */

  @SuppressWarnings("unused")

  public static boolean setMax(EffectType type, int max)

    {

    return EffectQueue.setMax(type.ordinal(),max);

    }

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

/**

 * Add a new Effect to our queue.

 *

 * @param effect The Effect to add.

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

 */

  public boolean apply(Effect effect)

    {

    switch(effect.getType())

      {

      case MATRIX      : return mM.add(effect);

      case VERTEX      : return mV.add(effect);

      case FRAGMENT    : return mF.add(effect);

      case POSTPROCESS : return mP.add(effect);

      }

    return false;

    }

  }