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;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import android.content.Context;

import android.opengl.GLES20;

import android.os.Build;

import android.util.Log;

import org.distorted.library.exception.*;

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

/**

 * A singleton class used to control various global settings.

 */

public class Distorted 

  {

  /**

   * When creating an instance of a DistortedObject from another instance, do not clone anything.

   * Used in the copy constructor.

   */

  public static final int CLONE_NOTHING = 0x0;

  /**

   * When creating an instance of a DistortedObject from another instance, clone the Bitmap that's

   * backing up our DistortedObject. 

   * <p>

   * This way we can have two DistortedObjects, both backed up by the same Bitmap, to which we can 

   * apply different effects. Used in the copy constructor.

   */

  public static final int CLONE_BITMAP  = 0x1;

  /**

   * When creating an instance of a DistortedObject from another instance, clone the Matrix Effects.

   * <p>

   * This way we can have two different DistortedObjects with different Bitmaps behind them, both 

   * always displayed in exactly the same place on the screen. Applying any matrix-based effect to 

   * one of them automatically applies the effect to the other. Used in the copy constructor.

   */

  public static final int CLONE_MATRIX = 0x2;

  /**

   * When creating an instance of a DistortedObject from another instance, clone the Vertex Effects.

   * <p>

   * This way we can have two different DistortedObjects with different Bitmaps behind them, both 

   * always with the same Vertex effects. Applying any vertex-based effect to one of them automatically 

   * applies the effect to the other. Used in the copy constructor.

   */

  public static final int CLONE_VERTEX  = 0x4;

  /**

   * When creating an instance of a DistortedObject from another instance, clone the Fragment Effects.

   * <p>

   * This way we can have two different DistortedObjects with different Bitmaps behind them, both 

   * always with the same Fragment effects. Applying any fragment-based effect to one of them automatically 

   * applies the effect to the other. Used in the copy constructor.

   */

  public static final int CLONE_FRAGMENT= 0x8;

  /**

   * When creating an instance of a DistortedNode from another instance, clone the children Nodes.

   * <p>

   * This is mainly useful for creating many similar sub-trees of Bitmaps and rendering then at different places

   * on the screen, with (optionally) different effects of the top-level root Bitmap.   

   */

  public static final int CLONE_CHILDREN= 0x10;

  private static final String TAG = Distorted.class.getSimpleName();

  private static boolean mInitialized = false;

  static int mPositionH;        // pass in model position information

  static int mTextureUniformH;  // pass in the texture.

  static int mNormalH;          // pass in model normal information.

  static int mTextureCoordH;    // pass in model texture coordinate information.

  static int mProgramH;         // This is a handle to our shading program.

  static DistortedProjection mProjection = new DistortedProjection();

  static float mFOV = 60.0f;

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

  private Distorted()

    {

    }

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

  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(TAG, "Max vectors in vertex shader: "+maxV);

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

    if( Build.FINGERPRINT.startsWith("generic") == false )

      {

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

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

      if( getMaxVertex()   > realMaxV )

        {

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

        }

      if( 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 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(TAG, "number of active uniforms="+numberOfUniforms[0]);

      }

    return programHandle;

    }

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

  private static String generateShaderHeader(final int type)

    {

    String header="";

    switch(type)

      {

      case GLES20.GL_VERTEX_SHADER  : header += ("#define NUM_VERTEX "  + 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 "+ getMaxFragment()+"\n");

                                      for(EffectNames name: EffectNames.values() )

                                        {

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

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

                                        }

                                      break;

     }

    //Log.d(TAG,""+header);

    return header;

    }

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

  private static String readTextFileFromRawResource(final Context c, final int resourceId)

    {

    final InputStream inputStream = c.getResources().openRawResource(resourceId);

    final InputStreamReader inputStreamReader = new InputStreamReader(inputStream);

    final BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

    String nextLine;

    final StringBuilder body = new StringBuilder();

    try

      {

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

        {

        body.append(nextLine);

        body.append('\n');

        }

      }

    catch (IOException e)

      {

      return null;

      }

    return body.toString();

    }

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

  private static String getVertexShader(final Context c)

    {

    return readTextFileFromRawResource( c, R.raw.main_vertex_shader);

    }

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

  private static String getFragmentShader(final Context c)

    {

    return readTextFileFromRawResource( c, R.raw.main_fragment_shader);

    }

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

// Public API

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

/**

 * Sets Vertical Field of View angle. This changes the Projection Matrix.  

 *   

 * @param fov Vertical Field Of View angle, in degrees. If T is the middle of the top edge of the 

 *            screen, E is the eye point, and B is the middle of the bottom edge of the screen, then 

 *            fov = angle(TEB)

 */

  public static void setFov(float fov)

    {

    mFOV = fov;

    if( mProjection.width>0 && mProjection.height>0 )

      mProjection.onSurfaceChanged( mProjection.width, mProjection.height);

    }

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

/**

 * When OpenGL context gets created, you need to call this method so that the library can initialise its internal data structures.

 * I.e. best called from GLSurfaceView.onSurfaceCreated().

 * <p>

 * Compiles the vertex and fragment shaders, establishes the addresses of all uniforms, and initialises all Bitmaps that have already

 * been created.

 *   

 * @param context Context of the App using the library - used to open up Resources and read Shader code.

 * @throws FragmentCompilationException

 * @throws VertexCompilationException

 * @throws VertexUniformsException

 * @throws FragmentUniformsException

 * @throws LinkingException

 */

  public static void onSurfaceCreated(final Context context) throws FragmentCompilationException,VertexCompilationException,VertexUniformsException,FragmentUniformsException,LinkingException

    { 

    mInitialized = true;  

    final String vertexShader   = Distorted.getVertexShader(context);

    final String fragmentShader = Distorted.getFragmentShader(context);

    sanitizeMaxValues();

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

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

    mProgramH = createAndLinkProgram(vertexShaderHandle, fragmentShaderHandle, new String[] {"a_Position",  "a_Color", "a_Normal", "a_TexCoordinate"});                                                            

    GLES20.glUseProgram(mProgramH);

    GLES20.glEnable (GLES20.GL_DEPTH_TEST);

    GLES20.glDepthFunc(GLES20.GL_LEQUAL);

    GLES20.glEnable(GLES20.GL_BLEND);

    GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA);

    GLES20.glEnable(GLES20.GL_CULL_FACE);

    GLES20.glCullFace(GLES20.GL_BACK);

    GLES20.glFrontFace(GLES20.GL_CW);

    mTextureUniformH = GLES20.glGetUniformLocation(mProgramH, "u_Texture");

    mPositionH       = GLES20.glGetAttribLocation( mProgramH, "a_Position");

    mNormalH         = GLES20.glGetAttribLocation( mProgramH, "a_Normal");

    mTextureCoordH   = GLES20.glGetAttribLocation( mProgramH, "a_TexCoordinate");

    EffectQueueFragment.getUniforms(mProgramH);

    EffectQueueVertex.getUniforms(mProgramH);

    EffectQueueMatrix.getUniforms(mProgramH);

    GLES20.glEnableVertexAttribArray(mPositionH);        

    GLES20.glEnableVertexAttribArray(mNormalH);

    GLES20.glEnableVertexAttribArray(mTextureCoordH);

    DistortedObjectList.reset();

    DistortedNode.reset();

    EffectMessageSender.startSending();

    }

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

/**

 * Call this when the physical size of the surface we are rendering to changes.

 * I.e. must be called from GLSurfaceView.onSurfaceChanged()  

 *   

 * @param surfaceWidth  new width of the surface.

 * @param surfaceHeight new height of the surface.

 */

  public static void onSurfaceChanged(int surfaceWidth, int surfaceHeight)

    {

    mProjection.onSurfaceChanged(surfaceWidth, surfaceHeight);

    }

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

/**

 * Call this so that the Library can release its internal data structures.

 * Must be called from Activity.onDestroy(). 

 */

  public static void onDestroy()

    {

    DistortedGridFactory.release();

    DistortedObjectList.release();

    DistortedNode.release();

    EffectQueue.reset();

    EffectMessageSender.stopSending();

    mInitialized = false;

    }

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

/**

 * Returns the true if onSurfaceCreated has been called already, and thus if the Library's is ready

 * to accept effect requests.

 * 

 * @return <code>true</code> if the Library is ready for action, <code>false</code> otherwise.

 */

  public static boolean isInitialized()

    {

    return mInitialized;  

    }

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

/**

 * Returns the maximum number of Matrix effects.

 *    

 * @return The maximum number of Matrix effects

 */

  public static int getMaxMatrix()

    {

    return EffectQueue.getMax(EffectTypes.MATRIX.ordinal());

    }

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

/**

 * Returns the maximum number of Vertex effects.

 *    

 * @return The maximum number of Vertex effects

 */  

  public static int getMaxVertex()

    {

    return EffectQueue.getMax(EffectTypes.VERTEX.ordinal());

    }

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

/**

 * Returns the maximum number of Fragment effects.

 *    

 * @return The maximum number of Fragment effects

 */  

  public static int getMaxFragment()

    {

    return EffectQueue.getMax(EffectTypes.FRAGMENT.ordinal());

    }

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

/**

 * Sets the maximum number of Matrix effects that can be applied to a single DistortedObject at one time.

 * This can fail if:

 * <ul>

 * <li>the value of 'max' is outside permitted range (0 &le; max &le; Byte.MAX_VALUE)

 * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called

 *     before the Vertex Shader gets compiled, i.e. before the call to {@link #onSurfaceCreated}. After this

 *     time only decreasing the value of 'max' is permitted.

 * <li>Furthermore, this needs to be called before any DistortedObject gets created.

 * </ul>

 * 

 * @param max new maximum number of simultaneous Matrix Effects. Has to be a non-negative number not greater

 *            than Byte.MAX_VALUE 

 * @return <code>true</code> if operation was successful, <code>false</code> otherwise.

 */

  public static boolean setMaxMatrix(int max)

    {

    return EffectQueue.setMax(EffectTypes.MATRIX.ordinal(),max);

    }

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

/**

 * Sets the maximum number of Vertex effects that can be applied to a single DistortedObject at one time.

 * This can fail if:

 * <ul>

 * <li>the value of 'max' is outside permitted range (0 &le; max &le; Byte.MAX_VALUE)

 * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called 

 *     before the Vertex Shader gets compiled, i.e. before the call to {@link #onSurfaceCreated}. After this

 *     time only decreasing the value of 'max' is permitted.

* <li>Furthermore, this needs to be called before any DistortedObject gets created.

 * </ul>

 * 

 * @param max new maximum number of simultaneous Vertex Effects. Has to be a non-negative number not greater

 *            than Byte.MAX_VALUE 

 * @return <code>true</code> if operation was successful, <code>false</code> otherwise.

 */

  public static boolean setMaxVertex(int max)

    {

    return EffectQueue.setMax(EffectTypes.VERTEX.ordinal(),max);

    }

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

/**

 * Sets the maximum number of Fragment effects that can be applied to a single DistortedObject at one time.

 * This can fail if:

 * <ul>

 * <li>the value of 'max' is outside permitted range (0 &le; max &le; Byte.MAX_VALUE)

 * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called 

 *     before the Fragment Shader gets compiled, i.e. before the call to {@link #onSurfaceCreated}. After this

 *     time only decreasing the value of 'max' is permitted.

 * <li>Furthermore, this needs to be called before any DistortedObject gets created.

 * </ul>

 * 

 * @param max new maximum number of simultaneous Fragment Effects. Has to be a non-negative number not greater

 *            than Byte.MAX_VALUE 

 * @return <code>true</code> if operation was successful, <code>false</code> otherwise.

 */

  public static boolean setMaxFragment(int max)

    {

    return EffectQueue.setMax(EffectTypes.FRAGMENT.ordinal(),max);

    }

  }