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

import android.opengl.GLES30;

import org.distorted.library.main.DistortedLibrary;

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 String mAttributeStr, mUniformStr, mUniList;

  private int mAttributeLen, mUniformLen;

  private int mNumAttributes;

  private int mNumUniforms;

  private String[] mAttributeName;

  private final int mProgramHandle;

/**

 * List of Attributes (OpenGL ES 3.0: 'in' variables), in the same order as declared in the shader source.

 */

  public int[] mAttribute;

/**

 * List of Uniforms, in the same order as declared in the shader source.

 */

  public int[] mUniform;

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

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

  throws LinkingException

    {

    int programHandle = GLES30.glCreateProgram();

    if (programHandle != 0)

      {

      GLES30.glAttachShader(programHandle, vertexShaderHandle);

      GLES30.glAttachShader(programHandle, fragmentShaderHandle);

      if( feedbackVaryings!=null )

        {

        GLES30.glTransformFeedbackVaryings(programHandle, feedbackVaryings, GLES30.GL_INTERLEAVED_ATTRIBS);

        }

      if (attributes != null)

        {

        final int size = attributes.length;

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

          {

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

          }

        }

      GLES30.glLinkProgram(programHandle);

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

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

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

        {

        String error = GLES30.glGetProgramInfoLog(programHandle);

        GLES30.glDeleteProgram(programHandle);

        throw new LinkingException(error);

        }

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

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

      //DistortedLibrary.logMessage("DistortedProgram: number of active uniforms="+numberOfUniforms[0]);

      }

    return programHandle;

    }

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

  private void init(int glslVersion)

    {

    mAttributeStr  = (glslVersion == 100 ? "attribute " : "in ");

    mAttributeLen  = mAttributeStr.length();

    mNumAttributes = 0;

    mUniformStr    = "uniform ";

    mUniformLen    = mUniformStr.length();

    mNumUniforms   = 0;

    mUniList       = "";

    }

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

  private String parseOutUniform(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>=mUniformLen+1 )

      {

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

      int subLen = semicolon-whiteSpace;

      if( subline.startsWith(mUniformStr))

        {

        //DistortedLibrary.logMessage("DistortedProgram: GOOD LINE: " +subline+" subLen="+subLen);

        for(nameBegin=subLen-1; nameBegin>mUniformLen-2; nameBegin--)

          {

          currChar=subline.charAt(nameBegin);

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

            {

            mNumUniforms++;

            String uniform = subline.substring(nameBegin+1,subLen);

            int brace = uniform.indexOf("[");

            return brace>=0 ? uniform.substring(0,brace) : uniform;

            }

          }

        }

      }

    return null;

    }

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

  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>=mAttributeLen+1 )

      {

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

      int subLen = semicolon-whiteSpace;

      if( subline.startsWith(mAttributeStr))

        {

        for(nameBegin=subLen-1; nameBegin>mAttributeLen-2; nameBegin--)

          {

          currChar=subline.charAt(nameBegin);

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

            {

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

            }

          }

        }

      }

    return null;

    }

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

  private void doAttributes(final String shader, boolean doAttributes)

    {

    String attribute, attrList="", uniform;

    String[] lines = shader.split("\n");

    for (String line : lines)

      {

      if (doAttributes)

        {

        attribute = parseOutAttribute(line);

        if (attribute != null)

          {

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

          attrList += attribute;

          }

        }

      uniform = parseOutUniform(line);

      if (uniform != null)

        {

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

        mUniList += uniform;

        }

      }

    if( doAttributes )

      {

      mAttributeName = attrList.split(" ");

      mNumAttributes = mAttributeName.length;

      }

    }

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

  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 )

            {

            //DistortedLibrary.logMessage("DistortedProgram: new attribute: "+attribute);

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

            attrList += attribute;

            }

          }

        }

      }

    catch (IOException e)

      {

      return null;

      }

    if( doAttributes )

      {

      mAttributeName = attrList.split(" ");

      mNumAttributes = mAttributeName.length;

      }

    return body.toString();

    }

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

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

  throws FragmentCompilationException,VertexCompilationException

    {

    int shaderHandle = GLES30.glCreateShader(shaderType);

    if (shaderHandle != 0)

      {

      GLES30.glShaderSource(shaderHandle, shaderSource);

      GLES30.glCompileShader(shaderHandle);

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

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

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

        {

        String error = GLES30.glGetShaderInfoLog(shaderHandle);

        GLES30.glDeleteShader(shaderHandle);

        switch (shaderType)

          {

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

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

          default:                        throw new RuntimeException(error);

          }

        }

      }

    return shaderHandle;

    }

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

  private static String insertEnabledEffects(String code, final String effects)

    {

    final String marker = "// ENABLED EFFECTS WILL BE INSERTED HERE";

    int length = marker.length();

    int place = code.indexOf(marker);

    if( place>=0 )

      {

      String begin = code.substring(0,place-1);

      String end   = code.substring(place+length);

      return begin + effects + end;

      }

    else

      {

      DistortedLibrary.logMessage("DistortedProgram: Error: marker string not found in SHADER!");

      }

    return null;

    }

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

  private void setUpAttributes()

    {

    int[] att = new int[mNumAttributes];

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

      {

      att[i] = GLES30.glGetAttribLocation( mProgramHandle, mAttributeName[i]);

      }

    int emptyAttrs = 0;

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

      {

      if( att[i] < 0 )

        {

        emptyAttrs++;

        for(int j=i; j<mNumAttributes-emptyAttrs; j++)

          {

          att[j] = att[j+1];

          mAttributeName[j] = mAttributeName[j+1];

          }

        }

      }

    if( emptyAttrs>0 )

      {

      mNumAttributes -= emptyAttrs;

      mAttribute = new int[mNumAttributes];

      System.arraycopy(att, 0, mAttribute, 0, mNumAttributes);

      }

    else

      {

      mAttribute = att;

      }

    }

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

  private void setUpUniforms()

    {

    if( mNumUniforms>0 )

      {

      mUniform = new int[mNumUniforms];

      String[] uniformName = mUniList.split(" ");

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

        {

        mUniform[i] = GLES30.glGetUniformLocation( mProgramHandle, uniformName[i]);

        }

      }

    else mUniform = null;

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

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

                          int glslVersion, final String[] feedback )

  throws FragmentCompilationException,VertexCompilationException,LinkingException

    {

    init(glslVersion);

    final String vertShader = readTextFileFromRawResource(vert, true );

    final String fragShader = readTextFileFromRawResource(frag, false);

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

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

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

    setUpAttributes();

    setUpUniforms();

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  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

    {

    init(glslVersion);

    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(GLES30.GL_VERTEX_SHADER  , vertHeader + vertShader);

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

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

    setUpAttributes();

    setUpUniforms();

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public DistortedProgram(final InputStream vertex, final InputStream fragment, final String vertexHeader, final String fragmentHeader, int glslVersion )

  throws FragmentCompilationException,VertexCompilationException,LinkingException

    {

    this(vertex,fragment,vertexHeader,fragmentHeader,glslVersion,null);

    }

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

// PUBLIC API

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

/**

 * Create a new Shader Program from two source strings.

 * <p>

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

 *

 * @param vertex   Vertex shader code.

 * @param fragment Fragment shader code.

 * @throws FragmentCompilationException fragment shader failed to compile

 * @throws VertexCompilationException vertex shader failed to compile

 * @throws LinkingException shaders failed to link

 */

  public DistortedProgram(final String vertex, final String fragment)

  throws FragmentCompilationException,VertexCompilationException,LinkingException

    {

    init(300);

    doAttributes(vertex  , true );

    doAttributes(fragment, false);

    final int vertexShaderHandle   = compileShader(GLES30.GL_VERTEX_SHADER  , vertex  );

    final int fragmentShaderHandle = compileShader(GLES30.GL_FRAGMENT_SHADER, fragment);

    mProgramHandle = createAndLinkProgram(vertexShaderHandle, fragmentShaderHandle, mAttributeName, null );

    setUpAttributes();

    setUpUniforms();

    }

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

/**

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

 */

  public int getProgramHandle()

    {

    return mProgramHandle;

    }

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

/**

 * Use the program and enable all vertex attribute arrays.

 *

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

 */

  public void useProgram()

    {

    GLES30.glUseProgram(mProgramHandle);

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

      {

      GLES30.glEnableVertexAttribArray(mAttribute[i]);

      }

    }

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

/**

 * Disable all vertex attribute arrays.

 *

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

 */

  public void stopUsingProgram()

    {

    GLES30.glUseProgram(0);

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

      {

      GLES30.glDisableVertexAttribArray(mAttribute[i]);

      }

    }

  }