Magic Cube

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

// Copyright 2022 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube 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.                                                           //

//                                                                                               //

// Magic Cube 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 Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.bandaged;

import android.app.ActivityManager;

import android.content.Context;

import android.content.pm.ConfigurationInfo;

import android.opengl.GLES30;

import android.opengl.GLSurfaceView;

import android.util.AttributeSet;

import android.view.MotionEvent;

import com.google.firebase.crashlytics.FirebaseCrashlytics;

import org.distorted.library.main.DistortedScreen;

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

public class BandagedCreatorView extends GLSurfaceView

{

    private final static float DIRECTION_SENSITIVITY= 12.0f;

    public static final int INVALID_POINTER_ID = -1;

    private BandagedCreatorRenderer mRenderer;

    private BandagedCreatorTouchControl mTouchControl;

    private int mScreenWidth, mScreenHeight, mScreenMin;

    private int mTouchedIndex1, mTouchedIndex2;

    private float mX1, mY1, mX2, mY2, mX, mY;

    private int mPointer1, mPointer2;

    private float mRotAngle, mInitDistance;

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

// PUBLIC API

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

    public BandagedCreatorView(Context context, AttributeSet attrs)

      {

      super(context,attrs);

      mX = -1;

      mY = -1;

      mTouchedIndex1 = -1;

      mTouchedIndex2 = -1;

      if(!isInEditMode())

        {

        BandagedCreatorActivity act = (BandagedCreatorActivity)context;

        mRenderer = new BandagedCreatorRenderer(this);

        DistortedScreen screen = mRenderer.getScreen();

        mTouchControl = new BandagedCreatorTouchControl(BandagedCreatorRenderer.SCREEN_RATIO, screen.getFOV() );

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

        try

          {

          final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();

          int esVersion = configurationInfo.reqGlEsVersion>>16;

          setEGLContextClientVersion(esVersion);

          setRenderer(mRenderer);

          }

        catch(Exception ex)

          {

          act.OpenGLError();

          String shading = GLES30.glGetString(GLES30.GL_SHADING_LANGUAGE_VERSION);

          String version = GLES30.glGetString(GLES30.GL_VERSION);

          String vendor  = GLES30.glGetString(GLES30.GL_VENDOR);

          String renderer= GLES30.glGetString(GLES30.GL_RENDERER);

          FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

          crashlytics.setCustomKey("GLSL Version"  , shading );

          crashlytics.setCustomKey("GL version"    , version );

          crashlytics.setCustomKey("GL Vendor "    , vendor  );

          crashlytics.setCustomKey("GLSL renderer" , renderer);

          crashlytics.recordException(ex);

          }

        }

      }

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

    public int getTouched()

      {

      return mTouchedIndex1;

      }

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

    public BandagedCreatorRenderer getRenderer()

      {

      return mRenderer;

      }

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

    public void setCubits(BandagedCubit[] cubits, int x, int y, int z)

      {

      mTouchControl.setCubits(cubits,x,y,z);

      }

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

    public void resetCubits()

      {

      if( mTouchedIndex1>=0 ) mRenderer.untouchCubit(mTouchedIndex1);

      if( mTouchedIndex2>=0 ) mRenderer.untouchCubit(mTouchedIndex2);

      mTouchedIndex1 = -1;

      mTouchedIndex2 = -1;

      }

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

    public void setScreenSize(int width, int height)

      {

      mScreenWidth = width;

      mScreenHeight= height;

      mScreenMin   = Math.min(width, height);

      }

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

    private float getAngle(float x1, float y1, float x2, float y2)

      {

      return (float) Math.atan2(y1-y2, x1-x2);

      }

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

    private void actionDown(MotionEvent event)

      {

      mPointer1 = event.getPointerId(0);

      mX1 = event.getX();

      mY1 = event.getY();

      mPointer2 = INVALID_POINTER_ID;

      float x1 = (mX1 -mScreenWidth*0.5f)/mScreenMin;

      float y1 = (mScreenHeight*0.5f-mY1)/mScreenMin;

      int index = mTouchControl.cubitTouched(x1,y1,mRenderer.getQuatAccu() );

      if( index<0 )

        {

        mX = mX1;

        mY = mY1;

        }

      else

        {

        mX = -1;

        mY = -1;

        if( mTouchedIndex1<0 )

          {

          mTouchedIndex1 = index;

          mRenderer.touchCubit(mTouchedIndex1);

          }

        else

          {

          mTouchedIndex2 = index;

          if( mTouchedIndex1 != index )

            {

            mRenderer.touchCubit(mTouchedIndex2);

            }

          }

        }

      }

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

