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

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.opengl.GLSurfaceView;

import org.distorted.examples.R;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshRectangles;

import org.distorted.library.mesh.MeshSphere;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import java.io.IOException;

import java.io.InputStream;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

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

class GenericRenderer implements GLSurfaceView.Renderer

{

    private static final float FOV = 30.0f;

    private static final float NEAR = 0.1f;

    private GLSurfaceView mView;

    private DistortedTexture mObjectTexture, mBackgroundTexture, mCenterTexture, mRegionTexture;

    private DistortedScreen mScreen;

    private DistortedNode mCenterNode, mRegionNode;

    private int mObjWidth, mObjHeight, mObjDepth;

    private Static3D mCenterPoint, mRegionPoint, mRegionScalePoint;

    private Static3D mRotateCen, mMoveObject, mScaleObject, mMoveCenter, mScaleCenter, mMoveRegion, mMoveBackground, mScaleBackground;

    private boolean mShowingCenter=false;

    private boolean mShowingRegion=false;

    private float mFactorObj;

    private int mWidth;

    private float mFactor;

    Static4D mQuat1, mQuat2;

    int mScreenMin;

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

    GenericRenderer(GLSurfaceView v)

      {

      mView = v;

      GenericActivity2 act = (GenericActivity2)v.getContext();

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

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

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

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

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

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

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

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

      mObjectTexture     = act.getTexture();

      mBackgroundTexture = new DistortedTexture(100,100);

      mCenterTexture     = new DistortedTexture(100,100);

      mRegionTexture     = new DistortedTexture(100,100);

      mFactorObj = 1.0f;

      DistortedEffects objectEffects     = act.getEffects();

      DistortedEffects backgroundEffects = new DistortedEffects();

      DistortedEffects centerEffects     = new DistortedEffects();

      DistortedEffects regionEffects     = new DistortedEffects();

      MeshBase mesh    = act.getMesh();

      MeshRectangles quad    = new MeshRectangles(1,1);

      mFactor = mesh instanceof MeshSphere ? 1.0f : 0.7f;

      mObjWidth = mObjectTexture.getWidth();

      mObjHeight= mObjectTexture.getHeight();

      mObjDepth = mObjectTexture.getDepth(mesh);

      mQuat1 = new Static4D(0,0,0,1);  // unity

      mQuat2 = new Static4D(0,0,0,1);  // quaternions

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

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

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

      mCenterNode = new DistortedNode(mCenterTexture, centerEffects, quad);

      mRegionNode = new DistortedNode(mRegionTexture, regionEffects, quad);

      mScreen = new DistortedScreen();

      mScreen.setProjection(FOV, NEAR);

      mScreen.attach(mBackgroundTexture, backgroundEffects, quad );

      mScreen.attach(mObjectTexture    , objectEffects    , mesh );

      int regionSize = mRegionTexture.getWidth();

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

      MatrixEffectQuaternion quat1cen = new MatrixEffectQuaternion(mQuat1, mRotateCen);

      MatrixEffectQuaternion quat2cen = new MatrixEffectQuaternion(mQuat2, mRotateCen);

      MatrixEffectMove centerMove = new MatrixEffectMove(mCenterPoint);

      centerEffects.apply( new MatrixEffectScale(mScaleCenter) );

      centerEffects.apply( centerMove );

      centerEffects.apply( new MatrixEffectMove(mMoveCenter) );

      centerEffects.apply(quat2cen);

      centerEffects.apply(quat1cen);

      regionEffects.apply( new MatrixEffectMove(new Static3D( -regionSize*0.5f , -regionSize*0.5f , 0)) );

      regionEffects.apply( new MatrixEffectScale(mRegionScalePoint) );

      regionEffects.apply( new MatrixEffectMove(mRegionPoint) );

      regionEffects.apply( centerMove );

      regionEffects.apply( new MatrixEffectMove(mMoveRegion) );

      regionEffects.apply(quat2cen);

      regionEffects.apply(quat1cen);

      resetMatrixEffects();

      // quite tricky: move the background exactly to the FAR plane! (see InternalOutputSurface.setProjection() )

      backgroundEffects.apply(new MatrixEffectScale(mScaleBackground) );

      backgroundEffects.apply(new MatrixEffectMove(mMoveBackground) );

      }

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

    void resetMatrixEffects()

      {

      GenericActivity2 act = (GenericActivity2)mView.getContext();

      DistortedEffects objectEffects= act.getEffects();

      Static3D rotateObj = new Static3D( (float)mObjWidth/2, (float)mObjHeight/2, (float)mObjDepth/2 );

      MatrixEffectQuaternion quat1obj = new MatrixEffectQuaternion(mQuat1,  rotateObj);

      MatrixEffectQuaternion quat2obj = new MatrixEffectQuaternion(mQuat2,  rotateObj);

      objectEffects.apply(quat2obj);

      objectEffects.apply(quat1obj);

      objectEffects.apply( new MatrixEffectScale(mScaleObject) );

      objectEffects.apply( new MatrixEffectMove(mMoveObject));

      mQuat1.set(0,0,0,1);

      mQuat2.set(0,0,0,1);

      }

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

