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.examples.plainmonalisa;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.opengl.EGL14;

import android.opengl.EGLSurface;

import android.opengl.GLES30;

import android.os.Looper;

import android.util.Log;

import android.view.Surface;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

import org.distorted.library.effect.EffectName;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffectDistort;

import org.distorted.library.main.Distorted;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.MeshFlat;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.examples.R;

import java.io.IOException;

import java.io.InputStream;

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

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 final 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 DistortedEffects mEffects;

  private DistortedTexture mTexture;

  private MeshFlat mMesh;

  private DistortedScreen mScreen;

  private int bmpHeight, bmpWidth;

  private SurfaceView mView;

  private static boolean resourcesCreated = false;

  private Static3D mMove, mScale;

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

  RenderThread(SurfaceHolder holder, SurfaceView view)

    {

    mSurfaceHolder = holder;

    mView = view;

    Static3D pLeft = new Static3D( 90, 258, 0);

    Static3D pRight= new Static3D(176, 255, 0);

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

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

    Dynamic3D dLeft = new Dynamic3D(1000,0.0f);

    Dynamic3D dRight= new Dynamic3D(1000,0.0f);

    dLeft.add( new Static3D(  0,  0,0) );

    dLeft.add( new Static3D(-20,-20,0) );

    dRight.add( new Static3D(  0,  0,0) );

    dRight.add( new Static3D( 20,-10,0) );

    mEffects = new DistortedEffects();

    mEffects.apply( new VertexEffectDistort(dLeft , pLeft , rLeft ) );

    mEffects.apply( new VertexEffectDistort(dRight, pRight, rRight) );

    mMove = new Static3D(0,0,0);

    mScale= new Static3D(1,1,1);

    mEffects.apply(new MatrixEffectMove(mMove));

    mEffects.apply(new MatrixEffectScale(mScale));

    mScreen = new DistortedScreen();

    }

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

  static void setResourcesCreated()

    {

    resourcesCreated = false;

    }

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

  private static void checkGlError(String op)

    {

    int error = GLES30.glGetError();

    if (error != GLES30.GL_NO_ERROR)

      {

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

      Log.e(TAG, msg);

//    throw new RuntimeException(msg);

      }

    }

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

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

      }

    }

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

  void waitUntilReady()

    {

    synchronized (mStartLock)

      {

      while (!mReady)

        {

        try

          {

          mStartLock.wait();

          }

        catch (InterruptedException ie) {  }

        }

      }

    }

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

  void shutdown()

    {

    Log.d(TAG, "shutdown");

    Looper.myLooper().quit();

    }

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

  RenderHandler getHandler()

    {

    return mHandler;

    }

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

  void surfaceCreated()

    {

    Log.d(TAG, "surfaceCreated");

    Surface surface = mSurfaceHolder.getSurface();

    eglSurface = eglCore.createWindowSurface(surface);

    eglCore.makeCurrent(eglSurface);

    createResources();

    }

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

  void surfaceChanged(int width, int height)

    {

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

    if( (float)bmpHeight/bmpWidth > (float)height/width )

      {

      int w = (height*bmpWidth)/bmpHeight;

      float factor = (float)height/bmpHeight;

      mMove.set((width-w)/2,0,0);

      mScale.set( factor,factor,factor );

      }

    else

      {

      int h = (width*bmpHeight)/bmpWidth;

      float factor = (float)width/bmpWidth;

      mMove.set(0,(height-h)/2,0);

      mScale.set( factor,factor,factor );

      }

    mScreen.resize(width, height);

    }

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

  private void createResources()

    {

    resourcesCreated = true;

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

    Bitmap bmp;

    try

      {

      bmp = BitmapFactory.decodeStream(is);

      }

    finally

      {

      try

        {

        is.close();

        }

      catch(IOException io) {}

      }

    bmpHeight = bmp.getHeight();

    bmpWidth  = bmp.getWidth();

    if( mTexture==null ) mTexture = new DistortedTexture(bmpWidth,bmpHeight);

    mTexture.setTexture(bmp);

    if( mMesh==null ) mMesh = new MeshFlat(9,9*bmpHeight/bmpWidth);

    mScreen.detachAll();

    mScreen.attach(mTexture,mEffects,mMesh);

    DistortedEffects.enableEffect(EffectName.DISTORT);

    try

      {

      Distorted.onCreate(mView.getContext());

      }

    catch(Exception ex)

      {

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

      }

    }

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

  void doFrame(long frameTimeNs)

    {

    // We can still get here after onPaused - ignore such calls.

    if( PlainMonaLisaSurfaceView.isPaused() )

      {

      android.util.Log.e("Thread", "Got here after onPaused- ignoring frame draw call!!");

      return;

      }

    // This will happen if we just briefly went into the background (press 'POWER')

    // Then surfaceCreated/changed is not called

    if( !resourcesCreated )

      {

      Log.e("Thread", "resources not created!!");

      createResources();

      }

    eglCore.makeCurrent(eglSurface);

    mScreen.render( frameTimeNs/1000000 );  // 1 nanosecond = 1 millisecond / 10^-6

    eglCore.swapBuffers(eglSurface);

    }

  }