Distorted Android

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 DistortedBitmap 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 PreShader 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_PRESHADER = 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;

  // Note: why no 'CLONE_POSTSHADER' constant? The only Postshader effects are the 'save to PNG file'

  // 'save to MP4 file'. Sharing those effects across multiple DistortedObject objects does not make any

  // sense - multiple Objects would then fight to get saved all to the same file.

  /**

   * 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 mColorH;         // pass in model color 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(false);

  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( EffectQueueVertex.getMax() > realMaxV )

        {

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

        }

      if( EffectQueueFragment.getMax() > 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 "  + EffectQueueVertex.getMax()+"\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 "+ EffectQueueFragment.getMax()+"\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( (int)mProjection.width, (int)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 APpp 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;  

// String ver;  

    final String vertexShader   = Distorted.getVertexShader(context);

    final String fragmentShader = Distorted.getFragmentShader(context);

/*

    ver = GLES20.glGetString(GLES20.GL_SHADING_LANGUAGE_VERSION);    

    Log.d(TAG, "GLSL version: "+(ver==null ? "null" : ver) );

    ver = GLES20.glGetString(GLES20.GL_VERSION);   

    Log.d(TAG, "GL version: "+(ver==null ? "null" : ver) );

    ver = GLES20.glGetString(GLES20.GL_VENDOR);    

    Log.d(TAG, "GL vendor: "+(ver==null ? "null" : ver) );

    ver = GLES20.glGetString(GLES20.GL_RENDERER);  

    Log.d(TAG, "GL renderer: "+(ver==null ? "null" : ver) );

*/

    //ver = GLES20.glGetString(GLES20.GL_EXTENSIONS);    

    //Log.d(TAG, "GL extensions: "+(ver==null ? "null" : ver) );

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

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

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

    mColorH          = GLES20.glGetAttribLocation( mProgramH, "a_Color");

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

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

    {

    DistortedObjectList.release();

    DistortedNode.release();

    EffectQueueVertex.reset();

    EffectQueueFragment.reset();

    EffectQueueMatrix.reset();  // no need to reset Other EffectQueue

    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 EffectQueueMatrix.getMax();

    }

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

/**

 * Returns the maximum number of Vertex effects.

 *    

 * @return The maximum number of Vertex effects

 */  

  public static int getMaxVertex()

    {

    return EffectQueueVertex.getMax();

    }

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

/**

 * Returns the maximum number of Fragment effects.

 *    

 * @return The maximum number of Fragment effects

 */  

  public static int getMaxFragment()

    {

    return EffectQueueFragment.getMax();

    }

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

/**

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

 * This can fail if the value of 'max' is outside permitted range. 

 * 

 * @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 EffectQueueMatrix.setMax(max);

    }

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

/**

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

 * This can fail if:

 * <ul>

 * <li>the value of 'max' is outside permitted range

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

 * </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 EffectQueueVertex.setMax(max);

    }

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

/**

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

 * This can fail if:

 * <ul>

 * <li>the value of 'max' is outside permitted range

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

 * </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 EffectQueueFragment.setMax(max);

    }

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

//end of file  

}