Distorted Android

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

import org.distorted.library.Interpolator3D;

import org.distorted.library.DistortedNode;

import org.distorted.library.Float1D;

import org.distorted.library.Float2D;

import org.distorted.library.Float3D;

import org.distorted.library.Float4D;

import org.distorted.library.EffectListener;

import org.distorted.library.EffectMessage;

import org.distorted.library.Distorted;

import org.distorted.library.DistortedBitmap;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.Typeface;

import android.opengl.GLES20;

import android.opengl.GLSurfaceView;

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

class StarWarsRenderer implements GLSurfaceView.Renderer, EffectListener

{

   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 GLSurfaceView mView;

   private DistortedBitmap mScreen, mGFFA, mLogo, mCrawl, mCrawlBackground;

   private DistortedBitmap[] mStars;

   private long gffaID, logoID, crawlID;

   private Random mRnd = new Random(0);

   private DistortedNode mRoot, mBackground;

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

   public StarWarsRenderer(GLSurfaceView v) 

     {

     mView = v;

     Distorted.setFov(60.0f);

     }

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

    public void onDrawFrame(GL10 glUnused) 

      {

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

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

      mRoot.draw(System.currentTimeMillis());

      }

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

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

      { 

      Distorted.onSurfaceChanged(width, height); 

      setupScreen(width,height);

      }

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

    public void onSurfaceCreated(GL10 glUnused, EGLConfig config) 

      {

      setupBitmaps();

      try

        {

        Distorted.onSurfaceCreated(mView.getContext());

        }

      catch(Exception ex)

        {

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

        }

      }

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

    private void setupScreen(int w, int h)

      {

      mScreen = new DistortedBitmap(w,h,1);

      mRoot = new DistortedNode(mScreen);

      mCrawlBackground = new DistortedBitmap(w,(int)(Math.sqrt(3.0)*h),1);

      int randomA, randomX, randomY, randomTime;

      float randomS, randomAlpha1, randomAlpha2;

      Float3D rot = new Float3D(0,0,0);

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

        {

        randomX = mRnd.nextInt(w);

        randomY = mRnd.nextInt(h);

        randomS = 0.2f+ mRnd.nextFloat();

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

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

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

        randomTime = 500+mRnd.nextInt(2000);

        mStars[i].move( randomX,randomY,0);

        mStars[i].scale(randomS);

        mStars[i].rotate( rot, randomA);

        Interpolator1D di = new Interpolator1D();

        di.setDuration(randomTime);

        di.setCount(0.0f);

        di.setNoise(0.3f);

        di.add(new Float1D(randomAlpha1));

        di.add(new Float1D(randomAlpha2));

        mStars[i].alpha(di, null, new Float2D(0,0));

        mRoot.attach(mStars[i]);

        }

      float scale = (0.5f*w/mGFFA.getWidth());

      Interpolator1D di = new Interpolator1D();

      di.setDuration(6000);

      di.setCount(0.5f);

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

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

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

      mGFFA.move( w/5, h/3, 0);

      mGFFA.scale(scale);

      mGFFA.alpha(di, null, new Float2D(0,0));

      mRoot.attach(mGFFA);

      mGFFA.addEventListener(this); 

      }

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

    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 ///////////////////

      mGFFA  = new DistortedBitmap(GFFA_WIDTH, GFFA_HEIGHT, 1);

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

        }

      mGFFA.setBitmap(bitmapGFFA);

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

      mLogo  = new DistortedBitmap(bitmapLogo, 1);

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

      mCrawl = new DistortedBitmap(CRAWL_WIDTH, CRAWL_HEIGHT, 1);

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

        }

      mCrawl.setBitmap(bitmapText);

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

      mStars = new DistortedBitmap[NUM_STARS];

      mStars[0] = new DistortedBitmap(bitmapStar,1);

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

        {

        mStars[i] = new DistortedBitmap(mStars[0], Distorted.CLONE_BITMAP|Distorted.CLONE_VERTEX);  

        }

      gffaID = mGFFA.getID();

      logoID = mLogo.getID();

      crawlID= mCrawl.getID();

      }

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

   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 effectMessage(final EffectMessage em, final long effectID, final int effectName, final long bitmapID, final String message)

      {

      if( em==EffectMessage.EFFECT_FINISHED )

        {

        if( bitmapID == gffaID )

          {

          mRoot.detach(mGFFA);   

          mGFFA.removeEventListener(this);

          int screenW=mScreen.getWidth();

          int screenH=mScreen.getHeight();

          int logoW = mLogo.getWidth();

          int logoH = mLogo.getHeight();

          int initSize= (int)(3.0f*screenW/logoW);

          int finaSize= (int)(0.1f*screenW/logoW);

          Interpolator3D di = new Interpolator3D();

          di.add(new Float3D(initSize,initSize,1));

          di.add(new Float3D(finaSize,finaSize,1));

          di.setCount(0.5f);

          di.setDuration(10000);

          mLogo.move( screenW/2, screenH/2, 0);

          mLogo.scale(di);

          mLogo.move( -logoW/2, -logoH/2, 0);

          mRoot.attach(mLogo);

          mLogo.addEventListener(this);

          }

        else if( bitmapID==logoID )

          {

          mRoot.detach(mLogo);   

          mLogo.removeEventListener(this);

          int crawlW = mCrawl.getWidth();

          int crawlH = mCrawl.getHeight();

          int screenW= mScreen.getWidth();

          int screenH= mScreen.getHeight();

          int backH  = mCrawlBackground.getHeight();

          float scale= (float)screenW/crawlW;

          Interpolator3D di = new Interpolator3D();

          di.setCount(0.5f);

          di.setDuration(60000);

          di.add(new Float3D(screenW/2,+backH       , 0));

          di.add(new Float3D(screenW/2,-scale*crawlH, 0));

          mCrawlBackground.move(0,screenH-backH,0);

          mCrawlBackground.rotate(new Float3D(screenW/2,backH,0), CRAWL_ANGLE, 1.0f, 0.0f, 0.0f);

          final int transpDistance = 5;

          mCrawlBackground.smooth_alpha((1-transpDistance/2)*1.0f, new Float4D(0,0,transpDistance*backH,transpDistance*backH), new Float2D(screenW/2,(1-transpDistance)*backH));

          mCrawl.move(di);

          mCrawl.scale(scale);

          mCrawl.move(-crawlW/2,0,0);

          mBackground = mRoot.attach(mCrawlBackground);

          mBackground.attach(mCrawl);

          mCrawl.addEventListener(this);

          }

        else if( bitmapID==crawlID )

          {

          mRoot.detach(mBackground);

          mBackground.detach(mCrawl);

          mCrawl.removeEventListener(this);

          }

        }

      }

}

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