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.program;

import android.opengl.GLES20;

import android.os.Build;

import org.distorted.library.DistortedEffects;

import org.distorted.library.EffectNames;

import org.distorted.library.EffectTypes;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

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

/**

 * An object which encapsulates a vertex/fragment shader combo, aka Shader Program.

 */

public class DistortedProgram

  {

  private int mProgramHandle;

  private int mNumAttributes;

  private int[] mAttribute;

  private String[] mAttributeName;

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

  private int createAndLinkProgram(final int vertexShaderHandle, final int fragmentShaderHandle, final String[] attributes)

  throws LinkingException

    {

    int programHandle = GLES20.glCreateProgram();

    if (programHandle != 0)

      {

      GLES20.glAttachShader(programHandle, vertexShaderHandle);

      GLES20.glAttachShader(programHandle, fragmentShaderHandle);

      if (attributes != null)

        {

        final int size = attributes.length;

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

          {

          GLES20.glBindAttribLocation(programHandle, i, attributes[i]);

          }

        }

      GLES20.glLinkProgram(programHandle);

      final int[] linkStatus = new int[1];

      GLES20.glGetProgramiv(programHandle, GLES20.GL_LINK_STATUS, linkStatus, 0);

      if (linkStatus[0] != GLES20.GL_TRUE )

        {

        String error = GLES20.glGetProgramInfoLog(programHandle);

        GLES20.glDeleteProgram(programHandle);

        throw new LinkingException(error);

        }

      final int[] numberOfUniforms = new int[1];

      GLES20.glGetProgramiv(programHandle, GLES20.GL_ACTIVE_UNIFORMS, numberOfUniforms, 0);

      //android.util.Log.d("program", "number of active uniforms="+numberOfUniforms[0]);

      }

    return programHandle;

    }

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

  private String parseOutAttribute(final String line)

    {

    int len = line.length();

    int whiteSpace, semicolon, nameBegin;

    char currChar;

    for(whiteSpace=0; whiteSpace<len; whiteSpace++)

      {

      currChar = line.charAt(whiteSpace);

      if( currChar!=' ' && currChar!='\t') break;

      }

    for(semicolon=whiteSpace; semicolon<len; semicolon++)

      {

      currChar = line.charAt(semicolon);

      if( currChar==';') break;

      }

    if( semicolon<len && semicolon-whiteSpace>=11 )   // "attribute a;" --> 11

      {

      String subline = line.substring(whiteSpace,semicolon);

      int subLen = semicolon-whiteSpace;

      if( subline.startsWith("attribute"))

        {

        //android.util.Log.e("program", "GOOD LINE: " +subline+" subLen="+subLen);

        for(nameBegin=subLen-1; nameBegin>8; nameBegin--)

          {

          currChar=subline.charAt(nameBegin);

          if( currChar==' ' || currChar=='\t' )

            {

            mNumAttributes++;

            return subline.substring(nameBegin+1,subLen);

            }

          }

        }

      }

    return null;

    }

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

  private String readTextFileFromRawResource(final InputStream inputStream, boolean doAttributes)

    {

    final InputStreamReader inputStreamReader = new InputStreamReader(inputStream);

    final BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

    String nextLine, attribute, attrList="";

    final StringBuilder body = new StringBuilder();

    try

      {

      while ((nextLine = bufferedReader.readLine()) != null)

        {

        body.append(nextLine);

        body.append('\n');

        if( doAttributes )

          {

          attribute = parseOutAttribute(nextLine);

          if( attribute!=null )

            {

            //android.util.Log.d("program", "new attribute: "+attribute);

            if( attrList.length()>0 ) attrList+=" ";

            attrList += attribute;

            }

          }

        }

      }

    catch (IOException e)

      {

      return null;

      }

    if( doAttributes )

      {

      mAttribute = new int[mNumAttributes];

      mAttributeName = attrList.split(" ");

      }

    return body.toString();

    }

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

  private static void sanitizeMaxValues()

  throws VertexUniformsException,FragmentUniformsException

    {

    int maxV,maxF;

    int[] param = new int[1];

    GLES20.glGetIntegerv(GLES20.GL_MAX_VERTEX_UNIFORM_VECTORS, param, 0);

    maxV = param[0];

    GLES20.glGetIntegerv(GLES20.GL_MAX_FRAGMENT_UNIFORM_VECTORS, param, 0);

    maxF = param[0];

    //Log.d("program", "Max vectors in vertex shader: "+maxV);

    //Log.d("program", "Max vectors in fragment shader: "+maxF);

    if( !Build.FINGERPRINT.contains("generic") )

      {

      int realMaxV = (maxV-11)/4;   // adjust this in case of changes to the shaders...

      int realMaxF = (maxF- 2)/4;   //

      if( DistortedEffects.getMaxVertex()   > realMaxV )

        {

        throw new VertexUniformsException("Too many effects in the vertex shader, max is "+realMaxV, realMaxV);

        }

      if( DistortedEffects.getMaxFragment() > realMaxF )

        {

        throw new FragmentUniformsException("Too many effects in the fragment shader, max is "+realMaxF, realMaxF);

        }

      }

    }

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

  private static int compileShader(final int shaderType, final String shaderSource)

  throws FragmentCompilationException,VertexCompilationException

    {

    int shaderHandle = GLES20.glCreateShader(shaderType);

    if (shaderHandle != 0)

      {

      GLES20.glShaderSource(shaderHandle, "#version 100 \n"+ generateShaderHeader(shaderType) + shaderSource);

      GLES20.glCompileShader(shaderHandle);

      final int[] compileStatus = new int[1];

      GLES20.glGetShaderiv(shaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus, 0);

      if (compileStatus[0] != GLES20.GL_TRUE )

        {

        GLES20.glDeleteShader(shaderHandle);

        shaderHandle = 0;

        }

      }

    if (shaderHandle == 0)

      {

      String error = GLES20.glGetShaderInfoLog(shaderHandle);

      switch(shaderType)

        {

        case GLES20.GL_VERTEX_SHADER  : throw new VertexCompilationException(error);

        case GLES20.GL_FRAGMENT_SHADER: throw new FragmentCompilationException(error);

        default                       : throw new RuntimeException(error);

        }

      }

    return shaderHandle;

    }

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

  private static String generateShaderHeader(final int type)

    {

    String header="";

    switch(type)

      {

      case GLES20.GL_VERTEX_SHADER  : header += ("#define NUM_VERTEX "  + DistortedEffects.getMaxVertex()+"\n");

                                      for(EffectNames name: EffectNames.values() )

                                        {

                                        if( name.getType()== EffectTypes.VERTEX)

                                        header += ("#define "+name.name()+" "+name.ordinal()+"\n");

                                        }

                                      break;

      case GLES20.GL_FRAGMENT_SHADER: header += ("#define NUM_FRAGMENT "+ DistortedEffects.getMaxFragment()+"\n");

                                      for(EffectNames name: EffectNames.values() )

                                        {

                                        if( name.getType()==EffectTypes.FRAGMENT)

                                        header += ("#define "+name.name()+" "+name.ordinal()+"\n");

                                        }

                                      break;

     }

    //android.util.Log.d("program",""+header);

    return header;

    }

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

// PUBLIC API

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

  /**

   * Create a new Shader Program from source stored in resource files.

   * <p>

   * Needs to be called from a thread holding the OpenGL context.

   *

   * @param vertex   InputStream containing the opened Resource file from where to read vertex shader code.

   * @param fragment InputStream containing the opened Resource file from where to read fragment shader code.

   * @throws FragmentCompilationException

   * @throws VertexCompilationException

   * @throws VertexUniformsException

   * @throws FragmentUniformsException

   * @throws LinkingException

   */

  public DistortedProgram(final InputStream vertex, final InputStream fragment)

  throws FragmentCompilationException,VertexCompilationException,VertexUniformsException,FragmentUniformsException,LinkingException

    {

    mNumAttributes = 0;

    final String vertexShader   = readTextFileFromRawResource(vertex  , true );

    final String fragmentShader = readTextFileFromRawResource(fragment, false);

    sanitizeMaxValues();

    final int vertexShaderHandle   = compileShader(GLES20.GL_VERTEX_SHADER  , vertexShader  );

    final int fragmentShaderHandle = compileShader(GLES20.GL_FRAGMENT_SHADER, fragmentShader);

    mProgramHandle = createAndLinkProgram(vertexShaderHandle, fragmentShaderHandle, mAttributeName);

    }

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

/**

 * Return the indexes off all attributes.

 */

  public int[] getAttributes()

    {

    return mAttribute;

    }

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

/**

 * Return the names of all vertex attributes.

 */

  public String[] getAttributeNames()

    {

    return mAttributeName;

    }

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

/**

 * Return the handle of the created program so that we can later, say, call glUseProgram.

 */

  public int getProgramHandle()

    {

    return mProgramHandle;

    }

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

/**

 * Bind all vertex attributes and enable them.

 * <p>

 * This assumes Program is in use. Call glUseProgram first.

 * Needs to be called from a thread holding the OpenGL context.

 */

  public void bindAndEnableAttributes()

    {

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

      {

      mAttribute[i] = GLES20.glGetAttribLocation( mProgramHandle, mAttributeName[i]);

      GLES20.glEnableVertexAttribArray(mAttribute[i]);

      }

    }

  }