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 int DIRECTION_SENSITIVITY=  12;

    private int mX, mY;

    private int mTouchedIndex1, mTouchedIndex2;

    private BandagedCreatorRenderer mRenderer;

    private BandagedTouchControl mTouchControl;

    private int mScreenWidth, mScreenHeight;

    private int mYoffset;

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

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

        BandagedCubit[] cubits = mRenderer.getCubits();

        DistortedScreen screen = mRenderer.getScreen();

        mTouchControl = new BandagedTouchControl(cubits, 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);

          }

        }

      }

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

    private void resetQuats()

      {

      float qx = mRenderer.mQuat1.get0();

      float qy = mRenderer.mQuat1.get1();

      float qz = mRenderer.mQuat1.get2();

      float qw = mRenderer.mQuat1.get3();

      float rx = mRenderer.mQuat2.get0();

      float ry = mRenderer.mQuat2.get1();

      float rz = mRenderer.mQuat2.get2();

      float rw = mRenderer.mQuat2.get3();

      float tx = rw*qx - rz*qy + ry*qz + rx*qw;

      float ty = rw*qy + rz*qx + ry*qw - rx*qz;

      float tz = rw*qz + rz*qw - ry*qx + rx*qy;

      float tw = rw*qw - rz*qz - ry*qy - rx*qx;

      mRenderer.mQuat1.set(0f, 0f, 0f, 1f);

      mRenderer.mQuat2.set(tx, ty, tz, tw);

      }

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

    public void setScreenSize(int width, int height, int yOffset)

      {

      mScreenWidth = width;

      mScreenHeight= height;

      mYoffset     = yOffset;

      }

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

    @Override

    public boolean onTouchEvent(MotionEvent event)

      {

      int action = event.getAction();

      int x = (int)event.getX();

      int y = (int)event.getY() + mYoffset;

      switch(action)

         {

         case MotionEvent.ACTION_DOWN: float x1 = (x -  mScreenWidth*0.5f)/mRenderer.mScreenMin;

                                       float y1 = (mScreenHeight*0.5f - y)/mRenderer.mScreenMin;

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

                                       if( index<0 )

                                         {

                                         mX = x;

                                         mY = y;

                                         }

                                       else

                                         {

                                         mX = -1;

                                         mY = -1;

                                         if( mTouchedIndex1<0 )

                                           {

                                           mTouchedIndex1 = index;

                                           mTouchControl.markCubit(mTouchedIndex1, BandagedCreatorRenderer.COLOR_MARKED);

                                           }

                                         else if( mTouchedIndex1 != index )

                                           {

                                           mTouchedIndex2 = index;

                                           mTouchControl.markCubit(mTouchedIndex2, BandagedCreatorRenderer.COLOR_MARKED);

                                           }

                                         }

                                       break;

         case MotionEvent.ACTION_MOVE: 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/mRenderer.mScreenMin);

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

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

                                           }

                                         }

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

                                         {

                                         mX = x;

                                         mY = y;

                                         resetQuats();

                                         }

                                       break;

         case MotionEvent.ACTION_UP  : if( mTouchedIndex2>=0 )

                                         {

                                         mTouchControl.markCubit(mTouchedIndex1, BandagedCreatorRenderer.COLOR_DEFAULT);

                                         mTouchControl.markCubit(mTouchedIndex2, BandagedCreatorRenderer.COLOR_DEFAULT);

                                         mRenderer.tryConnectingCubits(mTouchedIndex1,mTouchedIndex2);

                                         mTouchedIndex1 = -1;

                                         mTouchedIndex2 = -1;

                                         }

                                       mX = -1;

                                       mY = -1;

        	                             resetQuats();

                                       break;

         }

      return true;

      }

}