    void showRegionAndCenter(boolean showRegion, boolean showCenter)

      {

      if( mShowingCenter!=showCenter  )

        {

        if( showCenter )

          {

          if( mShowingRegion ) mScreen.detach(mRegionNode);

          mScreen.attach(mCenterNode);

          if( mShowingRegion ) mScreen.attach(mRegionNode);

          }

        else

          {

          mScreen.detach(mCenterNode);

          }

        mShowingCenter = showCenter;

        }

      if( mShowingRegion!=showRegion  )

        {

        if( showRegion ) mScreen.attach(mRegionNode);

        else             mScreen.detach(mRegionNode);

        mShowingRegion = showRegion;

        }

      }

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

    public int getWidth()

      {

      return mWidth;

      }

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

    void setCenter(float x, float y, float z)

      {

      mCenterPoint.set(mFactorObj*x,mFactorObj*y,mFactorObj*z);

      }

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

    void setRegion(float x, float y, float z, float r)

      {

      float factorReg = 2*mFactorObj*r/mRegionTexture.getWidth();

      mRegionPoint.set(mFactorObj*x,mFactorObj*y, mFactorObj*z);

      mRegionScalePoint.set(factorReg,factorReg,factorReg);

      }

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

    void useOIT(boolean use)

      {

      mScreen.setOrderIndependentTransparency(use);

      }

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

    public void onDrawFrame(GL10 glUnused)

      {

      mScreen.render(System.currentTimeMillis());

      }

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

    public void onSurfaceChanged(GL10 glUnused, int width, int height)

      {

      mWidth = width;

      mScreenMin = width<height ? width:height;

      float factorCen;

      int centerSize = mCenterTexture.getWidth();

      if( width*mObjHeight > height*mObjWidth ) // screen is more 'horizontal' than the Object

        {

        mFactorObj = (mFactor*height)/mObjHeight;

        factorCen  = (0.08f  *height)/centerSize;

        }

      else

        {

        mFactorObj = (mFactor*width)/mObjWidth;

        factorCen  = (0.08f  *width)/centerSize;

        }

      setCenter(0.5f*mObjWidth,0.5f*mObjHeight,0.5f*mObjDepth);

      setRegion(0.0f,0.0f,0.0f,0.25f*(mObjWidth+mObjHeight));

      mMoveObject.set( (width-mFactorObj*mObjWidth)/2 , (height-mFactorObj*mObjHeight)/2 , -mFactorObj*mObjDepth );

      mRotateCen.set(width*0.5f,height*0.5f, 0);

      mScaleObject.set(mFactorObj,mFactorObj,mFactorObj);

      mMoveCenter.set( (width -factorCen*centerSize-mFactorObj*mObjWidth )/2 ,

                       (height-factorCen*centerSize-mFactorObj*mObjHeight)/2 , 15 );

      mScaleCenter.set(factorCen,factorCen,factorCen);

      mMoveRegion.set( (width -mFactorObj*mObjWidth )/2 ,(height-mFactorObj*mObjHeight)/2 , 12 );

      int backgroundSize = mBackgroundTexture.getWidth();

      float factorBackX = ((float)width)/backgroundSize;

      float factorBackY = ((float)height)/backgroundSize;

      // quite tricky: move the background exactly to the FAR plane! (see InternalOutputSurface.setProjection() )

      mMoveBackground.set( -width*0.5f, -height*0.5f, -0.9f*height*(1.0f-NEAR)/(2.0f*(float)Math.tan(FOV*Math.PI/360)) );

      mScaleBackground.set( 2*factorBackX, 2*factorBackY, 1.0f );

      mScreen.resize(width, height);

      }

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

    public void onSurfaceCreated(GL10 glUnused, EGLConfig config)

      {

      GenericActivity2 act = (GenericActivity2)mView.getContext();

      InputStream isB = act.getResources().openRawResource(R.raw.water);

      InputStream isC = act.getResources().openRawResource(R.raw.center);

      InputStream isR = act.getResources().openRawResource(R.raw.region);

      Bitmap bitmapB,bitmapC,bitmapR;

      try 

        {

        bitmapB = BitmapFactory.decodeStream(isB);

        bitmapC = BitmapFactory.decodeStream(isC);

        bitmapR = BitmapFactory.decodeStream(isR);

        }

      finally 

        {

        try 

          {

          isB.close();

          isC.close();

          isR.close();

          }

        catch(IOException e) { }

        }  

      mObjectTexture.setTexture( act.getBitmap() );

      mBackgroundTexture.setTexture(bitmapB);

      mCenterTexture.setTexture(bitmapC);

      mRegionTexture.setTexture(bitmapR);

      DistortedLibrary.setMax(EffectType.VERTEX  ,10);

      DistortedLibrary.setMax(EffectType.FRAGMENT,10);

      Effect.enableEffects(EffectType.VERTEX);

      Effect.enableEffects(EffectType.FRAGMENT);

      Effect.enableEffects(EffectType.POSTPROCESS);

      try

        {

        DistortedLibrary.onCreate(mView.getContext());

        }

      catch(Exception ex)

        {

        android.util.Log.e("Effects3D", ex.getMessage() );

        }

      }

}