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.app.ActivityManager;

import android.content.Context;

import android.content.pm.ConfigurationInfo;

import android.content.res.Resources;

import android.opengl.GLES30;

import android.opengl.GLES31;

import android.util.Log;

import org.distorted.library.R;

import org.distorted.library.effect.Effect;

import org.distorted.library.effectqueue.EffectQueue;

import org.distorted.library.effectqueue.EffectQueuePostprocess;

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.FragmentEffect;

import org.distorted.library.effect.PostprocessEffect;

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.effectqueue.EffectQueueVertex;

import org.distorted.library.mesh.DeferredJobs;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.message.EffectMessageSender;

import org.distorted.library.program.DistortedProgram;

import org.distorted.library.program.VertexCompilationException;

import org.distorted.library.type.Dynamic;

import java.io.InputStream;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import java.nio.IntBuffer;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

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

/**

 * A singleton class used to control various global dialog_settings.

 */

public class DistortedLibrary

  {

  /**

   * When creating an instance of a DistortedTexture from another instance, clone the Bitmap that's

   * backing up our DistortedTexture.

   * <p>

   * This way we can have two DistortedTextures, both backed up by the same Bitmap, to which we can

   * apply different effects. Used in the copy constructor.

   */

  public static final int CLONE_SURFACE = 0x1;

  /**

   * When creating an instance of a DistortedEffects from another instance, clone the Matrix Effects.

   * <p>

   * This way we can have two different DistortedEffects sharing the MATRIX queue.

   */

  public static final int CLONE_MATRIX = 0x2;

  /**

   * When creating an instance of a DistortedEffects from another instance, clone the Vertex Effects.

   * <p>

   * This way we can have two different DistortedEffects sharing the VERTEX queue.

   */

  public static final int CLONE_VERTEX  = 0x4;

  /**

   * When creating an instance of a DistortedEffects from another instance, clone the Fragment Effects.

   * <p>

   * This way we can have two different DistortedEffects sharing the FRAGMENT queue.

   */

  public static final int CLONE_FRAGMENT= 0x8;

   /**

   * When creating an instance of a DistortedEffects from another instance, clone the PostProcess Effects.

   * <p>

   * This way we can have two different DistortedEffects sharing the POSTPROCESS queue.

   */

  public static final int CLONE_POSTPROCESS= 0x10;

  /**

   * When creating an instance of a DistortedNode from another instance, clone the children Nodes.

   * <p>

   * This is mainly useful for creating many similar sub-trees and rendering then at different places

   * on the screen with (optionally) different Effects.

   */

  public static final int CLONE_CHILDREN= 0x20;

  /**

   * When creating a DistortedScreen (which needs to have mFBOQueueSize FBOs attached), pass this

   * constant for 'numOfFBOs' and the number of backing FBOs will be taken from 'mFBOQueueSize'

   * (the value of which is most likely unknown at the time of creation of the Screen)

   */

  public static final int WAIT_FOR_FBO_QUEUE_SIZE = -1;

  /**

   * Work around bugs in ARM Mali driver by, instead to a single FBO, rendering to a circular queue

   * of mFBOQueueSize FBOs. (otherwise we sometimes get a 'full pipeline flush' and the end result

   * might be missing part of the Objects)

   *

   * This bug only exists on Mali driver r12. (or more precisely it's there in r12 but fixed in r22)

   *

   * https://community.arm.com/graphics/f/discussions/10285/opengl-es-3-1-on-mali-t880-flashes

   */

  private static int mFBOQueueSize;

  private static int mGLSL;

  private static String mGLSL_VERSION;

  private static boolean mOITCompilationAttempted, mNeedsTransformFeedback;

  private static int mMaxTextureSize         = Integer.MAX_VALUE;

  private static int mMaxNumberOfVerUniforms = Integer.MAX_VALUE;

  private static int mMaxNumberOfFraUniforms = Integer.MAX_VALUE;

  private static boolean mBuggyUBOs;

  private static String mVendor, mVersion, mRenderer;

  private static boolean mFastCompilationTF;

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

  /// MAIN PROGRAM ///

  private static DistortedProgram mMainProgram;

  private static int mMainTextureH;

  private static int mTransformFeedbackH;

  /// NORMAL PROGRAM /////

  private static DistortedProgram mNormalProgram;

  private static int mNormalProjectionH;

  /// MAIN OIT PROGRAM ///

  private static DistortedProgram mMainOITProgram;

  private static int mMainOITTextureH;

  private static int mMainOITSizeH;

  private static int mMainOITNumRecordsH;

  /// BLIT PROGRAM ///

  private static DistortedProgram mBlitProgram;

  private static int mBlitTextureH;

  private static int mBlitDepthH;

  private static final FloatBuffer mQuadPositions;

  /// FULL PROGRAM ///

  private static DistortedProgram mFullProgram;

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

  private static int mBlitDepthDepthTextureH;

  private static int mBlitDepthTexCorrH;

  /// Program Handles ///

  private static int mMainProgramH, mFullProgramH, mMainOITProgramH;

  /// OIT SSBO BUFFER ///

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

  private static int[] mAtomicCounter;

  private static int   mCurrBuffer;

  static

    {

    mLinkedListSSBO[0]= -1;

    mCurrBuffer       =  0;

    }

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

  // meaning: allocate 1.0 screenful of places for transparent

  // fragments in the SSBO backing up the OIT render method.

  private static float mBufferSize=1.0f;

  /// OIT CLEAR PROGRAM ///

  private static DistortedProgram mOITClearProgram;

  private static int mOITClearDepthH;

  private static int mOITClearTexCorrH;

  private static int mOITClearSizeH;

  /// OIT BUILD PROGRAM ///

  private static DistortedProgram mOITBuildProgram;

  private static int mOITBuildTextureH;

  private static int mOITBuildDepthTextureH;

  private static int mOITBuildDepthH;

  private static int mOITBuildTexCorrH;

  private static int mOITBuildSizeH;

  private static int mOITBuildNumRecordsH;

  /// OIT COLLAPSE PROGRAM ///

  private static DistortedProgram mOITCollapseProgram;

  private static int mOITCollapseDepthTextureH;

  private static int mOITCollapseDepthH;

  private static int mOITCollapseTexCorrH;

  private static int mOITCollapseSizeH;

  /// OIT RENDER PROGRAM ///

  private static DistortedProgram mOITRenderProgram;

  private static int mOITRenderDepthH;

  private static int mOITRenderTexCorrH;

  private static int mOITRenderSizeH;

  /// END PROGRAMS //////

  /**

   * Every application using the library must implement this interface so that the library can send

   * it exceptions that arise. The exceptions may come at any time, for example the library will

   * compile its OIT problem only on the first attempt to use the OIT

   * Those will mainly be hardware-related: shaders do not compile on particular hardware, the required

   * OpenGL ES 3.0 is not supported, etc.

   */

  public interface ExceptionListener

    {

    void distortedException(Exception ex);

    }

  private static ExceptionListener mListener;

  private static Resources mResources;

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

// private: hide this from Javadoc

  private DistortedLibrary()

    {

    }

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

  private static void createMainProgram()

    {

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

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

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

    int numF = FragmentEffect.getNumEnabled();

    int numV = VertexEffect.getNumEnabled();

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

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

    mainVertHeader += "#define MAX_COMPON " + MeshBase.getMaxEffComponents() + "\n";

    if( MeshBase.getUseCenters() ) mainVertHeader += "#define COMP_CENTERS\n";

    if( mBuggyUBOs )               mainVertHeader += "#define BUGGY_UBOS\n";

    String enabledEffectV= VertexEffect.getGLSL();

    String enabledEffectF= FragmentEffect.getGLSL();

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

    try

      {

      mMainProgram = new DistortedProgram(mainVertStream, mainFragStream, mainVertHeader,

                                          mainFragHeader, enabledEffectV, enabledEffectF,

                                          mGLSL, mNeedsTransformFeedback ? feedback : null );

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    mMainProgramH = mMainProgram.getProgramHandle();

    EffectQueue.getUniforms(mMainProgramH,0);

    MeshBase.getUniforms(mMainProgramH,0);

    mMainTextureH= GLES30.glGetUniformLocation( mMainProgramH, "u_Texture");

    mTransformFeedbackH= GLES30.glGetUniformLocation( mMainProgramH, "u_TransformFeedback");

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

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

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

    try

      {

      mBlitProgram = new DistortedProgram(blitVertStream,blitFragStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);

      }

    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  = GLES30.glGetUniformLocation( blitProgramH, "u_Texture");

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

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

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

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

    try

      {

      mBlitDepthProgram = new DistortedProgram(blitDepthVertStream,blitDepthFragStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);

      }

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

    mBlitDepthTextureH      = GLES30.glGetUniformLocation( blitDepthProgramH, "u_Texture");

    mBlitDepthDepthTextureH = GLES30.glGetUniformLocation( blitDepthProgramH, "u_DepthTexture");

    mBlitDepthTexCorrH      = GLES30.glGetUniformLocation( blitDepthProgramH, "u_TexCorr");

    }

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

  private static void createNormalProgram(Resources resources)

    {

    // 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, mGLSL_VERSION, mGLSL_VERSION, mGLSL);

      }

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

    mNormalProjectionH = GLES30.glGetUniformLocation( normalProgramH, "u_Projection");

    }

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

  private static void createFullProgram(Resources resources)

    {

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

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

    int numV = VertexEffect.getAllEnabled();

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

    String fullFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " +                                         0   + "\n");

    fullVertHeader += "#define MAX_COMPON " + MeshBase.getMaxEffComponents() + "\n";

    if( MeshBase.getUseCenters() ) fullVertHeader += "#define COMP_CENTERS\n";

    if( mBuggyUBOs )               fullVertHeader += "#define BUGGY_UBOS\n";

    String enabledEffectV= VertexEffect.getAllGLSL();

    String enabledEffectF= "{}";

    fullVertHeader += "#define PREAPPLY\n";

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

    try

      {

      mFullProgram = new DistortedProgram(fullVertStream, fullFragStream, fullVertHeader, fullFragHeader,

                                          enabledEffectV, enabledEffectF, mGLSL, feedback);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    mFullProgramH = mFullProgram.getProgramHandle();

    EffectQueue.getUniforms(mFullProgramH,3);

    MeshBase.getUniforms(mFullProgramH,3);

    }

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

  private static void createOITProgram(Resources resources)

    {

    // MAIN OIT 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= mGLSL_VERSION + ("#define NUM_VERTEX "   + ( numV>0 ? getMax(EffectType.VERTEX  ) : 0 ) + "\n") + ("#define OIT\n");

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

    mainVertHeader += "#define MAX_COMPON " + MeshBase.getMaxEffComponents() + "\n";

    if( MeshBase.getUseCenters() ) mainVertHeader += "#define COMP_CENTERS\n";

    if( mBuggyUBOs )               mainVertHeader += "#define BUGGY_UBOS\n";

    String enabledEffectV= VertexEffect.getGLSL();

    String enabledEffectF= FragmentEffect.getGLSL();

    try

      {

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

                                             enabledEffectV, enabledEffectF, mGLSL, null);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    mMainOITProgramH = mMainOITProgram.getProgramHandle();

    EffectQueue.getUniforms(mMainOITProgramH,1);

    MeshBase.getUniforms(mMainOITProgramH,1);

    mMainOITTextureH    = GLES30.glGetUniformLocation( mMainOITProgramH, "u_Texture");

    mMainOITSizeH       = GLES30.glGetUniformLocation( mMainOITProgramH, "u_Size");

    mMainOITNumRecordsH = GLES30.glGetUniformLocation( mMainOITProgramH, "u_numRecords");

    // OIT CLEAR PROGRAM ////////////////////////////////////

    final InputStream oitClearVertStream = resources.openRawResource(R.raw.oit_vertex_shader);

    final InputStream oitClearFragStream = resources.openRawResource(R.raw.oit_clear_fragment_shader);

    try

      {

      mOITClearProgram = new DistortedProgram(oitClearVertStream,oitClearFragStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    int oitClearProgramH   = mOITClearProgram.getProgramHandle();

    mOITClearDepthH        = GLES30.glGetUniformLocation( oitClearProgramH, "u_Depth");

    mOITClearTexCorrH      = GLES30.glGetUniformLocation( oitClearProgramH, "u_TexCorr");

    mOITClearSizeH         = GLES30.glGetUniformLocation( oitClearProgramH, "u_Size");

    // OIT BUILD PROGRAM ////////////////////////////////////

    final InputStream oitBuildVertStream = resources.openRawResource(R.raw.oit_vertex_shader);

    final InputStream oitBuildFragStream = resources.openRawResource(R.raw.oit_build_fragment_shader);

    try

      {

      mOITBuildProgram = new DistortedProgram(oitBuildVertStream,oitBuildFragStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    int oitBuildProgramH   = mOITBuildProgram.getProgramHandle();

    mOITBuildTextureH      = GLES30.glGetUniformLocation( oitBuildProgramH, "u_Texture");

    mOITBuildDepthTextureH = GLES30.glGetUniformLocation( oitBuildProgramH, "u_DepthTexture");

    mOITBuildDepthH        = GLES30.glGetUniformLocation( oitBuildProgramH, "u_Depth");

    mOITBuildTexCorrH      = GLES30.glGetUniformLocation( oitBuildProgramH, "u_TexCorr");

    mOITBuildSizeH         = GLES30.glGetUniformLocation( oitBuildProgramH, "u_Size");

    mOITBuildNumRecordsH   = GLES30.glGetUniformLocation( oitBuildProgramH, "u_numRecords");

    // OIT COLLAPSE PROGRAM ///////////////////////////

    final InputStream oitCollapseVertStream = resources.openRawResource(R.raw.oit_vertex_shader);

    final InputStream oitCollapseFragStream = resources.openRawResource(R.raw.oit_collapse_fragment_shader);

    try

      {

      mOITCollapseProgram = new DistortedProgram(oitCollapseVertStream,oitCollapseFragStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    int oitCollapseProgramH   = mOITCollapseProgram.getProgramHandle();

    mOITCollapseDepthTextureH = GLES30.glGetUniformLocation( oitCollapseProgramH, "u_DepthTexture");

    mOITCollapseDepthH        = GLES30.glGetUniformLocation( oitCollapseProgramH, "u_Depth");

    mOITCollapseTexCorrH      = GLES30.glGetUniformLocation( oitCollapseProgramH, "u_TexCorr");

    mOITCollapseSizeH         = GLES30.glGetUniformLocation( oitCollapseProgramH, "u_Size");

    // OIT RENDER PROGRAM ///////////////////////////

    final InputStream oitRenderVertStream = resources.openRawResource(R.raw.oit_vertex_shader);

    final InputStream oitRenderFragStream = resources.openRawResource(R.raw.oit_render_fragment_shader);

    try

      {

      mOITRenderProgram = new DistortedProgram(oitRenderVertStream,oitRenderFragStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    int oitRenderProgramH   = mOITRenderProgram.getProgramHandle();

    mOITRenderDepthH        = GLES30.glGetUniformLocation( oitRenderProgramH, "u_Depth");

    mOITRenderTexCorrH      = GLES30.glGetUniformLocation( oitRenderProgramH, "u_TexCorr");

    mOITRenderSizeH         = GLES30.glGetUniformLocation( oitRenderProgramH, "u_Size");

    }

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

  private static void displayNormals(float[] projection, MeshBase mesh)

    {

    if( mNormalProgram==null )

      {

      try

        {

        createNormalProgram(mResources);

        }

      catch(Exception ex)

        {

        mListener.distortedException(ex);

        return;

        }

      }

    int num = mesh.getNumVertices();

    int tfo = mesh.getTFO();

    GLES30.glUniform1i(DistortedLibrary.mTransformFeedbackH, 1);

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

    GLES30.glBeginTransformFeedback( GLES30.GL_POINTS);

    InternalRenderState.switchOffDrawing();

    GLES30.glDrawArrays( GLES30.GL_POINTS, 0, num );

    InternalRenderState.restoreDrawing();

    GLES30.glEndTransformFeedback();

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

    GLES30.glUniform1i(DistortedLibrary.mTransformFeedbackH, 0);

    mNormalProgram.useProgram();

    GLES30.glUniformMatrix4fv(mNormalProjectionH, 1, false, projection, 0);

    mesh.bindTransformAttribs(mNormalProgram);

    GLES30.glLineWidth(8.0f);

    GLES30.glDrawArrays(GLES30.GL_LINES, 0, 2*num);

    mNormalProgram.stopUsingProgram();

    }

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

/**

 * Execute all VertexEffects and adjust all vertices

 *

 * @y.exclude

 */

  public static void adjustVertices(MeshBase mesh, EffectQueueVertex queue)

    {

    if( mFullProgram==null )

      {

      try

        {

        createFullProgram(mResources);

        }

      catch(Exception ex)

        {

        mListener.distortedException(ex);

        return;

        }

      }

    int num = mesh.getNumVertices();

    int tfo = mesh.getTFO();

    mFullProgram.useProgram();

    mesh.bindVertexAttribs(mFullProgram);

    queue.compute(1,0);

    queue.send(0.0f,mFullProgramH,3);

    mesh.send(mFullProgramH,3);

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

    GLES30.glBeginTransformFeedback( GLES30.GL_POINTS);

    InternalRenderState.switchOffDrawing();

    GLES30.glDrawArrays( GLES30.GL_POINTS, 0, num );

    InternalRenderState.restoreDrawing();

    GLES30.glEndTransformFeedback();

    mesh.copyTransformToVertex();

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

    mFullProgram.stopUsingProgram();

    }

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

  static void drawPrivOIT(DistortedEffects effects, MeshBase mesh, InternalOutputSurface surface, long currTime, long step)

    {

    if( mMainOITProgram!=null )

      {

      EffectQueue[] queues = effects.getQueues();

      EffectQueue.compute(queues, currTime, step);

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

      mMainOITProgram.useProgram();

      GLES30.glUniform1i(mMainOITTextureH, 0);

      GLES30.glUniform2ui(mMainOITSizeH, surface.mWidth, surface.mHeight);

      GLES30.glUniform1ui(mMainOITNumRecordsH, (int)(mBufferSize*surface.mWidth*surface.mHeight) );

      mesh.bindVertexAttribs(mMainOITProgram);

      mesh.send(mMainOITProgramH,1);

      float inflate     = mesh.getInflate();

      float distance    = surface.mDistance;

      float mipmap      = surface.mMipmap;

      float[] projection= surface.mProjectionMatrix;

      EffectQueue.send(queues, mMainOITProgramH, distance, mipmap, projection, inflate, 1 );

      GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, mesh.getNumVertices() );

      mMainOITProgram.stopUsingProgram();

      if( mesh.getShowNormals() ) displayNormals(projection,mesh);

      }

    }

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

  static void drawPriv(DistortedEffects effects, MeshBase mesh, InternalOutputSurface surface, long currTime, long step)

    {

    if( mMainProgram!=null )

      {

      EffectQueue[] queues = effects.getQueues();

      EffectQueue.compute(queues, currTime, step);

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

      mMainProgram.useProgram();

      GLES30.glUniform1i(DistortedLibrary.mMainTextureH, 0);

      mesh.bindVertexAttribs(DistortedLibrary.mMainProgram);

      mesh.send(mMainProgramH,0);

      float inflate     = mesh.getInflate();

      float distance    = surface.mDistance;

      float mipmap      = surface.mMipmap;

      float[] projection= surface.mProjectionMatrix;

      EffectQueue.send(queues, mMainProgramH, distance, mipmap, projection, inflate, 0 );

      GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, mesh.getNumVertices() );

      mMainProgram.stopUsingProgram();

      if( mesh.getShowNormals() ) displayNormals(projection,mesh);

      }

    }

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

  static void blitPriv(InternalOutputSurface surface)

    {

    if( mBlitProgram!=null )

      {

      mBlitProgram.useProgram();

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

      GLES30.glUniform1i(mBlitTextureH, 0);

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

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

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

      mBlitProgram.stopUsingProgram();

      }

    }

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

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

    {

    if( mBlitDepthProgram!=null )

      {

      mBlitDepthProgram.useProgram();

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

      GLES30.glUniform1i(mBlitDepthTextureH, 0);

      GLES30.glUniform1i(mBlitDepthDepthTextureH, 1);

      GLES30.glUniform2f(mBlitDepthTexCorrH, corrW, corrH );

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

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

      mBlitDepthProgram.stopUsingProgram();

      }

    }

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

// yes it is safe to be mixing 3.0 and 3.1 like that, senior members of the OpenGL discussions forum assert

  private static int printPreviousBuffer()

    {

    int counter = 0;

    ByteBuffer atomicBuf = (ByteBuffer)GLES30.glMapBufferRange( GLES31.GL_ATOMIC_COUNTER_BUFFER, 0, 4,

                                                                GLES30.GL_MAP_READ_BIT);

    if( atomicBuf!=null )

      {

      IntBuffer atomicIntBuf = atomicBuf.order(ByteOrder.nativeOrder()).asIntBuffer();

      counter = atomicIntBuf.get(0);

      }

    else

      {

      Log.e("effects", "print: failed to map atomic buffer");

      }

    GLES30.glUnmapBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER);

    return counter;

    }

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

  private static void zeroBuffer()

    {

    ByteBuffer atomicBuf = (ByteBuffer)GLES30.glMapBufferRange( GLES31.GL_ATOMIC_COUNTER_BUFFER, 0, 4,

                                                                GLES30.GL_MAP_WRITE_BIT|GLES30.GL_MAP_INVALIDATE_BUFFER_BIT);

    if( atomicBuf!=null )

      {

      IntBuffer atomicIntBuf = atomicBuf.order(ByteOrder.nativeOrder()).asIntBuffer();

      atomicIntBuf.put(0,0);

      }

    else

      {

      Log.e("effects", "zero: failed to map atomic buffer");

      }

    GLES30.glUnmapBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER);

    }

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

// reset atomic counter to 0

  static int zeroOutAtomic()

    {

    int counter = 0;

    if( mAtomicCounter==null )

      {

      mAtomicCounter = new int[mFBOQueueSize];

      GLES30.glGenBuffers(mFBOQueueSize,mAtomicCounter,0);

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

        {

        GLES30.glBindBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER, mAtomicCounter[i]);

        GLES30.glBufferData(GLES31.GL_ATOMIC_COUNTER_BUFFER, 4, null, GLES30.GL_DYNAMIC_DRAW);

        zeroBuffer();

        }

      }

    // reading the value of the buffer on every frame would slow down rendering by

    // about 3%; doing it only once every 5 frames affects speed by less than 1%.

    if( mCurrBuffer==0 )

      {

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

      counter = printPreviousBuffer();

      }

    if( ++mCurrBuffer>=mFBOQueueSize ) mCurrBuffer = 0;

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

    zeroBuffer();

    return counter;

    }

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

// Pass1 of the OIT algorithm. Clear per-pixel head-pointers.

  static void oitClear(InternalOutputSurface surface, int counter)

    {

    if( mOITClearProgram==null )

      {

      if( mGLSL>=310 && !mOITCompilationAttempted )

        {

        mOITCompilationAttempted = true;

        try

          {

          createOITProgram(mResources);

          }

        catch(Exception ex)

          {

          mListener.distortedException(ex);

          return;

          }

        }

      else

        {

        return;

        }

      }

    if( mLinkedListSSBO[0]<0 )

      {

      GLES30.glGenBuffers(1,mLinkedListSSBO,0);

      int size = (int)(surface.mWidth*surface.mHeight*(3*mBufferSize+1)*4);

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

      GLES30.glBufferData(GLES31.GL_SHADER_STORAGE_BUFFER, size, null, GLES30.GL_DYNAMIC_READ|GLES30.GL_DYNAMIC_DRAW);

      GLES30.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, 0);

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

      }

    // See if we have overflown the SSBO in one of the previous frames.

    // If yes, assume we need to make the SSBO larger.

    float overflow = counter/(mBufferSize*surface.mWidth*surface.mHeight);

    if( overflow>1.0f )

      {

      mBufferSize *= (int)(overflow+1.0f);

      int size = (int)(surface.mWidth*surface.mHeight*(3*mBufferSize+1)*4);

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

      GLES30.glBufferData(GLES31.GL_SHADER_STORAGE_BUFFER, size, null, GLES30.GL_DYNAMIC_READ|GLES30.GL_DYNAMIC_DRAW);

      GLES30.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, 0);

      }

    mOITClearProgram.useProgram();

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

    GLES30.glUniform2f(mOITClearTexCorrH, 1.0f, 1.0f );   // corrections do not really matter here - only present because of common vertex shader.

    GLES30.glUniform1f( mOITClearDepthH , 1.0f);          // likewise depth

    GLES30.glUniform2ui(mOITClearSizeH, surface.mWidth, surface.mHeight);

    GLES30.glVertexAttribPointer(mOITClearProgram.mAttribute[0], 2, GLES30.GL_FLOAT, false, 0, mQuadPositions);

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

    mOITClearProgram.stopUsingProgram();

    }

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

// Pass2 of the OIT algorithm - build per-pixel linked lists.

  static void oitBuild(InternalOutputSurface surface, float corrW, float corrH)