Distorted Android

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

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

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

package org.distorted.library.effectqueue;

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.main.DistortedLibrary;

import org.distorted.library.main.DistortedFramebuffer;

import org.distorted.library.main.InternalOutputSurface;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.message.EffectMessageSender;

import org.distorted.library.program.DistortedProgram;

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

/**

  {

  private static final int NUM_UNIFORMS = PostprocessEffect.NUM_UNIFORMS;

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

  private int mHalo;

  private float mR, mG, mB, mA;

  private static DistortedProgram mPreProgram;

  private static int mPreTextureH;

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

  EffectQueuePostprocess()

    { 

    super(NUM_UNIFORMS,INDEX );

    }

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

  void compute(long currTime)

    {

    if( currTime==mTime ) return;

    if( mTime==0 ) mTime = currTime;

    mR = mG = mB = mA = 0.0f;

    mHalo = 0;

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

      mCurrentDuration[i] += step;

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

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

        {

        EffectMessageSender.newMessage(mEffects[i]);

        }

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

      }

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

    mTime = currTime;

    }

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

  public static void createPrograms(Resources resources)

    {

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

                                         enabledEffectV, null, DistortedLibrary.GLSL, null);

      }

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

    }

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

// 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 getRender()

    {

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

    }

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

    {

    buffer.setAsOutput();

    InternalSurface input = node.getSurface();

    if( input.setAsInput() )

      MeshBase mesh = node.getMesh();

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

      float halfZ = halfW*mesh.getZFactor();

      int width = buffer.getWidth();

      InternalRenderState.setUpStencilMark(mA!=0.0f);

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

      mesh.bindVertexAttribs(mPreProgram);

      EffectQueue[] queues = node.getEffects().getQueues();

      matrix.send(width, height, distance, mipmap, projection, halfW, halfH, halfZ, 2);

        inflate = matrix.magnify(projection, width, height, mipmap, halfW, halfH, halfZ, mHalo);

        }

      if( mA!=0.0f )

        {

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

        }

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

      InternalRenderState.restoreBlending();

    }

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

  public int postprocess(DistortedFramebuffer buffer)

    {

    int numRenders = 0;

    GLES31.glDisable(GLES31.GL_BLEND);

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

      {

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

      }

    GLES31.glEnable(GLES31.GL_BLEND);

    return numRenders;

    }

  }