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.os.Build;

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.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_INTERPOLATIONS= 100;

    private static final int MAX_VECTORS       =   6;

    private static final Object lock = new Object();

    private static int xDown,yDown;

    private static int mScrW, mScrH;

    private static Dynamic1D di1D;

    private static Dynamic2D di2D;

    private static Dynamic3D di3D;

    private static Paint mPaint;

    private static int moving;

    private static long mTime = 0;

    private static int mDuration;

    private static float mPosition;

    private static float mNoise0, mNoise1, mNoise2;

    private static int currentDim = DIM_2D;

    private static Static1D p1D;

    private static Static2D p2D;

    private static Static3D p3D;

    private static Static1D p1N;

    private static Static2D p2N;

    private static Static3D p3N;

    private static float[] mDrawCoord = new float[3];

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

    public DynamicSurfaceView(Context c, AttributeSet attrs)

      {

      super(c, 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;

      di1D = new Dynamic1D(mDuration,0.5f);

      p1N = new Static1D(mNoise0);

      di1D.setNoise(p1N);

      di2D = new Dynamic2D(mDuration,0.5f);

      p2N = new Static2D(mNoise0,mNoise1);

      di2D.setNoise(p2N);

      di3D = new Dynamic3D(mDuration,0.5f);

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

      di3D.setNoise(p3N);

      if(!isInEditMode())

        {

        setFocusable(true);

        setFocusableInTouchMode(true);

        setEGLContextClientVersion(2);

        if( Build.FINGERPRINT.startsWith("generic") ) // when running on the emulator, insert a magic line that is

          {                                           // supposed to cure the 'no config chosen' crash on emulator startup

          setEGLConfigChooser(8, 8, 8, 8, 16, 0);   

          }

        DynamicRenderer mRenderer = new DynamicRenderer(this);

        setRenderer(mRenderer);

        }

      }

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

    public static void setMode(int mode)

      {

      di1D.setMode(mode);  

      di2D.setMode(mode);

      di3D.setMode(mode);

      }

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

    public static void setScreenSize(int width, int height)

      {

      mScrW = width;

      mScrH = height;

      }

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

    public static void setDuration(int duration)

      {

      mDuration = duration;

      di1D.setDuration(duration);

      di2D.setDuration(duration);

      di3D.setDuration(duration);

      }

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

    public static 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 static 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();

            }

          }

        currentDim = dim;

        }

      }

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

    public static void drawCurve(Canvas c, long time)

      {

      mPosition += (mTime>0 && mDuration>0) ? ((float)(time-mTime)*NUM_INTERPOLATIONS/mDuration) : 0; 

      synchronized(lock)

        {

        switch(currentDim)

          {

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

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

          default    : drawCurve3D(c,time); break;

          }

        }

      mTime = time;

      }

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

    private static void drawCurve1D(Canvas c, long time)

      {

      int len = di1D.getNumPoints();   

      mPaint.setColor(0xff000000);

      c.drawLine(0, DynamicRenderer.BHEI/2, DynamicRenderer.BWID, DynamicRenderer.BHEI/2, mPaint);

      c.drawText("x", 0.95f* DynamicRenderer.BWID, 0.55f* DynamicRenderer.BHEI , mPaint);

      if( len>=2 )

        {

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

          {

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

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

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

          di1D.interpolate(mDrawCoord,0, (float)i/NUM_INTERPOLATIONS);

          c.drawCircle(mDrawCoord[0], DynamicRenderer.BHEI/2 , 2.0f, mPaint );

          }

        }

      mPaint.setColor(0xffff0000);

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

        {      

        p1D = di1D.getPoint(curr);

        c.drawCircle(p1D.getX(), DynamicRenderer.BHEI/2 , 5.0f, mPaint);

        }   

      }

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

    private static void drawCurve2D(Canvas c, long time)

      {

      int len = di2D.getNumPoints();   

      mPaint.setColor(0xff000000);

      c.drawLine(0, DynamicRenderer.BHEI/2, DynamicRenderer.BWID, DynamicRenderer.BHEI/2, mPaint);

      c.drawLine(DynamicRenderer.BWID/2, 0, DynamicRenderer.BWID/2, DynamicRenderer.BHEI, mPaint);

      c.drawText("x", 0.95f* DynamicRenderer.BWID, 0.55f* DynamicRenderer.BHEI , mPaint);

      c.drawText("y", 0.55f* DynamicRenderer.BWID, 0.05f* DynamicRenderer.BHEI , mPaint);

      if( len>=2 )

        {

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

          {

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

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

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

          di2D.interpolate(mDrawCoord,0, (float)i/NUM_INTERPOLATIONS);

          c.drawCircle(mDrawCoord[0], mDrawCoord[1], 2.0f, mPaint );

          }

        }

      mPaint.setColor(0xffff0000);

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

        {      

        p2D = di2D.getPoint(curr);

        c.drawCircle(p2D.getX(),p2D.getY(), 5.0f, mPaint);

        }

      }

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

    private static void drawCurve3D(Canvas c, long time)

      {

      int len = di3D.getNumPoints();   

      mPaint.setColor(0xff000000);

      c.drawLine(0, DynamicRenderer.BHEI/2, DynamicRenderer.BWID, DynamicRenderer.BHEI/2, mPaint);

      c.drawLine(DynamicRenderer.BWID/2, 0, DynamicRenderer.BWID/2, DynamicRenderer.BHEI, mPaint);

      c.drawText("x", 0.95f* DynamicRenderer.BWID, 0.55f* DynamicRenderer.BHEI , mPaint);

      c.drawText( currentDim==DIM_3DXY ? "y" : "z", 0.55f* DynamicRenderer.BWID, 0.05f* DynamicRenderer.BHEI , mPaint);

      if( len>=2 )

        {

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

          {

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

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

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

          di3D.interpolate(mDrawCoord,0, (float)i/NUM_INTERPOLATIONS);

          c.drawCircle(mDrawCoord[0], mDrawCoord[currentDim==DIM_3DXY ? 1:2], 2.0f, 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(), 5.0f, 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( (xDown-gx)*(xDown-gx) < (DynamicRenderer.BHEI)*(DynamicRenderer.BHEI)/100 )

                         {

                         moving = g;

                         break;

                         }

                       }

                     if( moving<0 )

                       {

                       synchronized(lock)

                         {

                         if( len>=MAX_VECTORS ) di1D.removeAll();

                         di1D.add(new Static1D(xDown));

                         }

                       }

                     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( (xDown-gx)*(xDown-gx) + (yDown-gy)*(yDown-gy) < (DynamicRenderer.BHEI)*(DynamicRenderer.BHEI)/100 )

                         {

                         moving = g;

                         break;

                         }

                       }

                     if( moving<0 )

                       {

                       synchronized(lock)

                         {

                         if( len>=MAX_VECTORS ) di2D.removeAll();

                         di2D.add(new Static2D(xDown,yDown));

                         }

                       }

                     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( (xDown-gx)*(xDown-gx) + (yDown-gy)*(yDown-gy) < (DynamicRenderer.BHEI)*(DynamicRenderer.BHEI)/100 )

                         {

                         moving = g;

                         break;

                         }

                       }

                     if( currentDim==DIM_3DXZ )

                       {

                       if( (xDown-gx)*(xDown-gx) + (yDown-gz)*(yDown-gz) < (DynamicRenderer.BHEI)*(DynamicRenderer.BHEI)/100 )

                         {

                         moving = g;

                         break;

                         }

                       }

                     }

                   if( moving<0 )

                     { 

                     synchronized(lock)

                       {

                       if( len>=MAX_VECTORS ) di3D.removeAll();

                       if( currentDim==DIM_3DXY )

                         {

                         di3D.add(new Static3D(xDown,yDown, DynamicRenderer.BHEI/2));

                         }

                       if( currentDim==DIM_3DXZ )

                         {

                         di3D.add(new Static3D(xDown, DynamicRenderer.BHEI/2,yDown));

                         }

                       }

                     }

                   break; 

        }

      }

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

    @Override public boolean onTouchEvent(MotionEvent event) 

      {

      int action = event.getAction();

      switch(action)

        {

        case MotionEvent.ACTION_DOWN: xDown = (int)event.getX()* DynamicRenderer.BWID/mScrW;

                                      yDown = (int)event.getY()* DynamicRenderer.BHEI/mScrH;

                                      addNewPoint(xDown,yDown);

                                      break;

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

                                        {

                                        xDown = (int)event.getX()* DynamicRenderer.BWID/mScrW;

                                        yDown = (int)event.getY()* DynamicRenderer.BHEI/mScrH;

                                        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;

      }

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

  }