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

import java.io.IOException;

import java.io.InputStream;

import java.util.Random;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import org.distorted.examples.R;

import org.distorted.library.effect.FragmentEffectAlpha;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectRotate;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.mesh.MeshQuad;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.message.EffectListener;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.main.DistortedEffects;

import android.app.ActivityManager;

import android.content.Context;

import android.content.pm.ConfigurationInfo;

import android.content.res.Resources;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.Typeface;

import android.opengl.GLES31;

import android.opengl.GLSurfaceView;

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

class StarWarsRenderer implements GLSurfaceView.Renderer, EffectListener, DistortedLibrary.LibraryUser

  {

  private final String[] mGFFAString = 

            { "A long time ago, in a galaxy far,",

              "far away...." };                    // yes, there really was a four-dot ellipsis

  private final String[] mCRAWLString = 

            { "It is a period of civil war.",      // in the original 1977 version, there was no 

              "Rebel spaceships, striking",        // 'Episode IV New Hope' subtitle line before

              "from a hidden base, have",          // the crawl. Lets keep to the classic.

              "won their first victory",

              "against the evil Galactic",

              "Empire.",

              "",

              "During the battle, rebel",

              "spies managed to steal",

              "secret plans to the Empire's",

              "ultimate weapon, the",

              "DEATH STAR, an armored",

              "space station with enough",

              "power to destroy an entire",

              "planet.",

              "",

              "Pursued by the Empire's",

              "sinister agents, Princess",

              "Leia races home aboard her",

              "starship, custodian of the",

              "stolen plans that can save",

              "her people and restore",

              "freedom to the galaxy...." };      // four-dot.

  private final int NUM_STARS = 40;

  private final int CRAWL_COLOR = 0xffffe81f;

  private final int GFFA_COLOR  = 0xff0000ff;

  private final int FONT_HEIGHT      = 40;

  private final int VERTICAL_SPACING = 10;

  private final String CRAWL_TYPEFACE = "News Gothic";

  private final int CRAWL_WIDTH = 500;

  private final int CRAWL_HEIGHT= (FONT_HEIGHT+VERTICAL_SPACING)*(mCRAWLString.length+1);

  private final int GFFA_WIDTH = 600;

  private final int GFFA_HEIGHT= (FONT_HEIGHT+VERTICAL_SPACING)*(mGFFAString.length+1);

  private final float CRAWL_ANGLE = -30.0f;

  private final float FOV_ANGLE   =  60.0f;

  private final GLSurfaceView mView;

  private final DistortedEffects mGFFAEffects, mLogoEffects, mCrawlEffects, mCrawlBackgroundEffects;

  private final DistortedEffects[] mStarEffects;

  private final DistortedScreen mScreen;

  private final MeshQuad mQuad;

  private final Random mRnd = new Random(0);

  private final Resources mResources;

  private DistortedTexture mGFFATexture, mLogoTexture, mCrawlTexture, mCrawlBackgroundTexture, mStarTexture;

  private DistortedNode mBackground;

  private long alphaEffectID, scaleEffectID, moveEffectID;

  private int mWidth, mHeight;

  private float mLogoRatio;

  private int mCrawlBackgroundW, mCrawlBackgroundH;

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

  StarWarsRenderer(GLSurfaceView v)

    {

    mView = v;

    mResources = v.getResources();

    mQuad = new MeshQuad();

    mGFFAEffects            = new DistortedEffects();

    mLogoEffects            = new DistortedEffects();

    mCrawlEffects           = new DistortedEffects();

    mCrawlBackgroundEffects = new DistortedEffects();

    if( NUM_STARS>0 )

      {

      mStarEffects = new DistortedEffects[NUM_STARS];

      mStarEffects[0] = new DistortedEffects();

      for (int i = 1; i < NUM_STARS; i++)

        mStarEffects[i] = new DistortedEffects(mStarEffects[0], DistortedLibrary.CLONE_VERTEX);

      }

    mScreen = new DistortedScreen();

    mScreen.setProjection(FOV_ANGLE, 0.02f);

    }

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

  public void onPause()

    {

    mWidth = 0;

    mHeight= 0;

    }

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

  public void onDrawFrame(GL10 glUnused) 

    {

    mScreen.render(System.currentTimeMillis());

    }

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

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

    {

    if( mWidth!=width || mHeight!=height )  // after onPause() we get 2 calls here

      {

      mWidth = width;

      mHeight= height;

      mGFFAEffects.abortAllEffects();

      mLogoEffects.abortAllEffects();

      mCrawlEffects.abortAllEffects();

      mCrawlBackgroundEffects.abortAllEffects();

      for(int i=0; i<NUM_STARS; i++) mStarEffects[i].abortAllEffects();

      mScreen.detachAll();

      setupScreen(width,height);

      mScreen.resize(width, height);

      }

    }

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

  public void onSurfaceCreated(GL10 glUnused, EGLConfig config) 

    {

    setupBitmaps();

    FragmentEffectAlpha.enable();

    DistortedLibrary.onSurfaceCreated(this);

    }

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

  private void setupScreen(int scrW, int scrH)

    {

    double angleA = (90.0f - FOV_ANGLE/2              ) * Math.PI/180;

    double angleB = (90.0f - FOV_ANGLE/2 + CRAWL_ANGLE) * Math.PI/180;

    if( mCrawlBackgroundTexture!=null ) mCrawlBackgroundTexture.markForDeletion();

    mCrawlBackgroundTexture = new DistortedTexture();

    mCrawlBackgroundW = scrW;

    mCrawlBackgroundH = (int)(scrH*Math.sin(angleA)/Math.sin(angleB));

    int randomA, randomX, randomY, randomTime;

    float randomS, randomAlpha1, randomAlpha2;

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

    Static3D axis   = new Static3D(0,0,1);

    Static1D alphaNoise = new Static1D(0.4f);

    for(int i=0; i<NUM_STARS; i++)

      {

      randomX = mRnd.nextInt(scrW) - scrW/2;

      randomY = mRnd.nextInt(scrH) - scrH/2;

      randomS = (0.2f+ 0.8f*mRnd.nextFloat())*20;

      randomA = (int)(180*mRnd.nextFloat());

      randomAlpha1 = 0.2f + 0.8f*mRnd.nextFloat();

      randomAlpha2 = 0.8f + 0.2f*mRnd.nextFloat();

      randomTime = 500+mRnd.nextInt(2000);

      mStarEffects[i].apply( new MatrixEffectRotate(new Static1D(randomA), axis, center) );

      mStarEffects[i].apply( new MatrixEffectScale(randomS) );

      mStarEffects[i].apply( new MatrixEffectMove(new Static3D(randomX,randomY,0)) );

      Dynamic1D di = new Dynamic1D(randomTime,0.0f);

      di.setNoise(alphaNoise);

      di.add(new Static1D(randomAlpha1));

      di.add(new Static1D(randomAlpha2));

      mStarEffects[i].apply( new FragmentEffectAlpha(di) );

      mScreen.attach(mStarTexture, mStarEffects[i], mQuad);

      }

    Dynamic1D di = new Dynamic1D(6000,0.5f);

    di.add(new Static1D(1.0f));

    di.add(new Static1D(1.0f));

    di.add(new Static1D(0.0f));

    FragmentEffectAlpha alpha = new FragmentEffectAlpha(di);

    alpha.notifyWhenFinished(this);

    alphaEffectID = alpha.getID();

    Static3D scale = new Static3D(0.5f*scrW, 0.5f*scrW * GFFA_HEIGHT / GFFA_WIDTH, 1);

    mGFFAEffects.apply( new MatrixEffectScale(scale) );

    mGFFAEffects.apply( new MatrixEffectMove(new Static3D(-scrW/3 + GFFA_WIDTH/2 ,scrH/6,0)) );

    mGFFAEffects.apply( alpha );

    mScreen.attach(mGFFATexture, mGFFAEffects, mQuad);

    }

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

  private void setupBitmaps()

    {

    InputStream is1 = mView.getContext().getResources().openRawResource(R.raw.starwars);

    InputStream is2 = mView.getContext().getResources().openRawResource(R.raw.star);

    Bitmap bitmapStar, bitmapGFFA, bitmapLogo, bitmapText;

    try 

      {

      bitmapLogo = BitmapFactory.decodeStream(is1);

      bitmapStar = BitmapFactory.decodeStream(is2);

      } 

    finally 

      {

      try 

        {

        is1.close();

        is2.close();

        } 

      catch(IOException e) { }

      } 

    Paint paint = new Paint();

    paint.setAntiAlias(true);

    paint.setTextAlign(Paint.Align.LEFT);

    paint.setTextSize(FONT_HEIGHT);

    paint.setColor(GFFA_COLOR);

    Typeface tf = Typeface.create(CRAWL_TYPEFACE, Typeface.BOLD);

    paint.setTypeface(tf);     

    ///// create GFFA ///////////////////

    if( mGFFATexture==null ) mGFFATexture  = new DistortedTexture();

    bitmapGFFA = Bitmap.createBitmap(GFFA_WIDTH,GFFA_HEIGHT,Bitmap.Config.ARGB_8888);

    bitmapGFFA.eraseColor(0x00000000);

    Canvas gffaCanvas = new Canvas(bitmapGFFA);

    for(int i=0; i<mGFFAString.length; i++)

      {

      gffaCanvas.drawText(mGFFAString[i], 0, (i+1)*(FONT_HEIGHT+VERTICAL_SPACING), paint);  

      }

    mGFFATexture.setTexture(bitmapGFFA);

    ///// create Logo ///////////////////

    if( mLogoTexture==null ) mLogoTexture = new DistortedTexture();

    mLogoTexture.setTexture(bitmapLogo);

    mLogoRatio = (float)bitmapLogo.getWidth()/bitmapLogo.getHeight();

    ///// create CRAWL //////////////////

    if( mCrawlTexture==null ) mCrawlTexture = new DistortedTexture();

    bitmapText = Bitmap.createBitmap(CRAWL_WIDTH,CRAWL_HEIGHT,Bitmap.Config.ARGB_8888);

    bitmapText.eraseColor(0x00000000);

    Canvas textCanvas = new Canvas(bitmapText);

    paint.setColor(CRAWL_COLOR);

    for(int i=0; i<mCRAWLString.length; i++)

      {

      displayJustified(mCRAWLString[i], 0, (i+1)*(FONT_HEIGHT+VERTICAL_SPACING), CRAWL_WIDTH, textCanvas, paint);  

      }

    mCrawlTexture.setTexture(bitmapText);

    ///// create Stars ///////////////////

    if( mStarTexture==null ) mStarTexture = new DistortedTexture();

    mStarTexture.setTexture(bitmapStar);

    }

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

  private void displayJustified(String str, int x, int y, int length, Canvas c, Paint paint)

    { 

    int len       = str.length();

    int numspaces = retNumSpaces(str);

    if( len>0 && str.charAt(len-1) == ' ' ) numspaces--;

    float left=x,w = (numspaces>0 ? (length-paint.measureText(str))/numspaces : 0);

    String tmp;

    int begin,end=0;

    while( end<len )

      {

      begin=end;

      end = str.indexOf(' ', begin)+1;

      if( end<=0 ) end = len;

      tmp = str.substring(begin,end);

      c.drawText( tmp, left, y, paint);

      left+= (paint.measureText(tmp)+w);

      }  

    }

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

  private int retNumSpaces(String str)

    {

    int begin=0, ret=0;

    while( true )

      {

      begin = str.indexOf(' ', begin) +1;

      if( begin>0 ) ret++;

      else break;

      }

    return ret;

    }

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

  public void effectFinished(final long effectID)

    {

    if( effectID == alphaEffectID )

      {

      mScreen.detach(mGFFAEffects);

      mGFFATexture.markForDeletion();

      int screenW = mScreen.getWidth();

      int initSize= (int)(3.00f*screenW);

      int finaSize= (int)(0.01f*screenW);

      Dynamic3D di = new Dynamic3D(10000,0.5f);

      di.add(new Static3D(initSize,initSize/mLogoRatio,1));

      di.add(new Static3D(finaSize,finaSize/mLogoRatio,1));

      MatrixEffectScale scale = new MatrixEffectScale(di);

      scale.notifyWhenFinished(this);

      scaleEffectID = scale.getID();

      mLogoEffects.apply( scale );

      mScreen.attach(mLogoTexture, mLogoEffects, mQuad);

      }

    else if( effectID == scaleEffectID )

      {

      mScreen.detach(mLogoEffects);

      mLogoTexture.markForDeletion();

      float scale = mCrawlBackgroundW/CRAWL_WIDTH;

      mCrawlBackgroundEffects.apply( new MatrixEffectScale( new Static3D(mCrawlBackgroundW, mCrawlBackgroundH, 1) ) );

      mCrawlBackgroundEffects.apply( new MatrixEffectRotate(new Static1D(CRAWL_ANGLE), new Static3D(1,0,0), new Static3D(0,-mCrawlBackgroundH/2,0)) );

      mCrawlBackgroundEffects.apply( new MatrixEffectMove(new Static3D( 0, (mCrawlBackgroundH-mHeight)/2, 0)) );

      final float transpDist = 5;

      Static3D center = new Static3D( 0, transpDist-0.5f, 0 );

      Static3D region = new Static3D( transpDist, transpDist, transpDist );

      mCrawlBackgroundEffects.apply( new FragmentEffectAlpha(new Static1D(1-transpDist*0.6f), center, region, true) );

      Dynamic3D di = new Dynamic3D(70000,0.5f);

      di.add(new Static3D(0, -(scale*CRAWL_HEIGHT+mCrawlBackgroundH)/2, 0));

      di.add(new Static3D(0, +(scale*CRAWL_HEIGHT+mCrawlBackgroundH)/2, 0));

      MatrixEffectMove move = new MatrixEffectMove(di);

      move.notifyWhenFinished(this);

      moveEffectID = move.getID();

      mCrawlEffects.apply( new MatrixEffectScale(new Static3D(scale*CRAWL_WIDTH,scale*CRAWL_HEIGHT,1)) );

      mCrawlEffects.apply( move );

      mBackground = mScreen.attach(mCrawlBackgroundTexture, mCrawlBackgroundEffects, mQuad);

      mBackground.resizeFBO(mCrawlBackgroundW,mCrawlBackgroundH);

      mBackground.attach(mCrawlTexture, mCrawlEffects, mQuad);

      mBackground.glDisable(GLES31.GL_DEPTH_TEST);

      mBackground.glDepthMask(false);

      }

    else if( effectID == moveEffectID )

      {

      mScreen.detach(mBackground);

      mBackground.detach(mCrawlEffects);

      mCrawlTexture.markForDeletion();

      mCrawlBackgroundEffects.abortAllEffects();

      mCrawlBackgroundTexture.markForDeletion();

      }

    }

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

  public void distortedException(Exception ex)

    {

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

    }

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

  public int openGlVersion()

    {

    Context context = mView.getContext();

    final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

    final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();

    int glESversion = configurationInfo.reqGlEsVersion;

    int major = glESversion >> 16;

    int minor = glESversion & 0xff;

    return 100*major + 10*minor;

    }

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

  public InputStream localFile(int fileID)

    {

    return mResources.openRawResource(fileID);

    }

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

  public void logMessage(String message)

    {

    android.util.Log.e("StarWars", message );

    }

  }