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

import android.view.View;

import android.widget.SeekBar;

import android.widget.TextView;

import org.distorted.examples.R;

import org.distorted.library.DistortedObject;

import org.distorted.library.EffectNames;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Dynamic2D;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Dynamic4D;

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 java.lang.ref.WeakReference;

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

public class Vertex3DEffect implements SeekBar.OnSeekBarChangeListener

  {

  private WeakReference<Vertex3DActivity> mAct;

  private EffectNames mName;

  private int[] mInter;

  private int[] mInterRegion;

  private int[] mInterCenter;

  private int[] mSeekID;

  private int[] mSeekRegionID;

  private int[] mSeekCenterID;

  private int mDimension;

  private TextView mText,mTextRegion,mTextCenter;

  private Dynamic1D mDyn1;

  private Dynamic3D mDyn3;

  private Static1D  mSta1;

  private Static3D  mSta3;

  private Dynamic4D mRegionDyn;

  private Static4D  mRegionSta;

  private Dynamic2D mCenterDyn;

  private Static2D  mCenterSta;

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

// requires knowledge about effect nature

  private int getDimension()

    {

    switch(mName)

      {

      case SWIRL  :

      case SINK   : return 1;

      case DISTORT:

      case DEFORM : return 3;

      }

    return 0;

    }

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

// requires knowledge about effect nature

  public void apply(DistortedObject object)

    {

    switch(mName)

      {

      case DISTORT: object.distort(mDyn3, mCenterDyn, mRegionDyn); break;

      case DEFORM : object.deform (mDyn3, mCenterDyn            ); break;

      case SINK   : object.sink   (mDyn1, mCenterDyn, mRegionDyn); break;

      case SWIRL  : object.swirl  (mDyn1, mCenterDyn, mRegionDyn); break;

      }

    }

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

// requires knowledge about effect nature

  public boolean supportsRegion()

    {

    return mName == EffectNames.DEFORM ? false : true;

    }

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

// requires knowledge about effect nature

  private void fillStatics()

    {

    switch(mName)

      {

      case DISTORT:

      case DEFORM : float l = mAct.get().getWidth()/50.0f;

                    float x = (mInter[0]-50)*l;

                    float y = (mInter[1]-50)*l;

                    float z = (mInter[2]-50)*l;

                    mSta3.set(x,y,z);

                    break;

      case SINK   : mSta1.set(mInter[0] > 50 ? 50.0f/(100.01f-mInter[0]) : mInter[0] / 50.0f);

                    break;

      case SWIRL  : mSta1.set( 3.6f*(mInter[0]-50) );

                    break;

      }

    }

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

// requires knowledge about effect nature

  private void setDefaultInter()

    {

    switch(mName)

      {

      case DISTORT:

      case DEFORM : mInter[0] = 50;

                    mInter[1] = 50;

                    mInter[2] = 50;

                    break;

      case SINK   :

      case SWIRL  : mInter[0] = 50;

                    break;

      }

    }

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

// requires knowledge about effect nature

  private void setText()

    {

    String text = mName.name();

    if( mName==EffectNames.DISTORT || mName==EffectNames.DEFORM)

      {

      int f1 = (int)mSta3.getX();

      int f2 = (int)mSta3.getY();

      int f3 = (int)mSta3.getZ();

      text += " ("+f1+","+f2+","+f3+")";

      }

    else

      {

      float f1 = ((int)(mSta1.getX()*100))/100.0f;

      text += " ("+f1+")";

      }

    mText.setText(text);

    }

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

  private void fillCenterStatics()

    {

    Vertex3DActivity act = mAct.get();

    float x = (mInterCenter[0]*0.012f - 0.1f)*act.getWidth();

    float y = (mInterCenter[1]*0.012f - 0.1f)*act.getHeight();

    mCenterSta.set(x,y);

    }

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

  private void setDefaultCenterInter()

    {

    mInterCenter[0] = 50;

    mInterCenter[1] = 50;

    }

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

  private void setCenterText()

    {

    int f0 = (int)mCenterSta.getX();

    int f1 = (int)mCenterSta.getY();

    mTextCenter.setText("center ("+f0+","+f1+")");

    }

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

  private void fillRegionStatics()

    {

    Vertex3DActivity act = mAct.get();

    float factorX = act.getWidth() / 100.0f;

    float factorY = act.getHeight()/ 100.0f;

    float  x = (mInterRegion[0]-50)*factorX;

    float  y = (mInterRegion[1]-50)*factorY;

    float rx =  mInterRegion[2]    *factorX;

    float ry =  mInterRegion[3]    *factorY;

    mRegionSta.set(x,y,rx,ry);

    }

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

  private void setDefaultRegionInter()

    {

    mInterRegion[0] = 50;

    mInterRegion[1] = 50;

    mInterRegion[2] = 50;

    mInterRegion[3] = 50;

    }

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

  private void setRegionText()

    {

    int f0 = (int)mRegionSta.getX();

    int f1 = (int)mRegionSta.getY();

    int f2 = (int)mRegionSta.getZ();

    int f3 = (int)mRegionSta.getW();

    mTextRegion.setText("region ("+f0+","+f1+","+f2+","+f3+")");

    }

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

  public Vertex3DEffect(EffectNames name, Vertex3DActivity act)

    {

    mAct = new WeakReference<>(act);

    mName = name;

    mDimension = getDimension();

    if( mDimension==1 )

      {

      mDyn1 = new Dynamic1D();

      mSta1 = new Static1D(0);

      mDyn1.add(mSta1);

      mDyn3 = null;

      }

    else if( mDimension==3 )

      {

      mDyn3 = new Dynamic3D();

      mSta3 = new Static3D(0,0,0);

      mDyn3.add(mSta3);

      mDyn1 = null;

      }

    else

      {

      throw new RuntimeException("unsupported effect");

      }

    mInter = new int[mDimension];

    mSeekID= new int[mDimension];

    mInterRegion = new int[4];

    mSeekRegionID= new int[4];

    mRegionDyn   = new Dynamic4D();

    mRegionSta   = new Static4D(0,0,0,0);

    mRegionDyn.add(mRegionSta);

    mInterCenter = new int[2];

    mSeekCenterID= new int[2];

    mCenterDyn   = new Dynamic2D();

    mCenterSta   = new Static2D(0,0);

    mCenterDyn.add(mCenterSta);

    }

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

  public View createView()

    {

    View effect;

    SeekBar[] seek = new SeekBar[mDimension];

    Vertex3DActivity act = mAct.get();

    switch(mDimension)

      {

      case 1 : effect     = act.getLayoutInflater().inflate(R.layout.effect1d, null);

               mText      = (TextView)effect.findViewById(R.id.effect1dText);

               seek[0]    = (SeekBar)effect.findViewById(R.id.effect1dbar1);

               mSeekID[0] = seek[0].getId();

               break;

      case 2 : effect     = act.getLayoutInflater().inflate(R.layout.effect2d, null);

               mText      = (TextView)effect.findViewById(R.id.effect2dText);

               seek[0]    = (SeekBar)effect.findViewById(R.id.effect2dbar1);

               seek[1]    = (SeekBar)effect.findViewById(R.id.effect2dbar2);

               mSeekID[0] = seek[0].getId();

               mSeekID[1] = seek[1].getId();

               break;

      case 3 : effect     = act.getLayoutInflater().inflate(R.layout.effect3d, null);

               mText      = (TextView)effect.findViewById(R.id.effect3dText);

               seek[0]    = (SeekBar)effect.findViewById(R.id.effect3dbar1);

               seek[1]    = (SeekBar)effect.findViewById(R.id.effect3dbar2);

               seek[2]    = (SeekBar)effect.findViewById(R.id.effect3dbar3);

               mSeekID[0] = seek[0].getId();

               mSeekID[1] = seek[1].getId();

               mSeekID[2] = seek[2].getId();

               break;

      case 4 : effect     = act.getLayoutInflater().inflate(R.layout.effect4d, null);

               mText      = (TextView)effect.findViewById(R.id.effect4dText);

               seek[0]    = (SeekBar)effect.findViewById(R.id.effect4dbar1);

               seek[1]    = (SeekBar)effect.findViewById(R.id.effect4dbar2);

               seek[2]    = (SeekBar)effect.findViewById(R.id.effect4dbar3);

               seek[3]    = (SeekBar)effect.findViewById(R.id.effect4dbar4);

               mSeekID[0] = seek[0].getId();

               mSeekID[1] = seek[1].getId();

               mSeekID[2] = seek[2].getId();

               mSeekID[3] = seek[3].getId();

               break;

      default: android.util.Log.e("Vertex3DEffect", "dimension "+mDimension+" not supported!");

               return null;

      }

    setDefaultInter();

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

      {

      seek[i].setOnSeekBarChangeListener(this);

      seek[i].setProgress( mInter[i] );

      }

    Vertex3DActivity.setSupportsRegion(supportsRegion());

    return effect;

    }

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

  public View createRegion()

    {

    Vertex3DActivity act = mAct.get();

    View region = act.getLayoutInflater().inflate(R.layout.effectregion, null);

    SeekBar[] seek = new SeekBar[4];

    seek[0] = (SeekBar)region.findViewById(R.id.effectRegionBarX );

    seek[1] = (SeekBar)region.findViewById(R.id.effectRegionBarY );

    seek[2] = (SeekBar)region.findViewById(R.id.effectRegionBarRX);

    seek[3] = (SeekBar)region.findViewById(R.id.effectRegionBarRY);

    mSeekRegionID[0] = seek[0].getId();

    mSeekRegionID[1] = seek[1].getId();

    mSeekRegionID[2] = seek[2].getId();

    mSeekRegionID[3] = seek[3].getId();

    mTextRegion = (TextView)region.findViewById(R.id.effectRegionText);

    setDefaultRegionInter();

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

      {

      seek[i].setOnSeekBarChangeListener(this);

      seek[i].setProgress( mInterRegion[i] );

      }

    act.setRegion(mRegionSta.getX(),mRegionSta.getY(),mRegionSta.getZ());

    return region;

    }

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

  public View createCenter()

    {

    Vertex3DActivity act = mAct.get();

    View center = act.getLayoutInflater().inflate(R.layout.effectcenter, null);

    SeekBar[] seek = new SeekBar[2];

    seek[0] = (SeekBar)center.findViewById(R.id.effectCenterBarX );

    seek[1] = (SeekBar)center.findViewById(R.id.effectCenterBarY );

    mSeekCenterID[0] = seek[0].getId();

    mSeekCenterID[1] = seek[1].getId();

    mTextCenter = (TextView)center.findViewById(R.id.effectCenterText);

    setDefaultCenterInter();

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

      {

      seek[i].setOnSeekBarChangeListener(this);

      seek[i].setProgress( mInterCenter[i] );

      }

    act.setCenter(mCenterSta.getX(),mCenterSta.getY());

    return center;

    }

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

  public void onProgressChanged(SeekBar bar, int progress, boolean fromUser)

    {

    if ( mDimension>=1 && bar.getId()==mSeekID[0] )

      {

      mInter[0] = progress;

      fillStatics();

      setText();

      }

    if ( mDimension>=2 && bar.getId()==mSeekID[1] )

      {

      mInter[1] = progress;

      fillStatics();

      setText();

      }

    if ( mDimension>=3 && bar.getId()==mSeekID[2] )

      {

      mInter[2] = progress;

      fillStatics();

      setText();

      }

    if ( mDimension>=4 && bar.getId()==mSeekID[3] )

      {

      mInter[3] = progress;

      fillStatics();

      setText();

      }

    if( bar.getId() == mSeekRegionID[0] )

      {

      mInterRegion[0] = progress;

      fillRegionStatics();

      setRegionText();

      }

    if( bar.getId() == mSeekRegionID[1] )

      {

      mInterRegion[1] = progress;

      fillRegionStatics();

      setRegionText();

      }

    if( bar.getId() == mSeekRegionID[2] )

      {

      mInterRegion[2] = progress;

      fillRegionStatics();

      setRegionText();

      }

    if( bar.getId() == mSeekRegionID[3] )

      {

      mInterRegion[3] = progress;

      fillRegionStatics();

      setRegionText();

      }

    if( bar.getId() == mSeekCenterID[0] )

      {

      mInterCenter[0] = progress;

      fillCenterStatics();

      setCenterText();

      }

    if( bar.getId() == mSeekCenterID[1] )

      {

      mInterCenter[1] = progress;

      fillCenterStatics();

      setCenterText();

      }

    if( fromUser )

      {

      Vertex3DActivity.setSupportsRegion(supportsRegion());

      Vertex3DActivity act = mAct.get();

      act.setCenter(mCenterSta.getX(),mCenterSta.getY());

      act.setRegion(mRegionSta.getX(),mRegionSta.getY(),mRegionSta.getZ());

      }

    }

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

  public void onStartTrackingTouch(SeekBar bar) { }

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

  public void onStopTrackingTouch(SeekBar bar)  { }

  }