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

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

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

// Lesser General Public License for more details.                                               //

//                                                                                               //

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

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

package org.distorted.library.effectqueue;

import android.content.res.Resources;

import android.opengl.GLES30;

import android.util.Log;

import org.distorted.library.R;

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.PostprocessEffect;

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedFramebuffer;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.InternalOutputSurface;

import org.distorted.library.main.InternalRenderState;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.message.EffectMessageSender;

import org.distorted.library.program.DistortedProgram;

import java.io.InputStream;

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

/**

 * Not part of public API, do not document

 *

 * @y.exclude

 */

public class EffectQueuePostprocess extends EffectQueue

  {

  private static final int NUM_FLOAT_UNIFORMS = PostprocessEffect.NUM_FLOAT_UNIFORMS;

  private static final int NUM_INT_UNIFORMS   = PostprocessEffect.NUM_INT_UNIFORMS;

  private static final boolean USE_UBO        = false;

  private static final int INDEX = EffectType.POSTPROCESS.ordinal();

  private int mHalo;

  private boolean mUseHaloDepth;

  private float mR, mG, mB, mA;

  private static DistortedProgram mPreProgram;

  private static int mPreColorH;

  private static int mPreTextureH;

  private static int mPreProgramH;

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

  EffectQueuePostprocess()

    { 

    super(NUM_FLOAT_UNIFORMS, NUM_INT_UNIFORMS, USE_UBO, INDEX );

    }

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

  EffectQueuePostprocess(EffectQueuePostprocess source)

    {

    super(source);

    }

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

  void compute(long currTime, long step)

    {

    mR = mG = mB = mA = 0.0f;

    mHalo = 0;

    int halo;

    float[] array = mUBF.getBackingArray();

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

      {

      // first zero out the 'alpha' because BLUR effect will not overwrite this (it is a 1D effect)

      // and if previously there was a GLOW effect here then mA would be non-zero and we don't want

      // that (see preprocess())

      array[NUM_FLOAT_UNIFORMS*i+5]=0.0f;

      PostprocessEffect effect = (PostprocessEffect)mEffects[i];

      if( effect.compute(array, NUM_FLOAT_UNIFORMS*i, currTime, step) )

        {

        EffectMessageSender.newMessage(mEffects[i]);

        }

      halo = (int)array[NUM_FLOAT_UNIFORMS*i];

      if( halo>mHalo ) mHalo = halo;

      // TODO  (now only really works in case of 1 effect!)

      mUseHaloDepth = effect.getHaloDepth();

      }

    // TODO  (now only really works in case of 1 effect!)

    if( mNumEffects>0 )

      {

      mR = array[2];

      mG = array[3];

      mB = array[4];

      mA = array[5];

      }

    }

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

  public static void createPrograms(Resources resources, int GLSL)

    {

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

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

    int numV = VertexEffect.getNumEnabled();

    String version = "#version "+GLSL+" es\n";

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

    String mainFragHeader= version + "\n";

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

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

    String enabledEffectV= VertexEffect.getGLSL();

    try

      {

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

                                         enabledEffectV, null, GLSL, null);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    mPreProgramH = mPreProgram.getProgramHandle();

    EffectQueue.getUniforms( mPreProgramH,2 );

    MeshBase.getUniforms( mPreProgramH,2 );

    mPreColorH  = GLES30.glGetUniformLocation( mPreProgramH, "u_Color"  );

    mPreTextureH= GLES30.glGetUniformLocation( mPreProgramH, "u_Texture");

    }

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

// TODO  (now only really works in case of 1 effect!)

  public int getQuality()

    {

    return mNumEffects>0 ? ((PostprocessEffect)mEffects[0]).getQuality() : 0;

    }

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

// TODO  (now only really works in case of 1 effect!)

  public boolean getRenderDirectly()

    {

    return mNumEffects>0 && ((PostprocessEffect) mEffects[0]).getRenderDirectly();

    }

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

  public int preprocess(InternalOutputSurface buffer, DistortedNode node, float distance, float mipmap, float[] projection)

    {

    MeshBase mesh = node.getMesh();

    DistortedEffects effects = node.getEffects();

    int width   = buffer.getWidth();

    int height  = buffer.getHeight();

    InternalRenderState.setUpStencilMark(mA!=0.0f);

    InternalRenderState.disableBlending();

    if( !mUseHaloDepth ) GLES30.glDepthMask(false);

    GLES30.glViewport(0, 0, width, height );

    mPreProgram.useProgram();

    mesh.bindVertexAttribs(mPreProgram);

    mesh.send(mPreProgramH,2);

    EffectQueue[] queues = effects.getQueues();

    EffectQueueMatrix matrix = (EffectQueueMatrix)queues[0];

    EffectQueueVertex vertex = (EffectQueueVertex)queues[1];

    matrix.send(distance, mipmap, projection, 2);

    vertex.send(mHalo*0.01f,mPreProgramH,2);

    if( mA!=0.0f )

      {

      GLES30.glUniform4f(mPreColorH, mR, mG, mB, mA);

      GLES30.glUniform1i(mPreTextureH, 0);

      }

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

    mPreProgram.stopUsingProgram();

    InternalRenderState.restoreBlending();

    InternalRenderState.unsetUpStencilMark();

    if( !mUseHaloDepth ) GLES30.glDepthMask(true);

    return 1;

    }

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

  public int postprocess(DistortedFramebuffer buffer)

    {

    int numRenders = 0;

    float[] array = mUBF.getBackingArray();

    GLES30.glDisable(GLES30.GL_BLEND);

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

      {

      numRenders += ((PostprocessEffect)mEffects[i]).postprocess(array,NUM_FLOAT_UNIFORMS*i, buffer);

      }

    GLES30.glEnable(GLES30.GL_BLEND);

    return numRenders;

    }

  }