Distorted Android

      mProgram1 = mPrograms.get(mIndex1);

      mProgram2 = mPrograms.get(mIndex2);

      mProgram1 = mPrograms.get(mIndex1);

      mProgram2 = mPrograms.get(mIndex2);

import org.distorted.library.program.*;

 * @throws FragmentCompilationException Fragment Shader failed to compile

 * @throws VertexCompilationException   Vertex Shader failed to compile

 * @throws VertexUniformsException      Too many uniforms in the Vertex Shader

 * @throws FragmentUniformsException    Too many uniforms in the Fragment Shader

 * @throws LinkingException             Shader failed to link

  throws FragmentCompilationException,VertexCompilationException,VertexUniformsException,FragmentUniformsException,LinkingException

    GLSL = ( (configurationInfo.reqGlEsVersion>>16)>=3 ? 300 : 100 );

    GLSL_VERSION= (GLSL==100 ? "#version 100\n" : "#version 300 es\n");

 * Call this so that the Library can release its internal data structures.

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

/**

 * Return 2 or 3 depending if we have OpenGL Es 2.0 or 3.x context created.

 */

  public static int getGlVersion()

    {

    return GLSL == 300 ? 3:2;

    }

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;

  throws FragmentCompilationException,VertexCompilationException,VertexUniformsException,FragmentUniformsException,LinkingException

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

                                         enabledEffectV, enabledEffectF, Distorted.GLSL, feedback);

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

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

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

    if( Distorted.GLSL >= 300 )

      {

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

      }

    else

      {

      mesh.mVertAttribs.position(0);

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

      mesh.mVertAttribs.position(MeshObject.POS_DATA_SIZE);

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

      mesh.mVertAttribs.position(MeshObject.POS_DATA_SIZE+MeshObject.NOR_DATA_SIZE);

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

      }

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

  void prepareDebug(long time) {}

  void renderDebug(long time)  {}

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

/**

 * Create new offscreen Framebuffer with COLOR0 attachment only.

 *

 * @param width Width of the COLOR0 attachment.

 * @param height Height of the COLOR0 attachment.

 */

  @SuppressWarnings("unused")

  public DistortedFramebuffer(int width, int height)

    {

    super(width,height,NOT_CREATED_YET, 1, NO_DEPTH_NO_STENCIL,NOT_CREATED_YET,TYPE_USER);

    }

// can make this logarithmic but the typical number of children is very small anyway

  static void addSorted(ArrayList<DistortedNode> mChildren, DistortedNode newChild)

      if( mChildren.get(i).getPostprocessQueue().getID() > bucket ) break;

      android.util.Log.d("NODE", "ERROR!! this NodeData cannot possibly contain a non-null FBO!! "+newData.mFBO.getID() );

      surface.setAsOutput(currTime);

      surface.setAsOutput(currTime);

      DistortedMaster.addSorted(mParent.mChildren,this);

      DistortedMaster.addSorted(children,this);

                     DistortedMaster.addSorted(mChildren,job.node);

                     DistortedMaster.addSorted(mChildren,job.node);

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

      object = mDoneList.removeFirst();

      mToDoMap.put(object.mID, object.new Job(object,JOB_CREATE) );

      object.recreate();

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

// 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 java.util.ArrayList;

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

/**

 * Return unique IDs of objects in a lazy way. When we create a new Object, return the lowest unused

 * integer. When an objects gets deleted, its ID then gets marked unused. We do not try to 'collapse'

 * unused holes.

 */

