Distorted Android

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

  private float mWind;

  private Static5D  windFactor41, windFactor42;

  private Dynamic5D windDynamic4;

    lastTime = 0;

    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.setAccessMode(Dynamic.ACCESS_SEQUENTIAL);

  void apply(DistortedEffects effects)

    Static3D midLeft    = new Static3D(0,mHeight/2,0);

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

    Static3D tadRight   = new Static3D(3*mWidth/4,mHeight/2,0);

    setWind(0);

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

  private void setWind(int wind)

    mWind = wind;

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

    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.set1(wave2);

    windFactor22.set1(wave2);

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

    windFactor31.set1(wave3);

    windFactor32.set1(wave3);

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

    windFactor41.set1(wave4);

    windFactor42.set1(wave4);

    }

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

  synchronized void increaseWind(long currTime)

    {

    if( lastTime>0 )

      {

      long diff = currTime-lastTime;

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

      mWind += diffWind;

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

      setWind( (int)mWind );

      }

    lastTime = currTime;

    }

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

  synchronized void decreaseWind(long currTime)

    {

    if( lastTime>0 )

      {

      long diff = currTime-lastTime;

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

      mWind -= diffWind;

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

      setWind( (int)mWind );

      }

    lastTime = currTime;

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

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

// Copyright 2019 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 java.util.Random;

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

class WindGust

  {

  private static final long TIME_PERIOD = 1000;

  private int mAvgWind;

  private boolean mBlowingNow;

  private long mLastTime;

  private static Random mRnd = new Random();

  WindGust()

    {

    mAvgWind = 0;

    mBlowingNow = false;

    mLastTime = 0;

    }

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

  void setAverageWind(int wind)

    {

    mAvgWind = wind;

    }

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

  boolean isWindBlowingNow(long currTime)

    {

    if( mLastTime>0 )

      {

      int lastPeriod = (int)(mLastTime/TIME_PERIOD);

      int currPeriod = (int)( currTime/TIME_PERIOD);

      if( currPeriod>lastPeriod ) mBlowingNow=(mRnd.nextInt(100)<=mAvgWind);

      }

    mLastTime = currTime;

    return mBlowingNow;

    }

  }

   private WindGust mGust;

      mGust    = new WindGust();

      mManager.apply(effects);

      mGust.setAverageWind(wind);

      long time = System.currentTimeMillis();

      if( mGust.isWindBlowingNow(time) ) mManager.increaseWind(time);

      else                               mManager.decreaseWind(time);

      mScreen.render(time);

      int min = width<height? width:height;

      float factor = ((float)min)/(mObjHeight + 1.4f*mObjWidth);

      mMove.set( factor*mObjHeight*0.58f +(width-min)/2, height - factor*mObjHeight*1.08f -(height-min)/2, 0 );