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.content.res.Resources;

import android.opengl.GLES31;

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.message.EffectMessage;

import org.distorted.library.program.DistortedProgram;

import java.io.InputStream;

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

class EffectQueuePostprocess extends EffectQueue

  {

  private static final int NUM_UNIFORMS = PostprocessEffect.NUM_UNIFORMS;

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

  private int mHalo;

  private static DistortedProgram mPreProgram;

  private static int mPreColorH;

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

  EffectQueuePostprocess(long id)

    { 

    super(id,NUM_UNIFORMS,INDEX );

    }

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

  void compute(long currTime)

    {

    if( currTime==mTime ) return;

    if( mTime==0 ) mTime = currTime;

    long step = (currTime-mTime);

    mHalo = 0;

    int halo;

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

      {

      mCurrentDuration[i] += step;

      if( mEffects[i].compute(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i], step) )

        {

        for(int j=0; j<mNumListeners; j++)

          EffectMessageSender.newMessage( mListeners.get(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);

        if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )

          {

          remove(i--);

          mNumEffectsToBe--;

          regenerateIDandSort();

          continue;

          }

        }

      halo = (int)mUniforms[NUM_UNIFORMS*i];

      if( halo>mHalo ) mHalo = halo;

      }

    mTime = currTime;

    }

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

  static void createPrograms(Resources resources)

    {

    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 mainVertHeader= Distorted.GLSL_VERSION + ("#define NUM_VERTEX "   + ( numV>0 ? DistortedEffects.getMax(EffectType.VERTEX  ) : 0 ) + "\n");

    String mainFragHeader= Distorted.GLSL_VERSION + "\n";

    String enabledEffectV= VertexEffect.getGLSL();

    try

      {

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

                                         enabledEffectV, null, Distorted.GLSL, null);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    int preProgramH = mPreProgram.getProgramHandle();

    EffectQueueVertex.getUniforms( preProgramH,2 );

    EffectQueueMatrix.getUniforms( preProgramH,2 );

    mPreColorH= GLES31.glGetUniformLocation( preProgramH, "u_Color");

    }

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

// TODO

  private int getWriteColor()

    {

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

    }

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

  private int getHalo()

    {

    return mNumEffects>0 ? mHalo : 0;

    }

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

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

  private int getInternalQuality()

    {

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

    }

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

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

  int getQuality()

    {

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

    }

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

  int preprocess(DistortedOutputSurface[] buffers, DistortedNode node)

    {

    int quality = getInternalQuality();

    DistortedOutputSurface surface = buffers[quality];

    surface.setAsOutput();

    DistortedSurface input = node.getInternalSurface();

    if( input.setAsInput() )

      {

      MeshObject mesh = node.getMesh();

      int  writeColor = getWriteColor();

      float    margin = getHalo()*surface.mMipmap;

      float halfW = input.getWidth() / 2.0f;

      float halfH = input.getHeight()/ 2.0f;

      float halfZ = halfW*mesh.zFactor;

      DistortedRenderState.setUpStencilMark(writeColor!=0);

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

      mPreProgram.useProgram();

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

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

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

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

      GLES31.glBindBuffer(GLES31.GL_ARRAY_BUFFER, 0);

      node.getEffects().send(halfW, halfH, halfZ, margin, surface, 2);

      float a = (writeColor&255);

      if( a!=0.0f )

        {

        writeColor = (writeColor>>8);

        float b = writeColor&255;

        writeColor = (writeColor>>8);

        float g = writeColor&255;

        writeColor = (writeColor>>8);

        float r = writeColor&255;

        GLES31.glUniform4f(mPreColorH, r, g, b, a);

        }

      GLES31.glDrawArrays(GLES31.GL_TRIANGLE_STRIP, 0, mesh.numVertices);

      DistortedRenderState.unsetUpStencilMark();

      return 1;

      }

    return 0;

    }

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

  int postprocess(DistortedOutputSurface[] buffers)

    {

    int numRenders = 0;

    GLES31.glDisable(GLES31.GL_BLEND);

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

      {

      numRenders += ((PostprocessEffect)mEffects[i]).apply(mUniforms,NUM_UNIFORMS*i, buffers);

      }

    GLES31.glEnable(GLES31.GL_BLEND);

    return numRenders;

    }

  }