class DistortedObjectCounter

  {

  private ArrayList<Integer> mUsed;

  private int mFirstUnused;

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

  DistortedObjectCounter()

    {

    mUsed        = new ArrayList<>();

    mFirstUnused = 0;

    }

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

  int returnNext()

    {

    int size = mUsed.size();

    if( mFirstUnused<size )

      {

      int ret = mFirstUnused;

      mUsed.set(mFirstUnused,1);

      int found=-1;

      for(int i=mFirstUnused+1; i<size; i++ )

        {

        if( mUsed.get(i)==0 )

          {

          found = i;

          break;

          }

        }

      mFirstUnused = found<0 ? size : found;

      return ret;

      }

    mUsed.add(1);

    mFirstUnused++;

    return size;

    }

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

  void release(int objID)

    {

    int size = mUsed.size();

    if( objID<size && objID>=0 && mUsed.get(objID)==1 )

      {

      mUsed.set(objID,0);

      if( objID<mFirstUnused ) mFirstUnused = objID;

      }

    }

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

  void releaseAll()

    {

    mUsed.clear();

    mFirstUnused = 0;

    }

  }

//////////// DEBUG FLAGS /////////////////////////////////////////////

/**

 * When rendering a Screen, show FPS in the upper-left corner?

 */

public static final int DEBUG_FPS = 1;

//////////// END DEBUG FLAGS /////////////////////////////////////////

  private static DistortedOutputSurface[] mBuffer = new DistortedOutputSurface[EffectQuality.LENGTH];

  private int mDebugLevel;

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

  abstract void prepareDebug(long time);

  abstract void renderDebug(long time);

    mDebugLevel = 0;

  private static void createBuffers(int width, int height, float near)

    for(int j=0; j<EffectQuality.LENGTH; j++)

      mBuffer[j] = null;

// set of them) so before we use them for output, we need to adjust the Vieport as if they were

  private static void cloneViewport(DistortedOutputSurface from)

    if( mBuffer[0].mWidth != from.mWidth )

      if( currBucket==0 ) numRenders += child1.draw(time,this);

        if( mBuffer[0]==null ) createBuffers(mWidth,mHeight,mNear);

          if( lastBucket!=0 )

          cloneViewport(this);

        }

      }

/**

 * Make the library show various debugging information.

 * <p>

 * Currently only DEBUG_FPS - show FPS in the upper-left corner of every Screen - is defined.

 *

 * @param bitmask 0, or a bitmask of DEBUG_** flags to enable (currently only DEBUG_FPS defined)

 */

  public void setDebug(int bitmask)

    {

    if( this instanceof DistortedScreen )

      mDebugLevel = bitmask;

    }

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

    if( mDebugLevel!=0 ) prepareDebug(time);

    if( mDebugLevel != 0 ) renderDebug(time);

      DistortedRenderState.colorDepthStencilOn();

      GLES31.glClearColor(mClearR, mClearG, mClearB, mClearA);

      GLES31.glClearDepthf(mClearDepth);

      GLES31.glClearStencil(mClearStencil);

      GLES31.glClear(mClear);

      DistortedRenderState.colorDepthStencilRestore();

/*

      if( mSSBO[0]>=0 )

        {

        // yes, this DOES keep on working when 'value' overflows into negative territory.

        int value = mIntBuffer.get(FRAME_DELAY*mSurfaceID+mLastIndex);

        if( value-mLastValue[mLastIndex]!=mLastDiff )

          {

          android.util.Log.d("surface", "id " + mSurfaceID +

                             (mType == TYPE_USER ? " USER" : (mType == TYPE_SYST ? " SYST" : " TREE")) +

                             " viewport: (" + mWidth + "x" + mHeight + ") last frame: " + (value - mLastValue[mLastIndex])

                             + " avg: " + (mAvgSum/RUNNING_AVERAGE)

                            );

          }

        mLastDiff = value-mLastValue[mLastIndex];

        mLastValue[mLastIndex] = value;

        mAvgSum += (mLastDiff-mRunningAvg[mAvgIndex]);

        mRunningAvg[mAvgIndex] = mLastDiff;

        if( ++mAvgIndex>=RUNNING_AVERAGE ) mAvgIndex =0;

        }

      if( ++mLastIndex >= FRAME_DELAY ) mLastIndex=0;

*/

    if( mBuffer[0]!=null )

                     DistortedMaster.addSorted(mChildren,job.node);

                     DistortedMaster.addSorted(mChildren,job.node);

