Distorted Android

package org.distorted.examples.plainmonalisa;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.opengl.EGL14;

import android.opengl.EGLSurface;

import android.opengl.GLES20;

import android.os.Looper;

import android.os.Trace;

import android.util.Log;

import android.view.Surface;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

import org.distorted.library.Distorted;

import org.distorted.library.DistortedBitmap;

import org.distorted.library.EffectTypes;

import org.distorted.library.Float2D;

import org.distorted.library.Float3D;

import org.distorted.library.Float4D;

import org.distorted.examples.R;

import java.io.IOException;

import java.io.InputStream;

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

/**

 * This class handles all OpenGL rendering.

 * <p>

 * Start the render thread after the Surface has been created.

 */

public class RenderThread extends Thread

  {

  private static final String TAG = "RenderThread";

  // Object must be created on render thread to get correct Looper, but is used from

  // UI thread, so we need to declare it volatile to ensure the UI thread sees a fully

  // constructed object.

  private volatile RenderHandler mHandler;

  // Used to wait for the thread to start.

  private Object mStartLock = new Object();

  private boolean mReady = false;

  private volatile SurfaceHolder mSurfaceHolder;  // may be updated by UI thread

  private EglCore eglCore;

  private EGLSurface eglSurface;

  private DistortedBitmap monaLisa;

  private int bmpHeight, bmpWidth;

  private Float2D pLeft, pRight;

  private Float4D rLeft, rRight;

  private Float3D vLeft, vRight;

  SurfaceView mView;

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

  /**

   * Pass in the SurfaceView's SurfaceHolder.  Note the Surface may not yet exist.

   */

  public RenderThread(SurfaceHolder holder, SurfaceView view)

    {

    mSurfaceHolder = holder;

    mView = view;

    pLeft = new Float2D( 90, 258);

    pRight= new Float2D(176, 255);

    rLeft = new Float4D(-10,-10,25,25);

    rRight= new Float4D( 10, -5,25,25);

    vLeft = new Float3D(-20,-20,0);

    vRight= new Float3D( 20,-10,0);

    }

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

  /**

   * Thread entry point.

   * <p>

   * The thread should not be started until the Surface associated with the SurfaceHolder

   * has been created.  That way we don't have to wait for a separate "surface created"

   * message to arrive.

   */

  @Override

  public void run()

    {

    Looper.prepare();

    mHandler = new RenderHandler(this);

    eglCore = new EglCore(null, EglCore.FLAG_RECORDABLE | EglCore.FLAG_TRY_GLES3);

    synchronized (mStartLock)

      {

      mReady = true;

      mStartLock.notify();    // signal waitUntilReady()

      }

    Looper.loop();

    Log.d(TAG, "looper quit");

    checkGlError("releaseGl start");

    if (eglSurface != null)

      {

      eglCore.releaseSurface(eglSurface);

      eglSurface = EGL14.EGL_NO_SURFACE;

      }

    checkGlError("releaseGl done");

    eglCore.makeNothingCurrent();

    eglCore.release();

    synchronized (mStartLock)

      {

      mReady = false;

      }

    }

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

  /**

   * Waits until the render thread is ready to receive messages.

   * <p>

   * Call from the UI thread.

   */

  public void waitUntilReady()

    {

    synchronized (mStartLock)

      {

      while (!mReady)

        {

        try

          {

          mStartLock.wait();

          }

        catch (InterruptedException ie) { /* not expected */ }

        }

      }

    }

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

  /**

   * Shuts everything down.

   */

  void shutdown()

    {

    Log.d(TAG, "shutdown");

    Looper.myLooper().quit();

    }

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

  /**

   * Returns the render thread's Handler.  This may be called from any thread.

   */

  public RenderHandler getHandler()

      {

      return mHandler;

      }

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

  /**

   * Prepares the surface.

   */

  void surfaceCreated()

    {

    Surface surface = mSurfaceHolder.getSurface();

    eglSurface = eglCore.createWindowSurface(surface);

    eglCore.makeCurrent(eglSurface);

    InputStream is = mView.getContext().getResources().openRawResource(R.raw.monalisa);

    Bitmap bmp;

    try

      {

      bmp = BitmapFactory.decodeStream(is);

      }

    finally

      {

      try

        {

        is.close();

        }

      catch(IOException io) {}

      }

    monaLisa = new DistortedBitmap(bmp, 10);

    monaLisa.distort( vLeft, rLeft , pLeft, 1000, 0);

    monaLisa.distort(vRight, rRight, pRight,1000, 0);

    bmpHeight = bmp.getHeight();

    bmpWidth  = bmp.getWidth();

    try

      {

      Distorted.onSurfaceCreated(mView.getContext());

      }

    catch(Exception ex)

      {

      Log.e("MonaLisa", ex.getMessage() );

      }

    }

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

  void surfaceChanged(int width, int height)

    {

    Log.d(TAG, "surfaceChanged " + width + "x" + height);

    monaLisa.abortEffects(EffectTypes.MATRIX);

    if( bmpHeight/bmpWidth > height/width )

      {

      int w = (height*bmpWidth)/bmpHeight;

      monaLisa.move((width-w)/2 ,0, 0);

      monaLisa.scale((float)height/bmpHeight);

      }

    else

      {

      int h = (width*bmpHeight)/bmpWidth;

      monaLisa.move(0 ,(height-h)/2, 0);

      monaLisa.scale((float)width/bmpWidth);

      }

    Distorted.onSurfaceChanged(width, height);

    }

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

  public void doFrame(long frameTimeNs)

    {

    Trace.beginSection("doFrame draw");

    eglCore.makeCurrent(eglSurface);

    GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

    GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

    monaLisa.draw(System.currentTimeMillis());

    eglCore.swapBuffers(eglSurface);

    Trace.endSection();

    }

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

  public static void checkGlError(String op)

    {

    int error = GLES20.glGetError();

    if (error != GLES20.GL_NO_ERROR)

      {

      String msg = op + ": glError 0x" + Integer.toHexString(error);

      Log.e(TAG, msg);

      throw new RuntimeException(msg);

      }

    }

  }

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