Distorted Android

   * Number of Main program variants (ATM 3: MAIN, MAIN OIT, PREPROCESS)

  public static final int MAIN_VARIANTS = 3;

    try

      {

      EffectQueuePostprocess.createPrograms(resources);

      }

    catch(Exception ex)

      {

      exception = ex;

      }

  void send(float halfW, float halfH, float halfZ, float margin, DistortedOutputSurface surface, int variant)

    {

    mM.send(surface,halfW,halfH,halfZ,margin,variant);

    mV.send(variant);

    }

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

  void drawPrivOIT(float halfW, float halfH, MeshObject mesh, DistortedOutputSurface surface, long currTime)

    mM.send(surface,halfW,halfH,halfZ,0,1);

  void drawPriv(float halfW, float halfH, MeshObject mesh, DistortedOutputSurface surface, long currTime)

    mM.send(surface,halfW,halfH,halfZ,0,0);

      mEffects.drawPriv(mSurface.getWidth()/2.0f, mSurface.getHeight()/2.0f, mMesh, surface, currTime);

      mEffects.drawPrivOIT(mSurface.getWidth()/2.0f, mSurface.getHeight()/2.0f, mMesh, surface, currTime);

      mEffects.drawPriv(mSurface.getWidth()/2.0f, mSurface.getHeight()/2.0f, mMesh, surface, currTime);

 * Returns the DistortedSurface object that's in the Node.

 * @return The DistortedSurface contained in the Node.

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

  /**

   * Returns the DistortedSurface object that's in the Node.

   *

   * @return The DistortedSurface contained in the Node (if a leaf), or the FBO (if an internal Node)

   */

  public DistortedSurface getInternalSurface()

    {

    return mNumChildren[0]==0 ? mSurface : mData.mFBO;

    }

            for(int j=bucketChange; j<i; j++) numRenders += lastQueue.preprocess( mBuffer,children.get(j) );

          for(int j=bucketChange; j<numChildren; j++) numRenders += currQueue.preprocess( mBuffer,children.get(j) );

  static void setUpStencilMark(boolean color)

    int clr = color ? 1:0;

    if( cState.colorMaskR!=clr || cState.colorMaskG!=clr || cState.colorMaskB!=clr || cState.colorMaskA!=clr )

      cState.colorMaskR = clr;

      cState.colorMaskG = clr;

      cState.colorMaskB = clr;

      cState.colorMaskA = clr;

      GLES31.glColorMask(color,color,color,color);

      fpsEffects.drawPriv(fpsW / 2.0f, fpsH / 2.0f, fpsMesh, this, time);

import android.content.res.Resources;

import android.util.Log;

import org.distorted.library.R;

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.program.DistortedProgram;

import java.io.InputStream;

  static DistortedProgram mPreProgram;

  static int mPreColorH;

  /**

   * Only for use by the library itself.

   *

   * @y.exclude

   */

  public 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 boolean getWriteColor()

    return false;

  private int getHalo()

    return mNumEffects>0 ? mHalo : 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)

    DistortedOutputSurface surface = buffers[quality];

    surface.setAsOutput();

    DistortedSurface input = node.getInternalSurface();

    if( input.setAsInput() )

      {

      MeshObject    mesh = node.getMesh();

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

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

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

      DistortedRenderState.unsetUpStencilMark();

      return 1;

      }

    return 0;

  public DistortedProgram(final InputStream vert, final InputStream frag, final String vertHeader, final String fragHeader,

                          int glslVersion, final String[] feedback )

  throws FragmentCompilationException,VertexCompilationException,LinkingException

    final String vertShader = readTextFileFromRawResource(vert, true );

    final String fragShader = readTextFileFromRawResource(frag, false);

    final int vertShaderHandle = compileShader(GLES31.GL_VERTEX_SHADER  , vertHeader + vertShader);

    final int fragShaderHandle = compileShader(GLES31.GL_FRAGMENT_SHADER, fragHeader + fragShader);

    mProgramHandle = createAndLinkProgram(vertShaderHandle, fragShaderHandle, mAttributeName, glslVersion>= 300 ? feedback:null );

  public DistortedProgram(final InputStream vert, final InputStream frag, final String vertHeader, final String fragHeader,

                          final String enabledVert, final String enabledFrag, int glslVersion, final String[] feedback )

  throws FragmentCompilationException,VertexCompilationException,LinkingException

    String vertShader = readTextFileFromRawResource( vert, true );

    String fragShader = readTextFileFromRawResource( frag, false);

    if( enabledVert!=null ) vertShader = insertEnabledEffects(vertShader,enabledVert);

    if( enabledFrag!=null ) fragShader = insertEnabledEffects(fragShader,enabledFrag);

    final int vertShaderHandle = compileShader(GLES31.GL_VERTEX_SHADER  , vertHeader + vertShader);

    final int fragShaderHandle = compileShader(GLES31.GL_FRAGMENT_SHADER, fragHeader + fragShader);

    mProgramHandle = createAndLinkProgram(vertShaderHandle, fragShaderHandle, mAttributeName, glslVersion>= 300 ? feedback:null );

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

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

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

precision highp float;

out vec4 fragColor;

uniform vec4 u_Color;

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

void main()

  {

  fragColor = u_Color;

  }