/ - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision 9205f15e

Added by Leszek Koltunski over 4 years ago

ID 9205f15e3f936e57e342bb7d4583fefdcb99ff5a
Parent 33c22e6c
Child 8ba7aeb1

Simplify RubikSurfaceView and the touchscreen control.

       private MeshQuad mQuad;
       private DistortedTexture mTextureShad, mTextureCirc;
       private Dynamic3D mDynMoveHand1, mDynMoveShad1;
       private Dynamic3D mDynScaleHand1, mDynScaleShad1;
       private MatrixEffectMove mMoveHand1, mMoveShad1;
       private MatrixEffectScale mScaleHand1, mScaleShad1;
       private Dynamic3D mDynMoveHand2, mDynMoveShad2;
       private Dynamic3D mDynScaleHand2, mDynScaleShad2;
       private MatrixEffectMove mMoveHand2, mMoveShad2;
       private MatrixEffectScale mScaleHand2, mScaleShad2;
       private Dynamic3D mDyn1, mDyn2, mDyn3, mDyn4;
       private Static3D mPosition1, mPosition2, mPosition3, mPosition4;
       private float[] tmpBuffer;
-...
         mDynScaleShad1.setMode(Dynamic.MODE_PATH);
         mDynScaleShad1.setConvexity(0.0f);
         mMoveHand1 = new MatrixEffectMove(mDynMoveHand1);
         mMoveShad1 = new MatrixEffectMove(mDynMoveShad1);
         mScaleHand1= new MatrixEffectScale(mDynScaleHand1);
         mScaleShad1= new MatrixEffectScale(mDynScaleShad1);
         MatrixEffectMove  moveHand1 = new MatrixEffectMove(mDynMoveHand1);
         MatrixEffectMove  moveShad1 = new MatrixEffectMove(mDynMoveShad1);
         MatrixEffectScale scaleHand1= new MatrixEffectScale(mDynScaleHand1);
         MatrixEffectScale scaleShad1= new MatrixEffectScale(mDynScaleShad1);
         mEffects[0].apply(mScaleShad1);
         mEffects[0].apply(mMoveShad1);
         mEffects[2].apply(mScaleHand1);
         mEffects[2].apply(mMoveHand1);
         mEffects[0].apply(scaleShad1);
         mEffects[0].apply(moveShad1);
         mEffects[2].apply(scaleHand1);
         mEffects[2].apply(moveHand1);
         mDynMoveHand2 = new Dynamic3D(time,0.5f);
         mDynMoveHand2.setMode(Dynamic.MODE_PATH);
-...
         mDynScaleShad2.setMode(Dynamic.MODE_PATH);
         mDynScaleShad2.setConvexity(0.0f);
         mMoveHand2 = new MatrixEffectMove(mDynMoveHand2);
         mMoveShad2 = new MatrixEffectMove(mDynMoveShad2);
         mScaleHand2= new MatrixEffectScale(mDynScaleHand2);
         mScaleShad2= new MatrixEffectScale(mDynScaleShad2);
         MatrixEffectMove  moveHand2 = new MatrixEffectMove(mDynMoveHand2);
         MatrixEffectMove  moveShad2 = new MatrixEffectMove(mDynMoveShad2);
         MatrixEffectScale scaleHand2= new MatrixEffectScale(mDynScaleHand2);
         MatrixEffectScale scaleShad2= new MatrixEffectScale(mDynScaleShad2);
         mEffects[1].apply(mScaleShad2);
         mEffects[1].apply(mMoveShad2);
         mEffects[3].apply(mScaleHand2);
         mEffects[3].apply(mMoveHand2);
         mEffects[1].apply(scaleShad2);
         mEffects[1].apply(moveShad2);
         mEffects[3].apply(scaleHand2);
         mEffects[3].apply(moveHand2);
         DistortedScreen screen = mControl.getScreen();
         int wid= screen.getWidth();
