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

import android.app.ActivityManager;

import android.content.Context;

import android.content.pm.ConfigurationInfo;

import android.graphics.Rect;

import android.opengl.GLSurfaceView;

import android.view.MotionEvent;

import android.util.AttributeSet;

import android.graphics.Canvas;

import android.graphics.Paint.Style;

import android.graphics.Paint;

import org.distorted.library.type.Dynamic;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Dynamic2D;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static2D;

import org.distorted.library.type.Static3D;

import java.lang.ref.WeakReference;

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

public class DynamicSurfaceView extends GLSurfaceView

    {

    public static final int DIM_1D   = 0; 

    public static final int DIM_2D   = 1; 

    public static final int DIM_3DXY = 2; 

    public static final int DIM_3DXZ = 3; 

    static final int NUM_POINTS = 250;

    private static final Object lock = new Object();

    private WeakReference<DynamicActivity> mAct;

    private static int halfScreenHeight=0;

    private static int halfScreenWidth =0;

    private Dynamic1D di1D;

    private Dynamic2D di2D;

    private Dynamic3D di3D;

    private Paint mPaint;

    private int mMoving;

    private int mDuration;

    private int mPosition;

    private long mDiffTime, mLastTime, mStartTime;

    private float mNoise0, mNoise1, mNoise2;

    private float mCount;

    private int mSize1, mSize2, mSizeT, mAvg;

    private float mFontHeight;

    private int currentDim= DIM_2D;

    private Static1D p1D;

    private Static2D p2D;

    private Static3D p3D;

    private Static1D p1N;

    private Static2D p2N;

    private Static3D p3N;

    private float[] mPoints = new float[3*NUM_POINTS];

    private boolean mRunning;

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

    public DynamicSurfaceView(Context context, AttributeSet attrs)

      {

      super(context, attrs);

      DynamicActivity act = (DynamicActivity)context;

      mAct = new WeakReference<>(act);

      mPaint = new Paint();

      mPaint.setStyle(Style.FILL);

      mPaint.setAntiAlias(true);

      mMoving = -1;

      mDuration = 10000;

      mCount    = 0.0f;

      mPosition = 0;

      mNoise0   = 0.0f;

      mNoise1   = 0.0f;

      mNoise2   = 0.0f;

      mDiffTime = -1;

      mLastTime = -1;

      mStartTime= -1;

      mRunning = false;

      clearPoints();

      di1D = new Dynamic1D(mDuration,mCount);

      p1N  = new Static1D(mNoise0);

      di2D = new Dynamic2D(mDuration,mCount);

      p2N  = new Static2D(mNoise0,mNoise1);

      di3D = new Dynamic3D(mDuration,mCount);

      p3N  = new Static3D(mNoise0,mNoise1,mNoise2);

      di1D.setAccessType(Dynamic.ACCESS_TYPE_SEQUENTIAL);

      di2D.setAccessType(Dynamic.ACCESS_TYPE_SEQUENTIAL);

      di3D.setAccessType(Dynamic.ACCESS_TYPE_SEQUENTIAL);

      if(!isInEditMode())

        {

        setFocusable(true);

        setFocusableInTouchMode(true);

        DynamicRenderer mRenderer = new DynamicRenderer(this);

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

        final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();

        setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );

        setRenderer(mRenderer);

        }

      }

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

    public void onSurfaceChanged(int width,int height)

      {

      mAvg = (width+height)/2;

      mSize1 = mAvg/150;

      mSize2 = mAvg/50;

      mSizeT = mAvg/30;

      mPaint.setTextSize(mSizeT);

      mPaint.setTextAlign(Paint.Align.CENTER);

      final Rect textBounds = new Rect();

      String text = "1";

      mPaint.getTextBounds(text, 0, text.length(), textBounds);

      mFontHeight = textBounds.exactCenterY();

      clearPoints();

      }

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

    public static void setHalfWidth(int hw)

      {

      halfScreenWidth = hw;

      }

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

    public static void setHalfHeight(int hh)

      {

      halfScreenHeight = hh;

      }

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

    public void setMode(int mode)

      {

      di1D.setMode(mode);  

      di2D.setMode(mode);

      di3D.setMode(mode);

      }

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

    public void setDuration(int duration)

      {

      mDuration = duration;

      di1D.setDuration(duration);

      di2D.setDuration(duration);

      di3D.setDuration(duration);

      }

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

    public void setCount(float count)

      {

      mCount = count;

      di1D.setCount(count);

      di2D.setCount(count);

      di3D.setCount(count);

      }

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

    public void setNoise(float noise0, float noise1, float noise2)

      {

      mNoise0 = noise0;

      mNoise1 = noise1;

      mNoise2 = noise2;

      p1N.set(mNoise0);

      p2N.set(mNoise0,mNoise1);

      p3N.set(mNoise0,mNoise1,mNoise2);

      di1D.setNoise(p1N);

      di2D.setNoise(p2N);

      di3D.setNoise(p3N);

      }

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

    public void setDimension(int dim)

      {

      if( currentDim != dim )

        {

        if( !(currentDim==DIM_3DXY && dim==DIM_3DXZ) && !(currentDim==DIM_3DXZ && dim==DIM_3DXY) )

          {

          resetPoints();

          }

        currentDim = dim;

        }

      }

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

    public void drawCurve(Canvas c, long time)

      {

      if( mLastTime<0 )

        {

        mLastTime = time;

        }

      else

        {

        mDiffTime = time - mLastTime;

        }

      synchronized(lock)

        {

        switch(currentDim)

          {

          case DIM_1D: drawHorizontalAxis(c,"x");

                       drawPath(c,di1D,1,time);

                       drawRedPoints1D(c);

                       break;

          case DIM_2D: drawHorizontalAxis(c,"x");

                       drawVerticalAxis  (c,"y");

                       drawPath(c,di2D,1,time);

                       drawRedPoints2D(c);

                       break;

          default    : drawHorizontalAxis(c,"x");

                       drawVerticalAxis  (c, currentDim==DIM_3DXY ? "y" : "z" );

                       drawPath(c,di3D,(currentDim==DIM_3DXY ? 1:2),time);

                       drawRedPoints3D(c);

                       break;

          }

        }

      mLastTime = time;

      }

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

    private void clearPoints()

      {

      for(int i=0; i<3*NUM_POINTS; i++)

         {

         mPoints[i] = -100000.0f;

         }

      }

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

    public void resetPoints()

      {

      synchronized(lock)

        {

        clearPoints();

        switch(currentDim)

          {

          case DIM_1D  : di1D.removeAll(); break;

          case DIM_2D  : di2D.removeAll(); break;

          case DIM_3DXY:

          case DIM_3DXZ: di3D.removeAll(); break;

          }

        DynamicActivity act = mAct.get();

        act.setNumRedPoints(0);

        act.clearPoints();

        }

      }

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

    public void startDynamic()

      {

      mRunning = true;

      mLastTime= -1;

      mStartTime = System.currentTimeMillis();

      clearPoints();

      di1D.resetToBeginning();

      di2D.resetToBeginning();

      di3D.resetToBeginning();

      }

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

    public void stopDynamic()

      {

      mRunning = false;

      }

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

    private void drawHorizontalAxis(Canvas c, String label)

      {

      mPaint.setColor(0xff000000);

      c.drawLine(0, halfScreenHeight, halfScreenWidth*2, halfScreenHeight, mPaint);

      c.drawText( label, 0.95f*halfScreenWidth*2, halfScreenHeight + mSizeT , mPaint);

      }

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

    private void drawVerticalAxis(Canvas c, String label)

      {

      mPaint.setColor(0xff000000);

      c.drawLine(halfScreenWidth, 0, halfScreenWidth, halfScreenHeight*2, mPaint);

      c.drawText(label, halfScreenWidth + mSizeT,                mSizeT , mPaint);

      }

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

    private void drawPath(Canvas c, Dynamic dyn, int index, long time)

      {

      int len = dyn.getNumPoints();

      if( len>=2 )

        {

        if( mRunning )

          {

          if ( ++mPosition >= NUM_POINTS ) mPosition=0;

          if( dyn.getDimension()==1 )

            {

            mPoints[3*mPosition+index] = halfScreenHeight;

            }

          if( dyn.get(mPoints,3*mPosition, time-mStartTime, mDiffTime) )

            {

            stopDynamic();

            }

          addNewSpeedPoint(time);

          }

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

          {

          int color = i<=mPosition ? 0xff - (mPosition           -i)*0xff/(NUM_POINTS-1)

                                   : 0xff - (mPosition+NUM_POINTS-i)*0xff/(NUM_POINTS-1);

          mPaint.setColor( 0xffffff + ((color&0xff)<<24) );

          c.drawCircle(mPoints[3*i], mPoints[3*i+index] , mSize1, mPaint );

          }

        }

      }

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

    private void drawRedPoints1D(Canvas c)

      {

      int len = di1D.getNumPoints();

      for(int curr=0; curr<len; curr++)

        {

        p1D = di1D.getPoint(curr);

        drawRedPoint(c,curr+"", p1D.get1(), halfScreenHeight);

        }

      }

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

    private void drawRedPoints2D(Canvas c)

      {

      int len = di2D.getNumPoints();

      for(int curr=0; curr<len; curr++)

        {

        p2D = di2D.getPoint(curr);

        drawRedPoint(c,curr+"", p2D.get1(), p2D.get2());

        }

      }

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

    private void drawRedPoints3D(Canvas c)

      {

      int len = di3D.getNumPoints();

      for(int curr=0; curr<len; curr++)

        {

        p3D = di3D.getPoint(curr);

        drawRedPoint(c,curr+"", p3D.get1(), currentDim==DIM_3DXY ? p3D.get2():p3D.get3());

        }

      }

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

    private void drawRedPoint(Canvas c, String label, float width, float height)

      {

      mPaint.setColor(0xffff0000);

      c.drawCircle( width, height, mSize2, mPaint);

      mPaint.setColor(0xffffffff);

      c.drawText(label, width,height-mFontHeight, mPaint);

      }

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

    private void addNewPoint(int x, int y)

      {

      float gx,gy,gz;

      int len;

      switch(currentDim)

        {

        case DIM_1D: len = di1D.getNumPoints();

                     for(int g=0; g<len; g++)

                       {

                       p1D = di1D.getPoint(g);  

                       gx = p1D.get1();

                       if( (x-gx)*(x-gx) < (mAvg*mAvg/100) )

                         {

                         mMoving = g;

                         break;

                         }

                       }

                     if( mMoving <0 )

                       {

                       synchronized(lock)

                         {

                         di1D.add(new Static1D(x));

                         mAct.get().setNumRedPoints(len+1);

                         }

                       }

                     break;

        case DIM_2D: len = di2D.getNumPoints();

                     for(int g=0; g<len; g++)

                       {

                       p2D = di2D.getPoint(g);  

                       gx = p2D.get1();

                       gy = p2D.get2();

                       if( (x-gx)*(x-gx) + (y-gy)*(y-gy) < (mAvg*mAvg/100) )

                         {

                         mMoving = g;

                         break;

                         }

                       }

                     if( mMoving <0 )

                       {

                       synchronized(lock)

                         {

                         di2D.add(new Static2D(x,y));

                         mAct.get().setNumRedPoints(len+1);

                         }

                       }

                     break;

        default    : len = di3D.getNumPoints();

                     for(int g=0; g<len; g++)

                       {

                       p3D = di3D.getPoint(g);  

                       gx = p3D.get1();

                       gy = p3D.get2();

                       gz = p3D.get3();

                     if( currentDim==DIM_3DXY )

                       {

                       if( (x-gx)*(x-gx) + (y-gy)*(y-gy) < (mAvg*mAvg/100) )

                         {

                         mMoving = g;

                         break;

                         }

                       }

                     if( currentDim==DIM_3DXZ )

                       {

                       if( (x-gx)*(x-gx) + (y-gz)*(y-gz) < (mAvg*mAvg/100) )

                         {

                         mMoving = g;

                         break;

                         }

                       }

                     }

                   if( mMoving <0 )

                     { 

                     synchronized(lock)

                       {

                       if( currentDim==DIM_3DXY ) di3D.add(new Static3D(x,y, halfScreenHeight));

                       if( currentDim==DIM_3DXZ ) di3D.add(new Static3D(x, halfScreenHeight,y));

                       mAct.get().setNumRedPoints(len+1);

                       }

                     }

                   break; 

        }

      }

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

    private void addNewSpeedPoint(long time)

      {

      int prev = mPosition-1;

      if( prev<0 ) prev = NUM_POINTS-1;

      float xdiff = mPoints[3*prev  ]-mPoints[3*mPosition  ];

      float ydiff = mPoints[3*prev+1]-mPoints[3*mPosition+1];

      float zdiff = mPoints[3*prev+2]-mPoints[3*mPosition+2];

      float dist = (float)Math.sqrt( xdiff*xdiff + ydiff*ydiff + zdiff*zdiff );

      float speed= mDiffTime<=0 ? 0: dist / mDiffTime;

      float timepoint = ((float)(time-mStartTime))/mDuration;

      if( dist<1000.0f )   // otherwise this is a very first call; do not send it!

        {

        mAct.get().addPoint( timepoint - (int)timepoint, speed );

        }

      }

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

    @Override

    public boolean onTouchEvent(MotionEvent event)

      {

      int action = event.getAction();

      int xDown, yDown;

      switch(action)

        {

        case MotionEvent.ACTION_DOWN: xDown = (int)event.getX();

                                      yDown = (int)event.getY();

                                      addNewPoint(xDown,yDown);

                                      break;

        case MotionEvent.ACTION_MOVE: if( mMoving >=0 )

                                        {

                                        xDown = (int)event.getX();

                                        yDown = (int)event.getY();

                                        switch(currentDim)

                                          {

                                          case DIM_1D  : di1D.setPoint(mMoving, xDown);

                                                         break;

                                          case DIM_2D  : di2D.setPoint(mMoving, xDown, yDown);

                                                         break;

                                          case DIM_3DXY: di3D.setPoint(mMoving, xDown, yDown, (int)di3D.getPoint(mMoving).get3());

                                                         break;

                                          case DIM_3DXZ: di3D.setPoint(mMoving, xDown, (int)di3D.getPoint(mMoving).get2(), yDown);

                                                         break;

                                          }

                                        }                           

                                      break;

        case MotionEvent.ACTION_UP  : mMoving = -1;

                                      break;

        }

      return true;

      }

  }