// Copyright 2016 Leszek Koltunski                                                               //

public class DistortedScreen extends DistortedOutputSurface

  private String fpsString = "";

  private boolean mInitialized;

// here we don't manage underlying OpenGL assets ourselves

  void create()   {}

  void delete()   {}

  void recreate() {}

  private void initialize()

    mInitialized=true;

    }

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

  void prepareDebug(long time)

    {

    if( !mInitialized ) initialize();

    if( lastTime==0 ) lastTime = time;

    currDuration++;

    if (currDuration >= NUM_FRAMES) currDuration = 0;

    durations[NUM_FRAMES] += ((time - lastTime) - durations[currDuration]);

    durations[currDuration] = time - lastTime;

    fpsString = "" + ((int)(10000.0f*NUM_FRAMES/durations[NUM_FRAMES]))/10.0f;

    mPaint.setColor(0xffffffff);

    fpsCanvas.drawRect(0, 0, fpsW, fpsH, mPaint);

    mPaint.setColor(0xff000000);

    fpsCanvas.drawText(fpsString, fpsW/2, 0.75f*fpsH, mPaint);

    fpsTexture.setTexture(fpsBitmap);

    lastTime = time;

    }

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

  void renderDebug(long time)

    {

    if (fpsTexture.setAsInput())

      {

      setAsOutput(time);

      GLES31.glColorMask(true,true,true,true);

      GLES31.glDepthMask(false);

      GLES31.glDisable(GLES31.GL_STENCIL_TEST);

      GLES31.glDisable(GLES31.GL_DEPTH_TEST);

      fpsEffects.drawPriv(fpsW/2.0f, fpsH/2.0f, fpsMesh, this, time, 0);

      }

    }

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

// PUBLIC API

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

/**

 * Create a new Screen.

 * <p>

 * Has to be followed by a 'resize()' to set the size.

 */

  public DistortedScreen()

    {

    // Screen also has to be created (3rd arg 'NOT_CREATED_YET') because of the SSBO inside OutputSurface.

    super(0,0,NOT_CREATED_YET,1,DEPTH_NO_STENCIL,0,TYPE_USER);

    mInitialized = false;

  }

 * Assumed to hold GLSL 'version 300 es' source.

precision lowp float;

#if __VERSION__ != 100

#define TEXTURE texture

#define FRAG_COLOR fragColor

#else

varying vec2 v_TexCoordinate; // Interpolated texture coordinate per fragment.

#define TEXTURE texture2D

#define FRAG_COLOR gl_FragColor

#endif

  gl_FragDepth = TEXTURE(u_DepthTexture,v_TexCoordinate).r;

  FRAG_COLOR   = TEXTURE(u_Texture     ,v_TexCoordinate);

precision lowp float;

#if __VERSION__ != 100

#else

attribute vec2 a_Position;    // Per-vertex position.

varying vec2 v_TexCoordinate; //

#endif

#if __VERSION__ != 100

#define TEXTURE texture

#define FRAG_COLOR fragColor

#else

varying vec2 v_TexCoordinate; // Interpolated texture coordinate per fragment.

#define TEXTURE texture2D

#define FRAG_COLOR gl_FragColor

#endif

  FRAG_COLOR = TEXTURE(u_Texture,v_TexCoordinate);

#if __VERSION__ != 100

#else

attribute vec2 a_Position;    // Per-vertex position.

varying vec2 v_TexCoordinate; //

#endif

#if __VERSION__ != 100

#define FRAG_COLOR fragColor

#else

#define FRAG_COLOR gl_FragColor

#endif

  FRAG_COLOR = vec4(1.0,0.0,0.0,1.0);

#if __VERSION__ != 100

#else

attribute vec3 a_Position;

#endif

  gl_Position = u_MVPMatrix*vec4( a_Position, 1.0);