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.content.Context;

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;

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

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; 

    private static final int NUM_POINTS = 250;

    private static final int MAX_POINTS =   6;

    private static final Object lock = new Object();

    private Dynamic1D di1D;

    private Dynamic2D di2D;

    private Dynamic3D di3D;

    private Paint mPaint;

    private int moving;

    private int mDuration;

    private int mPosition;

    private long mDiffTime, mLastTime;

    private float mNoise0, mNoise1, mNoise2;

    private int mSize1, mSize2, mSizeT, mAvg;

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

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

    public DynamicSurfaceView(Context context, AttributeSet attrs)

      {

      super(context, attrs);

      mPaint = new Paint();

      mPaint.setStyle(Style.FILL);

      mPaint.setAntiAlias(true);

      moving    = -1;

      mDuration = 10000;

      mPosition = 0;

      mNoise0   = 0.0f;

      mNoise1   = 0.0f;

      mNoise2   = 0.0f;

      mDiffTime = -1;

      mLastTime = -1;

      di1D = new Dynamic1D(mDuration,0.0f);

      p1N  = new Static1D(mNoise0);

      di2D = new Dynamic2D(mDuration,0.0f);

      p2N  = new Static2D(mNoise0,mNoise1);

      di3D = new Dynamic3D(mDuration,0.0f);

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

      di1D.setAccessMode(Dynamic.ACCESS_SEQUENTIAL);

      di2D.setAccessMode(Dynamic.ACCESS_SEQUENTIAL);

      di3D.setAccessMode(Dynamic.ACCESS_SEQUENTIAL);

      if(!isInEditMode())

        {

        setFocusable(true);

        setFocusableInTouchMode(true);

        DynamicRenderer mRenderer = new DynamicRenderer(this);

        setRenderer(mRenderer);

        }

      }

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

    public void onSurfaceChanged(int width,int height)

      {

      mAvg = (width+height)/2;

      mSize1 = mAvg/150;

      mSize2 = mAvg/60;

      mSizeT = mAvg/30;

      mPaint.setTextSize(mSizeT);

      clearPoints();

      }

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

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

          {

          synchronized(lock)

            {

            di1D.removeAll();

            di2D.removeAll();

            di3D.removeAll();

            clearPoints();

            }

          }

        currentDim = dim;

        }

      }

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

    public void drawCurve(Canvas c, long time)

      {

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

      if( mLastTime<0 )

        {

        mLastTime = time;

        }

      else

        {

        mDiffTime = time - mLastTime;

        }

      synchronized(lock)

        {

        switch(currentDim)

          {

          case DIM_1D: drawCurve1D(c,time); break;

          case DIM_2D: drawCurve2D(c,time); break;

          default    : drawCurve3D(c,time); break;

          }

        }

      mLastTime = time;

      }

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

    private void clearPoints()

      {

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

         {

         mPoints[i] = -10.0f;

         }

      }

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

    private void drawCurve1D(Canvas c, long time)

      {

      int len = di1D.getNumPoints();   

      mPaint.setColor(0xff000000);

      c.drawLine(0, DynamicRenderer.texH/2, DynamicRenderer.texW, DynamicRenderer.texH/2, mPaint);

      c.drawText("x", 0.95f*DynamicRenderer.texW, DynamicRenderer.texH /2 + mSizeT , mPaint);

      if( len>=2 )

        {

        di1D.get(mPoints,3*mPosition, time, mDiffTime);

        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], DynamicRenderer.texH/2 , mSize1, mPaint );

          }

        }

      mPaint.setColor(0xffff0000);

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

        {      

        p1D = di1D.getPoint(curr);

        c.drawCircle(p1D.getX(), DynamicRenderer.texH/2 , mSize2, mPaint);

        }   

      }

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

    private void drawCurve2D(Canvas c, long time)

      {

      int len = di2D.getNumPoints();   

      mPaint.setColor(0xff000000);

      c.drawLine(0, DynamicRenderer.texH/2, DynamicRenderer.texW, DynamicRenderer.texH/2, mPaint);

      c.drawLine(DynamicRenderer.texW/2, 0, DynamicRenderer.texW/2, DynamicRenderer.texH, mPaint);

      c.drawText("x", 0.95f* DynamicRenderer.texW    , DynamicRenderer.texH/2+mSizeT , mPaint);

      c.drawText("y", DynamicRenderer.texW/2 + mSizeT,                        mSizeT , mPaint);

      if( len>=2 )

        {

        di2D.get(mPoints,3*mPosition, time, mDiffTime);

        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+1], mSize1, mPaint );

          }

        }

      mPaint.setColor(0xffff0000);

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

        {      

        p2D = di2D.getPoint(curr);

        c.drawCircle(p2D.getX(),p2D.getY(), mSize2, mPaint);

        }

      }

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

    private void drawCurve3D(Canvas c, long time)

      {

      int len = di3D.getNumPoints();   

      mPaint.setColor(0xff000000);

      c.drawLine(0, DynamicRenderer.texH/2, DynamicRenderer.texW  , DynamicRenderer.texH/2, mPaint);

      c.drawLine(DynamicRenderer.texW/2, 0, DynamicRenderer.texW/2, DynamicRenderer.texH  , mPaint);

      c.drawText( "x"                             , 0.95f* DynamicRenderer.texW    , DynamicRenderer.texH/2 + mSizeT , mPaint);

      c.drawText( currentDim==DIM_3DXY ? "y" : "z", DynamicRenderer.texW/2 + mSizeT,                          mSizeT , mPaint);

      if( len>=2 )

        {

        di3D.get(mPoints, 3*mPosition, time, mDiffTime);

        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 + (currentDim==DIM_3DXY ? 1:2) ], mSize1, mPaint );

          }

        }

      mPaint.setColor(0xffff0000);

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

        {      

        p3D = di3D.getPoint(curr);

        c.drawCircle(p3D.getX(), currentDim==DIM_3DXY ? p3D.getY():p3D.getZ(), mSize2, 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.getX();

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

                         {

                         moving = g;

                         break;

                         }

                       }

                     if( moving<0 )

                       {

                       synchronized(lock)

                         {

                         if( len>=MAX_POINTS )

                           {

                           di1D.removeAll();

                           clearPoints();

                           }

                         di1D.add(new Static1D(x));

                         }

                       }

                     break;

        case DIM_2D: len = di2D.getNumPoints();

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

                       {

                       p2D = di2D.getPoint(g);  

                       gx = p2D.getX();

                       gy = p2D.getY();

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

                         {

                         moving = g;

                         break;

                         }

                       }

                     if( moving<0 )

                       {

                       synchronized(lock)

                         {

                         if( len>=MAX_POINTS )

                           {

                           di2D.removeAll();

                           clearPoints();

                           }

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

                         }

                       }

                     break;

        default    : len = di3D.getNumPoints();

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

                       {

                       p3D = di3D.getPoint(g);  

                       gx = p3D.getX();

                       gy = p3D.getY();

                       gz = p3D.getZ();

                     if( currentDim==DIM_3DXY )

                       {

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

                         {

                         moving = g;

                         break;

                         }

                       }

                     if( currentDim==DIM_3DXZ )

                       {

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

                         {

                         moving = g;

                         break;

                         }

                       }

                     }

                   if( moving<0 )

                     { 

                     synchronized(lock)

                       {

                       if( len>=MAX_POINTS )

                         {

                         di3D.removeAll();

                         clearPoints();

                         }

                       if( currentDim==DIM_3DXY )

                         {

                         di3D.add(new Static3D(x,y, DynamicRenderer.texH/2));

                         }

                       if( currentDim==DIM_3DXZ )

                         {

                         di3D.add(new Static3D(x, DynamicRenderer.texH/2,y));

                         }

                       }

                     }

                   break; 

        }

      }

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

    @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( moving>=0 )

                                        {

                                        xDown = (int)event.getX();

                                        yDown = (int)event.getY();

                                        switch(currentDim)

                                          {

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

                                                         break;

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

                                                         break;

                                          case DIM_3DXY: di3D.setPoint(moving, xDown, yDown, (int)di3D.getPoint(moving).getZ());

                                                         break;

                                          case DIM_3DXZ: di3D.setPoint(moving, xDown, (int)di3D.getPoint(moving).getY(), yDown);

                                                         break;

                                          }

                                        }                           

                                      break;

        case MotionEvent.ACTION_UP  : moving = -1;

                                      break;

        }

      return true;

      }

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

  }