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

import android.content.Context;

import android.opengl.GLSurfaceView;

import android.os.Build;

import android.view.MotionEvent;

import android.util.AttributeSet;

import org.distorted.library.EffectNames;

import org.distorted.library.EffectTypes;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static2D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.library.type.Dynamic3D;

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

public class Effects2DSurfaceView extends GLSurfaceView

  {

  private Effects2DRenderer mRenderer;

  private static int mCurrentEffect;

  private static int mDuration;

  private static float mCount;

  private static int mScrW, mScrH;

  private static Static4D region;

  private static Static2D point;

  private static Static4D mRegion;

  private static Dynamic1D mInterA, mInterM, mInterC, mInterS;

  private static Dynamic3D mInterD;

  private static Static3D v0, v1, v2, v3;

  private final static Static3D mRED = new Static3D(1,0,0);

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

  public Effects2DSurfaceView(Context c, AttributeSet attrs)

    {

    super(c, attrs);

    mDuration = 10000;

    mCount    = 1.0f;

    mInterD = new Dynamic3D(mDuration,mCount);

    int h = 30;

    int r = 20;

    v0 = new Static3D( 0, r, h );

    v1 = new Static3D(-r, 0, h );

    v2 = new Static3D( 0,-r, h );

    v3 = new Static3D( r, 0, h );

    mInterD.add(v0);

    mInterD.add(v1);

    mInterD.add(v2);

    mInterD.add(v3);

    mInterA = new Dynamic1D(mDuration,mCount);

    mInterA.add(new Static1D(1));

    mInterA.add(new Static1D(0));

    mInterS = new Dynamic1D(mDuration,mCount);

    mInterS.add(new Static1D(1.0f));

    mInterS.add(new Static1D(0.3f));

    mInterC = new Dynamic1D(mDuration,mCount);

    mInterC.add(new Static1D(1));

    mInterC.add(new Static1D(0));

    mInterM = new Dynamic1D(mDuration,mCount);

    mInterM.add(new Static1D(1));

    mInterM.add(new Static1D(10));

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

        }

      mRenderer = new Effects2DRenderer(this);

      setRenderer(mRenderer);

      point = new Static2D(0,0);

      region= new Static4D(0,0,60,60);

      mRegion = new Static4D(0,0,60,60);

      setEffect(0);  

      }

    }

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

  public static void setScreenSize(int width, int height)

    {

    mScrW = width;

    mScrH = height;

    }

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

  public static void setEffect(int effect)

    {

    mCurrentEffect = effect;

    }

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

  @Override public boolean onTouchEvent(MotionEvent event) 

    {

    int action = event.getAction();

    int x, y;

    long id = -1;

    switch(action)

      {

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

                                    y = (int)event.getY()* Effects2DRenderer.BHEI/mScrH;

                                    point.set(x,y);

                                    mRegion.set(x,y,60,60);

                                    Effects2DActivity act = (Effects2DActivity)getContext();

                                    switch(mCurrentEffect)

                                      {

                                      case 0: id = Effects2DRenderer.mBackground.distort(mInterD, point, region);

                                              act.effectAdded(id, EffectNames.DISTORT, EffectTypes.VERTEX);

                                              break;

                                      case 1: id = Effects2DRenderer.mBackground.sink(mInterS, point, region);

                                              act.effectAdded(id, EffectNames.SINK, EffectTypes.VERTEX);

                                              break;

                                      case 2: id = Effects2DRenderer.mBackground.alpha(mInterA, mRegion, true);

                                              act.effectAdded(id, EffectNames.ALPHA, EffectTypes.FRAGMENT);

                                              break;

                                      case 3: id = Effects2DRenderer.mBackground.macroblock(mInterM, mRegion);

                                              act.effectAdded(id, EffectNames.MACROBLOCK, EffectTypes.FRAGMENT);

                                              break;

                                      case 4: id = Effects2DRenderer.mBackground.chroma(mInterC, mRED, mRegion, true);

                                              act.effectAdded(id, EffectNames.CHROMA, EffectTypes.FRAGMENT);

                                              break;

                                      }

                                    break;

      }

    return true;

    }

  }