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

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

  {

  private final String[] mGFFAString = 

  private final String[] mCRAWLString = 

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

      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 

      {

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

    }

  }