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

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

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.MatrixEffectShear;

import org.distorted.library.effect.VertexEffectDeform;

import org.distorted.library.effect.VertexEffectWave;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.type.Dynamic;

import org.distorted.library.type.Dynamic5D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.library.type.Static5D;

class WindEffectsManager

  {

  private static final long TIME_TO_GET_UP    = 400; // time it takes for the max wind to

                                                     // make the flag horizontal (milliseconds)

  private static final long TIME_TO_FALL_DOWN =2000; // time it takes for the flag to

                                                     // fall back down if no wind (milliseconds)

  private long mLastTime, mPausedTime;

  private float mWind;

  private final int mHeight;

    private final int mWidth;

  private final Static3D  shearFactor;

  private final Static3D  scaleFactor;

  private final Static3D  deformForce;

  private final Static5D  windFactor11;

    private final Static5D windFactor12;

  private final Dynamic5D windDynamic1;

  private final Static5D  windFactor21;

    private final Static5D windFactor22;

  private final Dynamic5D windDynamic2;

  private final Static5D  windFactor31;

    private final Static5D windFactor32;

  private final Dynamic5D windDynamic3;

  private final Static5D  windFactor41;

    private final Static5D windFactor42;

  private final Dynamic5D windDynamic4;

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

  WindEffectsManager(int width, int height)

    {

    mLastTime = 0;

    mWidth = width;

    mHeight= height;

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

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

    deformForce = new Static3D(mWidth/3,0,0);

    windFactor11 = new Static5D(mHeight/10,mHeight/5, 180, 0, 90);

    windFactor12 = new Static5D(mHeight/10,mHeight/5,-180, 0, 90);

    windDynamic1 = new Dynamic5D(1000,0.0f);

    windDynamic1.add(windFactor11);

    windDynamic1.add(windFactor12);

    windDynamic1.setMode(Dynamic.MODE_JUMP);

    windDynamic1.setAccessType(Dynamic.ACCESS_TYPE_SEQUENTIAL);

    windFactor21 = new Static5D(mHeight/10,mHeight/5,-180, 90, 10);

    windFactor22 = new Static5D(mHeight/10,mHeight/5,+180, 90, 10);

    windDynamic2 = new Dynamic5D(1000,0.0f);

    windDynamic2.add(windFactor21);

    windDynamic2.add(windFactor22);

    windDynamic2.setMode(Dynamic.MODE_JUMP);

    windDynamic2.setAccessType(Dynamic.ACCESS_TYPE_SEQUENTIAL);

    windFactor31 = new Static5D(mHeight/10,mHeight/10,-180, 90, 90);

    windFactor32 = new Static5D(mHeight/10,mHeight/10,+180, 90, 90);

    windDynamic3 = new Dynamic5D(1000,0.0f);

    windDynamic3.add(windFactor31);

    windDynamic3.add(windFactor32);

    windDynamic3.setMode(Dynamic.MODE_JUMP);

    windDynamic3.setAccessType(Dynamic.ACCESS_TYPE_SEQUENTIAL);

    windFactor41 = new Static5D(mHeight/10,mHeight/5,-180,  0,  0);

    windFactor42 = new Static5D(mHeight/10,mHeight/5,+180,  0,  0);

    windDynamic4 = new Dynamic5D(1000,0.0f);

    windDynamic4.add(windFactor41);

    windDynamic4.add(windFactor42);

    windDynamic4.setMode(Dynamic.MODE_JUMP);

    windDynamic4.setAccessType(Dynamic.ACCESS_TYPE_SEQUENTIAL);

    }

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

  void apply(DistortedEffects effects)

    {

    Static3D midLeft   = new Static3D(-mWidth/2,0,0);

    Static3D midRight  = new Static3D( mWidth/2,0,0);

    Static3D tadRight  = new Static3D( mWidth/4,0,0);

    Static4D windRegion= new Static4D(0,0,0,mHeight);

    setWind(0);

    effects.apply( new MatrixEffectScale(scaleFactor) );

    effects.apply( new MatrixEffectShear(shearFactor,midLeft) );

    effects.apply( new VertexEffectDeform(deformForce, new Static1D(mWidth/2), midRight) );

    effects.apply( new VertexEffectWave(windDynamic1, midRight, windRegion) );

    effects.apply( new VertexEffectWave(windDynamic2, midRight, windRegion) );

    effects.apply( new VertexEffectWave(windDynamic3, midRight, windRegion) );

    effects.apply( new VertexEffectWave(windDynamic4, tadRight, windRegion) );

    }

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

  private void setWind(int wind)

    {

    mWind = wind;

    float tanAngle = (wind-50)/50.0f;

    shearFactor.set1(tanAngle);

    scaleFactor.set0(1/(float)Math.sqrt(1+tanAngle*tanAngle));

    windDynamic1.setDuration( wind > 0 ? 900 + 10000/wind : Long.MAX_VALUE);

    windDynamic2.setDuration( wind > 0 ? 720 +  8000/wind : Long.MAX_VALUE);

    windDynamic3.setDuration( wind > 0 ? 900 + 10000/wind : Long.MAX_VALUE);

    float wave2 = mHeight*( 0.05f + 0.002f*wind);

    windFactor21.set0(wave2);

    windFactor22.set0(wave2);

    float wave3 = (mHeight/(wind+5.0f));

    windFactor31.set0(wave3);

    windFactor32.set0(wave3);

    float wave4 = (mHeight*(wind*(100-wind)/50000.0f));

    windFactor41.set0(wave4);

    windFactor42.set0(wave4);

    }

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

  void pauseWind()

    {

    mPausedTime = System.currentTimeMillis();

    }

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

  void resumeWind()

    {

    long gap = System.currentTimeMillis() - mPausedTime;

    mLastTime += gap;

    }

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

  synchronized void increaseWind(long currTime)

    {

    if( mLastTime>0 )

      {

      long diff = currTime-mLastTime;

      float diffWind = (100.0f*diff/TIME_TO_GET_UP);

      mWind += diffWind;

      if( mWind>100.0f ) mWind=100.0f;

      setWind( (int)mWind );

      }

    mLastTime = currTime;

    }

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

  synchronized void decreaseWind(long currTime)

    {

    if( mLastTime>0 )

      {

      long diff = currTime-mLastTime;

      float diffWind = (100.0f*diff/TIME_TO_FALL_DOWN);

      mWind -= diffWind;

      if( mWind<0.0f ) mWind=0.0f;

      setWind( (int)mWind );

      }

    mLastTime = currTime;

    }

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

  }