-...
+        {
         switch(stage)
+          {
           case  1: setEffectsStage2(); break;
           case  2: setEffectsStage3(); break;
           case  3: setEffectsStage4(); break;
           case  4: setEffectsStage5(); break;
           case  5: setEffectsStage6(); break;
           case  6: setEffectsStage7(); break;
           case  7: setEffectsStage8(); break;
           case  8: setEffectsStage9(); break;
           case  1: setEffectsStage2() ; break;
           case  2: setEffectsStage3() ; break;
           case  3: setEffectsStage4() ; break;
           case  4: setEffectsStage5() ; break;
           case  5: setEffectsStage6() ; break;
           case  6: setEffectsStage7() ; break;
           case  7: setEffectsStage8() ; break;
           case  8: setEffectsStage9() ; break;
           case  9: setEffectsStage10(); break;
           case 10: setEffectsStage11(); break;
           case 11: setEffectsStage12(); break;

         private int mScreenWidth, mScreenHeight, mScreenMin;
         private float mRotAngle, mInitDistance;
         private int mPtrID1, mPtrID2;
         private float mX, mY;
         private float mStartRotX, mStartRotY;
         private float mAxisX, mAxisY;
         private float mRotationFactor;
-...
         private int mFirstIndex, mLastIndex;
         private int mDensity;
         private int mPointer1, mPointer2;
         private float mX1, mY1, mX2, mY2, mX, mY;
         private static final Static4D mQuat= new Static4D(-0.25189602f,0.3546389f,0.009657208f,0.90038127f);
         private static final Static4D mTemp= new Static4D(0,0,0,1);
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private void drag(MotionEvent event, float x, float y)
         private void drag(float x, float y)
+          {
           if( mPtrID1!=INVALID_POINTER_ID && mPtrID2!=INVALID_POINTER_ID)
           if( mPointer1!=INVALID_POINTER_ID && mPointer2!=INVALID_POINTER_ID)
+            {
             int pointer = event.findPointerIndex(mPtrID2);
             float pX,pY;
             try
+              {
               pX = event.getX(pointer);
               pY = event.getY(pointer);
+              }
             catch(IllegalArgumentException ex)
+              {
               mPtrID1=INVALID_POINTER_ID;
               mPtrID2=INVALID_POINTER_ID;
               FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();
               crashlytics.setCustomKey("DragError", "pointer="+pointer );
               crashlytics.recordException(ex);
               return;
+              }
             float x2 = (pX - mScreenWidth*0.5f)/mScreenMin;
             float y2 = (mScreenHeight*0.5f -pY)/mScreenMin;
             float x2 = (mX2 - mScreenWidth*0.5f)/mScreenMin;
             float y2 = (mScreenHeight*0.5f - mY2)/mScreenMin;
             float angleNow = getAngle(x,y,x2,y2);
             float angleDiff = angleNow-mRotAngle;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private void actionMove(MotionEvent event)
         void initialize()
+          {
           int pointer = event.findPointerIndex(mPtrID1 != INVALID_POINTER_ID ? mPtrID1:mPtrID2);
           if( pointer<0 ) return;
           float pX = event.getX(pointer);
           float pY = event.getY(pointer);
           float x = (pX - mScreenWidth*0.5f)/mScreenMin;
           float y = (mScreenHeight*0.5f -pY)/mScreenMin;
           if( mBeginningRotation )
+            {
             if( retFingerDragDistanceInInches(mX,mY,x,y) > ROTATION_SENSITIVITY )
+              {
               beginRotation(x,y);
+              }
+            }
           else if( mContinuingRotation )
+            {
             continueRotation(x,y);
+            }
           else if( mDragging )
+            {
             drag(event,x,y);
+            }
           else
+            {
             setUpDragOrRotate(false,x,y);
+            }
           mPointer1 = INVALID_POINTER_ID;
           mPointer2 = INVALID_POINTER_ID;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private void actionDown(MotionEvent event)
         private void prepareDown(MotionEvent event)
+          {
           mPtrID1 = event.getPointerId(0);
           float x = event.getX();
           float y = event.getY();
           mX = (x - mScreenWidth*0.5f)/mScreenMin;
           mY = (mScreenHeight*0.5f -y)/mScreenMin;
           setUpDragOrRotate(true,mX,mY);
           mPointer1 = event.getPointerId(0);
           mX1 = event.getX();
           mY1 = event.getY();
           mPointer2 = INVALID_POINTER_ID;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private void actionUp(MotionEvent event)
         private void prepareMove(MotionEvent event)
+          {
           mPtrID1 = INVALID_POINTER_ID;
           mPtrID2 = INVALID_POINTER_ID;
           int index1 = event.findPointerIndex(mPointer1);
           if( mContinuingRotation )
           if( index1>=0 )
+            {
             finishRotation();
             mX1 = event.getX(index1);
             mY1 = event.getY(index1);
+            }
           if( mLastCubitColor>=0 )
           int index2 = event.findPointerIndex(mPointer2);
           if( index2>=0 )
+            {
             mPreRender.setTextureMap( mLastCubit, mLastCubitFace, mLastCubitColor );
             mLastCubitColor = -1;
             mX2 = event.getX(index2);
             mY2 = event.getY(index2);
+            }
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private void actionDown2(MotionEvent event)
         private void prepareUp()
+          {
           int index = event.getActionIndex();
           if( mPtrID1==INVALID_POINTER_ID )
+            {
             mPtrID1 = event.getPointerId(index);
             float x = event.getX();
             float y = event.getY();
             if( mPtrID2 != INVALID_POINTER_ID )
+              {
               int pointer = event.findPointerIndex(mPtrID2);
               try
+                {
                 float x2 = event.getX(pointer);
                 float y2 = event.getY(pointer);
                 mRotAngle = getAngle(x,-y,x2,-y2);
                 mInitDistance = -1;
+                }
               catch(IllegalArgumentException ex)
+                {
                 mPtrID1=INVALID_POINTER_ID;
                 mPtrID2=INVALID_POINTER_ID;
                 FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();
                 crashlytics.setCustomKey("DragError", "pointer="+pointer );
                 crashlytics.recordException(ex);
                 return;
+                }
+              }
             mX = (x - mScreenWidth*0.5f)/mScreenMin;
             mY = (mScreenHeight*0.5f -y)/mScreenMin;
+            }
           else if( mPtrID2==INVALID_POINTER_ID )
+            {
             mPtrID2 = event.getPointerId(index);
             float x = event.getX();
             float y = event.getY();
             if( mPtrID2 != INVALID_POINTER_ID )
+              {
               int pointer = event.findPointerIndex(mPtrID2);
               try
+                {
                 float x2 = event.getX(pointer);
                 float y2 = event.getY(pointer);
                 mRotAngle = getAngle(x,-y,x2,-y2);
                 mInitDistance = -1;
+                }
               catch(IllegalArgumentException ex)
+                {
                 mPtrID1=INVALID_POINTER_ID;
                 mPtrID2=INVALID_POINTER_ID;
                 FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();
                 crashlytics.setCustomKey("DragError", "pointer="+pointer );
                 crashlytics.recordException(ex);
                 return;
+                }
+              }
             if( mBeginningRotation || mContinuingRotation )
+              {
               mX = (x - mScreenWidth*0.5f)/mScreenMin;
               mY = (mScreenHeight*0.5f -y)/mScreenMin;
+              }
+            }
           if( mBeginningRotation )
+            {
             mContinuingRotation = false;
             mBeginningRotation  = false;
             mDragging           = true;
+            }
           else if( mContinuingRotation )
+            {
             finishRotation();
+            }
           mPointer1 = INVALID_POINTER_ID;
           mPointer2 = INVALID_POINTER_ID;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private void actionUp2(MotionEvent event)
         private void prepareDown2(MotionEvent event)
+          {
           int index = event.getActionIndex();
           if( index==event.findPointerIndex(mPtrID1) )
           if( mPointer1==INVALID_POINTER_ID )
+            {
             mPtrID1 = INVALID_POINTER_ID;
             int pointer = event.findPointerIndex(mPtrID2);
             if( pointer>=0 )
+              {
               float x1 = event.getX(pointer);
               float y1 = event.getY(pointer);
               mX = (x1 - mScreenWidth*0.5f)/mScreenMin;
               mY = (mScreenHeight*0.5f -y1)/mScreenMin;
+              }
             mPointer1 = event.getPointerId(index);
             mX1 = event.getX(index);
             mY1 = event.getY(index);
+            }
           else if( index==event.findPointerIndex(mPtrID2) )
           else if( mPointer2==INVALID_POINTER_ID )
+            {
             mPtrID2 = INVALID_POINTER_ID;
             mPointer2 = event.getPointerId(index);
             mX2 = event.getX(index);
             mY2 = event.getY(index);
+            }
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         void initialize()
         private void prepareUp2(MotionEvent event)
+          {
           mPtrID1 = INVALID_POINTER_ID;
           mPtrID2 = INVALID_POINTER_ID;
           int index = event.getActionIndex();
                if( index==event.findPointerIndex(mPointer1) ) mPointer1 = INVALID_POINTER_ID;
           else if( index==event.findPointerIndex(mPointer2) ) mPointer2 = INVALID_POINTER_ID;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+            }
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void actionMove(int p1, float x1, float y1, int p2, float x2, float y2)
+          {
           float pX = p1 != INVALID_POINTER_ID ? x1 : x2;
           float pY = p1 != INVALID_POINTER_ID ? y1 : y2;
           float x = (pX - mScreenWidth*0.5f)/mScreenMin;
           float y = (mScreenHeight*0.5f -pY)/mScreenMin;
           if( mBeginningRotation )
+            {
             if( retFingerDragDistanceInInches(mX,mY,x,y) > ROTATION_SENSITIVITY )
+              {
               beginRotation(x,y);
+              }
+            }
           else if( mContinuingRotation )
+            {
             continueRotation(x,y);
+            }
           else if( mDragging )
+            {
             drag(x,y);
+            }
           else
+            {
             setUpDragOrRotate(false,x,y);
+            }
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void actionDown(float x1, float y1)
+          {
           mX = (x1 -  mScreenWidth*0.5f)/mScreenMin;
           mY = (mScreenHeight*0.5f - y1)/mScreenMin;
           setUpDragOrRotate(true,mX,mY);
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void actionUp()
+          {
           if( mContinuingRotation )
+            {
             finishRotation();
+            }
           if( mLastCubitColor>=0 )
+            {
             mPreRender.setTextureMap( mLastCubit, mLastCubitFace, mLastCubitColor );
             mLastCubitColor = -1;
+            }
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void actionDown2(float x1, float y1, float x2, float y2)
+          {
           mRotAngle = getAngle(x1,-y1, x2,-y2);
           mInitDistance = -1;
           mX = (x1 - mScreenWidth*0.5f )/mScreenMin;
           mY = (mScreenHeight*0.5f - y1)/mScreenMin;
           if( mBeginningRotation )
+            {
             mContinuingRotation = false;
             mBeginningRotation  = false;
             mDragging           = true;
+            }
           else if( mContinuingRotation )
+            {
             finishRotation();
+            }
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void actionUp2(int p1, float x1, float y1, int p2, float x2, float y2)
+          {
           if( p1==INVALID_POINTER_ID )
+            {
             mX = (x2 -  mScreenWidth*0.5f)/mScreenMin;
             mY = (mScreenHeight*0.5f - y2)/mScreenMin;
+            }
           if( p2==INVALID_POINTER_ID )
+            {
             mX = (x1 -  mScreenWidth*0.5f)/mScreenMin;
             mY = (mScreenHeight*0.5f - y1)/mScreenMin;
+            }
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         @Override
-...
           switch(action)
+             {
              case MotionEvent.ACTION_DOWN        : actionDown(event) ; break;
              case MotionEvent.ACTION_MOVE        : actionMove(event) ; break;
              case MotionEvent.ACTION_UP          : actionUp(event)   ; break;
              case MotionEvent.ACTION_POINTER_DOWN: actionDown2(event); break;
              case MotionEvent.ACTION_POINTER_UP  : actionUp2(event)  ; break;
              case MotionEvent.ACTION_DOWN        : prepareDown(event);
                                                    actionDown(mX1, mY1);
                                                    break;
              case MotionEvent.ACTION_MOVE        : prepareMove(event);
                                                    actionMove(mPointer1, mX1, mY1, mPointer2, mX2, mY2);
                                                    break;
              case MotionEvent.ACTION_UP          : prepareUp();
                                                    actionUp();
                                                    break;
              case MotionEvent.ACTION_POINTER_DOWN: prepareDown2(event);
                                                    actionDown2(mX1, mY1, mX2, mY2);
                                                    break;
              case MotionEvent.ACTION_POINTER_UP  : prepareUp2(event);
                                                    actionUp2(mPointer1, mX1, mY1, mPointer2, mX2, mY2);
                                                    break;
+             }
           return true;

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision 9205f15e

Added by Leszek Koltunski over 4 years ago