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

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

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

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

 * class.

  private static DistortedProgram mMainProgram;

  private static int mMainTextureH;

  static

    {

    int len = EffectNames.size();

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

      {

      mEffectEnabled[i] = false;

      }

    }

  private static DistortedProgram mBlitProgram;

  private static int mBlitTextureH;

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

  private static int mDebugMVPMatrixH;

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

  private EffectQueueFragment    mF;

  private EffectQueueVertex      mV;

  throws FragmentCompilationException,VertexCompilationException,VertexUniformsException,FragmentUniformsException,LinkingException

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

    String mainFragHeader= Distorted.GLSL_VERSION;

    EffectTypes type;

    boolean foundF = false;

    boolean foundV = false;

        {

        name = EffectNames.getName(i);

        type = EffectNames.getType(i);

        if( type == EffectTypes.VERTEX )

          {

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

          foundV = true;

          }

        else if( type == EffectTypes.FRAGMENT )

          {

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

          foundF = true;

          }

        }

    mainFragHeader += ("#define NUM_FRAGMENT " + ( foundF ? getMaxFragment() : 0 ) + "\n");

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

    mMainProgram = new DistortedProgram(mainVertStream,mainFragStream, mainVertHeader, mainFragHeader, Distorted.GLSL, feedback);

    EffectQueueMatrix.getUniforms(mainProgramH);

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

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

      {

    catch(Exception e)

      {

      android.util.Log.e("EFFECTS", "exception trying to compile BLIT program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

      }

    int blitProgramH = mBlitProgram.getProgramHandle();

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

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

      {

    catch(Exception e)

      {

      android.util.Log.e("EFFECTS", "exception trying to compile DEBUG program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

      }

    int debugProgramH = mDebugProgram.getProgramHandle();

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

      matrixCloned = true;

      }

    else

      {

      }

      {

      mV = d.mV;

      vertexCloned = true;

      }

    else

      {

      }

      {

      mF = d.mF;

      fragmentCloned = true;

      {

      }

    }

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

    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;

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

      if( wx>maxx ) maxx = wx;

      if( wy<miny ) miny = wy;

      if( wy>maxy ) maxy = wy;

    mDebugProgram.useProgram();

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

    GLES30.glUniformMatrix4fv(mDebugMVPMatrixH, 1, false, mMVPMatrix , 0);

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

  private void displayTransformFeedback(MeshObject mesh)

    {

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

    GLES30.glBeginTransformFeedback( GLES30.GL_POINTS);

    DistortedRenderState.switchOffDrawing();

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

    DistortedRenderState.restoreDrawing();

    int error = GLES30.glGetError();

      if( error != GLES30.GL_NO_ERROR )

        {

        throw new RuntimeException("DrawArrays: glError 0x" + Integer.toHexString(error));

        }

    Buffer mappedBuffer =  GLES30.glMapBufferRange(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, 0, 4*size, GLES30.GL_MAP_READ_BIT);

    FloatBuffer fb = ((ByteBuffer) mappedBuffer).order(ByteOrder.nativeOrder()).asFloatBuffer();

    String msg = "";

    for(int i=0; i<size; i++) msg += (" "+fb.get(i));

    android.util.Log.d( "Feedback", msg);

    GLES30.glUnmapBuffer(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER);

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

    }

    mM.compute(currTime);

    mV.compute(currTime);

    mF.compute(currTime);

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

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

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

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

    GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, 0 );

    mV.send(halfW,halfH,halfZ);

    displayTransformFeedback(mesh);

    EffectQueueVertex.sendZero();

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

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

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

    GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, 0 );

    /// DEBUG ONLY //////

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

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

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

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

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

    mV = null;

    mF = null;

    mNextID = 0;

    int len = EffectNames.size();

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

      {

      mEffectEnabled[i] = false;

      }

// PUBLIC API

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

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

/**

    releasePriv();

    }

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

/**

 *

 * @return ID of the object.

/**

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

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

 */

    mF.registerForMessages(el);

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

 */

    mF.deregisterForMessages(el);

    mM.deregisterForMessages(el);

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

/**

 * @return Number of effects aborted.

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

    }

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

/**

 * @return Number of effects aborted.

    {

    switch(type)

      case VERTEX     : return mV.abortAll(true);

      case FRAGMENT   : return mF.abortAll(true);

      default         : return 0;

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

/**

 * Aborts a single Effect.

 * 

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

    {

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

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

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

    }

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

/**

    {

    switch(name.getType())

      case VERTEX     : return mV.removeByType(name);

      case FRAGMENT   : return mF.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.

 */

    {

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

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

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

    }

/**

 * Enables a given Effect.

 * <p>

 * By default, all effects are disabled. One has to explicitly enable each effect one intends to use.

 * This needs to be called BEFORE shaders get compiled, i.e. before the call to Distorted.onCreate().

 * The point: by enabling only the effects we need, we can optimize the shaders.

 *

 * @param name Name of the Effect to enable.

 */

  public static void enableEffect(EffectNames name)

    {

    mEffectEnabled[name.ordinal()] = true;

    }

/**

 * Returns the maximum number of Matrix effects.

 *

 * @return The maximum number of Matrix effects

 */

    {

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

    }

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

/**

 * Returns the maximum number of Vertex effects.

 *

 * @return The maximum number of Vertex effects

 */

    {

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

    }

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

/**

 * Returns the maximum number of Fragment effects.

 *

 * @return The maximum number of Fragment effects

 */

    {

    return EffectQueue.getMax(EffectTypes.FRAGMENT.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.

 */

    {

    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.

 */

    {

    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.

 */

    {

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

    }

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

// Individual effect functions.