    private void actionMove(MotionEvent event)

      {

      int index1 = event.findPointerIndex(mPointer1);

      if( index1>=0 )

        {

        mX1 = event.getX(index1);

        mY1 = event.getY(index1);

        }

      int index2 = event.findPointerIndex(mPointer2);

      if( index2>=0 )

        {

        mX2 = event.getX(index2);

        mY2 = event.getY(index2);

        }

      if( mPointer1!=INVALID_POINTER_ID && mPointer2!=INVALID_POINTER_ID)

        {

        float angleNow = getAngle(mX1,mY1,mX2,mY2);

        float angleDiff = angleNow-mRotAngle;

        float sinA = (float)Math.sin(angleDiff);

        float cosA = (float)Math.cos(angleDiff);

        mRenderer.setQuatTemp(0,0,sinA,cosA);

        mRenderer.resetQuats();

        mRotAngle = angleNow;

/*

        float distNow  = (float)Math.sqrt( (x-x2)*(x-x2) + (y-y2)*(y-y2) );

        float distQuot = mInitDistance<0 ? 1.0f : distNow/ mInitDistance;

        mInitDistance = distNow;

        TwistyObject object = mPreRender.getObject();

        if( object!=null ) object.setObjectRatio(distQuot, mObjectNode.getMinSize() );

 */

        }

      else

        {

        float x = event.getX();

        float y = event.getY();

        if( mX>=0 && mY>= 0 )

          {

          float px = mY-y;

          float py = mX-x;

          float pz = 0;

          float plen = (float)Math.sqrt(px*px + py*py + pz*pz);

          if( plen>0 )

            {

            px /= plen;

            py /= plen;

            pz /= plen;

            float cosA = (float)Math.cos(plen*3.14f/mScreenMin);

            float sinA = (float)Math.sqrt(1-cosA*cosA);

            mRenderer.setQuatTemp(px*sinA, py*sinA, pz*sinA, cosA);

            }

          }

        if( (mX-x)*(mX-x) + (mY-y)*(mY-y) > mScreenMin*mScreenMin/(DIRECTION_SENSITIVITY*DIRECTION_SENSITIVITY) )

          {

          mX = x;

          mY = y;

          mRenderer.resetQuats();

          }

        }

      }

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

    private void actionUp()

      {

      mPointer1 = INVALID_POINTER_ID;

      mPointer2 = INVALID_POINTER_ID;

      if( mTouchedIndex2>=0 )

        {

        mRenderer.untouchCubit(mTouchedIndex1);

        mRenderer.untouchCubit(mTouchedIndex2);

        mRenderer.setConnecting(mTouchedIndex1,mTouchedIndex2);

        mTouchedIndex1 = -1;

        mTouchedIndex2 = -1;

        }

      mX = -1;

      mY = -1;

      mRenderer.resetQuats();

      }

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

    private void actionPointerDown(MotionEvent event)

      {

      int index = event.getActionIndex();

      if( mPointer1==INVALID_POINTER_ID )

        {

        mPointer1 = event.getPointerId(index);

        mX1 = event.getX(index);

        mY1 = event.getY(index);

        }

      else if( mPointer2==INVALID_POINTER_ID )

        {

        mPointer2 = event.getPointerId(index);

        mX2 = event.getX(index);

        mY2 = event.getY(index);

        }

      mRotAngle = getAngle(mX1,mY1,mX2,mY2);

      mInitDistance = -1;

      mRenderer.resetQuats();

      }

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

    private void actionPointerUp(MotionEvent event)

      {

      int index = event.getActionIndex();

      if( index==event.findPointerIndex(mPointer1) )

        {

        mPointer1 = INVALID_POINTER_ID;

        mX = mX2;

        mY = mY2;

        }

      else if( index==event.findPointerIndex(mPointer2) )

        {

        mPointer2 = INVALID_POINTER_ID;

        mX = mX1;

        mY = mY1;

        }

      mRenderer.resetQuats();

      }

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

    @Override

    public boolean onTouchEvent(MotionEvent event)

      {

      if( mRenderer.isBusy() ) return true;

      int action = event.getActionMasked();

      switch(action)

         {

         case MotionEvent.ACTION_DOWN        : actionDown(event)       ; break;

         case MotionEvent.ACTION_MOVE        : actionMove(event)       ; break;

         case MotionEvent.ACTION_UP          : actionUp()              ; break;

         case MotionEvent.ACTION_POINTER_DOWN: actionPointerDown(event); break;

         case MotionEvent.ACTION_POINTER_UP  : actionPointerUp  (event); break;

         }

      return true;

      }

}