Distorted Android

// Copyright 2016 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

//                                                                                               //

// This library 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                             //

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

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

package org.distorted.library.main;

import android.opengl.GLES30;

import android.opengl.GLES31;

import org.distorted.library.R;

import org.distorted.library.effect.Effect;

import org.distorted.library.effectqueue.EffectQueue;

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.PostprocessEffect;

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.effectqueue.EffectQueueVertex;

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;

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

 * 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

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

   */

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

   */

   /**

  /**

   * 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

   */

  public static final int CLONE_CHILDREN= 0x20;

  /**

  /**

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

   *

   */

  private static int mFBOQueueSize;

  private static int mGLSL;

  private static boolean mOITCompilationAttempted, mNeedsTransformFeedback;

  private static boolean mBuggyUBOs;

  private static boolean mFastCompilationTF;

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

  private static int mTransformFeedbackH;

  private static int mNormalProjectionH;

  /// FULL PROGRAM ///

  static

  /// Program Handles ///

  /// OIT SSBO BUFFER ///

  private static int[] mAtomicCounter;

  private static int   mCurrBuffer;

  /**

   *

   */

  public interface LibraryUser

    {

    InputStream localFile(int fileID);

    }

  private static LibraryUser mUser;

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

// private: hide this from Javadoc

  private DistortedLibrary()

    {

    }

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

  private static void createMainProgram()

    {

    final InputStream mainVertStream = mUser.localFile(R.raw.main_vertex_shader);

    String mainVertHeader= mGLSL_VERSION + ("#define NUM_VERTEX "   + ( numV>0 ? getMax(EffectType.VERTEX  ) : 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();

      mMainProgram = new DistortedProgram(mainVertStream, mainFragStream, mainVertHeader,

      }

      mUser.logMessage(e.getClass().getSimpleName()+" trying to compile MAIN program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

    mMainProgramH = mMainProgram.getProgramHandle();

    MeshBase.getUniforms(mMainProgramH,0);

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

    final InputStream blitVertStream = mUser.localFile(R.raw.blit_vertex_shader);

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

      }

      mUser.logMessage(e.getClass().getSimpleName()+" trying to compile BLIT program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

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

    final InputStream blitDepthVertStream = mUser.localFile(R.raw.blit_depth_vertex_shader);

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

      }

      mUser.logMessage(e.getClass().getSimpleName()+" trying to compile BLIT DEPTH program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

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

    }

  private static void createNormalProgram()

    {

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

    final InputStream normalVertexStream   = mUser.localFile(R.raw.normal_vertex_shader);

      mNormalProgram = new DistortedProgram(normalVertexStream,normalFragmentStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);

      }

      mUser.logMessage(e.getClass().getSimpleName()+" trying to compile NORMAL program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

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

    }

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

  private static void createFullProgram()

    {

    final InputStream fullVertStream = mUser.localFile(R.raw.main_vertex_shader);

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

    fullVertHeader += "#define PREAPPLY\n";

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

      mUser.logMessage(e.getClass().getSimpleName()+" trying to compile FULL program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

    mFullProgramH = mFullProgram.getProgramHandle();

    MeshBase.getUniforms(mFullProgramH,3);

    }

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

  private static void createOITProgram()

    {

    final InputStream mainVertStream = mUser.localFile(R.raw.main_vertex_shader);

    String mainVertHeader= mGLSL_VERSION + ("#define NUM_VERTEX "   + ( numV>0 ? getMax(EffectType.VERTEX  ) : 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();

                                             enabledEffectV, enabledEffectF, mGLSL, null);

      }

      mUser.logMessage(e.getClass().getSimpleName()+" trying to compile MAIN OIT program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

    mMainOITProgramH = mMainOITProgram.getProgramHandle();

    MeshBase.getUniforms(mMainOITProgramH,1);

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

    final InputStream oitClearVertStream = mUser.localFile(R.raw.oit_vertex_shader);

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

      }

      mUser.logMessage(e.getClass().getSimpleName()+" trying to compile OIT CLEAR program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

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

    final InputStream oitBuildVertStream = mUser.localFile(R.raw.oit_vertex_shader);

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

      }

      mUser.logMessage(e.getClass().getSimpleName()+" trying to compile OIT BUILD program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

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

    final InputStream oitCollapseVertStream = mUser.localFile(R.raw.oit_vertex_shader);

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

      }

      mUser.logMessage(e.getClass().getSimpleName()+" trying to compile OIT COLLAPSE program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

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

    final InputStream oitRenderVertStream = mUser.localFile(R.raw.oit_vertex_shader);

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

      }

      mUser.logMessage(e.getClass().getSimpleName()+" trying to compile OIT RENDER program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

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

    }

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

    {

    if( mNormalProgram==null )

        createNormalProgram();

        }

        mUser.distortedException(ex);

        return;

    int num = mesh.getNumVertices();

    GLES30.glUniform1i(DistortedLibrary.mTransformFeedbackH, 1);

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

    InternalRenderState.switchOffDrawing();

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

    InternalRenderState.restoreDrawing();

    GLES30.glEndTransformFeedback();

    GLES30.glUniform1i(DistortedLibrary.mTransformFeedbackH, 0);

    mNormalProgram.useProgram();

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

    mesh.bindTransformAttribs(mNormalProgram);

    GLES30.glLineWidth(8.0f);

    mNormalProgram.stopUsingProgram();

    }

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

/**

  public static void adjustVertices(MeshBase mesh, EffectQueueVertex queue)

    {

    if( mFullProgram==null )

      {

      try

        createFullProgram();

        }

        mUser.distortedException(ex);

        return;

      }

    queue.compute(1,0);

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

    mesh.send(mFullProgramH,3);

    mFullProgram.stopUsingProgram();

    }

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

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

    {

    if( mMainOITProgram!=null )

      EffectQueue.compute(queues, currTime, step);

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

      mMainOITProgram.useProgram();

      mesh.send(mMainOITProgramH,1);

      float inflate     = mesh.getInflate();

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

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

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

      mMainOITProgram.stopUsingProgram();

      }

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

    {

    if( mMainProgram!=null )

      {

      EffectQueue.compute(queues, currTime, step);

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

      mMainProgram.useProgram();

      mesh.send(mMainProgramH,0);

      float inflate     = mesh.getInflate();

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

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

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

      mMainProgram.stopUsingProgram();

      }

    }

  static void blitPriv(InternalOutputSurface surface)

    {

    if( mBlitProgram!=null )

      mBlitProgram.stopUsingProgram();

      }

    }

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