/ - Diff - TwistyPuzzleLib - Distorted Android

         mRotationAngle.removeAll();
         int nonGhostAngle= (int)angle;
         if( (nonGhostAngle%mGhostBasicDeg)!=0 )
         if( mGhostAngle!=0 && (nonGhostAngle%mGhostBasicDeg)!=0 )
+          {
                if( ((nonGhostAngle-mGhostAngle)%mGhostBasicDeg==0 ) ) nonGhostAngle -= mGhostAngle;
           else if( ((nonGhostAngle+mGhostAngle)%mGhostBasicDeg==0 ) ) nonGhostAngle += mGhostAngle;

     package org.distorted.objectlib.touchcontrol;
     import org.distorted.library.helpers.QuatHelper;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.main.TwistyObjectControllable;
-...
       float[][] mTouchBorders;
       private final float[][] mRotationFactor;
       protected final float[][] mCuts;
       protected final boolean[][] mRotatable;
       protected final float mSize;
       protected final Static3D[] mRotAxis;
       protected final int[][][] mEnabled;
       protected final float[] mPoint, mCamera, mTouch, mMove2D;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public TouchControl(TwistyObjectControllable object)
+        {
         mRotationFactor = object.returnRotationFactor();
         mCuts           = object.getCuts();
         mRotatable      = object.getLayerRotatable();
         mSize           = object.getSize();
         mRotAxis        = object.getRotationAxis();
         mEnabled        = object.getEnabled();
         mMove2D = new float[2];
         mPoint  = new float[3];
         mCamera = new float[3];
         mTouch  = new float[3];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

       private static final float MIN_LEN = 0.35f;
       private static final float[] mTmp = new float[4];
       private final Static3D[] mRotAxis;
       private final float[] mPoint, mCamera, mTouch;
       private final int[] mEnabledRotAxis;
       private final int[][][] mEnabled;
       private final float[] mMove2D;
       private final float[][] mCastedRotAxis;
       private float[][] mTouchBorders;
       private float mLongitude, mLatitude;
       private float mX, mY, mZ;
       private static final float X = (float)Math.sqrt( (2-SQ2)/(6+SQ2) );
       private static final float Y = (float)Math.sqrt( (2+SQ2)/(6+SQ2) );
       private static final float PI= (float)Math.PI;
       public static final Static3D[] FACE_AXIS = new Static3D[]
+            {
-...
+        {
         super(object);
         float[][] cuts  = object.getCuts();
         boolean[][] rot = object.getLayerRotatable();
         float size      = object.getSize();
         mRotAxis        = object.getRotationAxis();
         mEnabled        = object.getEnabled();
         mMove2D  = new float[2];
         mPoint = new float[3];
         mCamera= new float[3];
         mTouch = new float[3];
         int numRotAxis = mRotAxis.length;
         mEnabledRotAxis = new int[numRotAxis+1];
         mCastedRotAxis = new float[numRotAxis][2];
         computeBorders(cuts,rot,size);
         computeBorders(mCuts,mRotatable,mSize);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         mLongitude = mZ==0 ? 0 : (float)Math.atan(mX/mZ);
         mLatitude  = (float)Math.asin(2*mY);
         if( mZ<0 ) mLongitude += Math.PI;
         else if( mX<0 ) mLongitude += 2*Math.PI;
         if( mZ<0 ) mLongitude += PI;
         else if( mX<0 ) mLongitude += 2*PI;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       private int returnTouchedFace()
+        {
         float t = (float)(mLongitude + Math.PI/8);
         if( t>2*Math.PI ) t-=(2*Math.PI);
         int ret = (int)(t/(Math.PI/4));
         float t = mLongitude+PI/8;
         if( t>2*PI ) t-=(2*PI);
         int ret = (int)(t/(PI/4));
         return ret<8 ? ret : 7;
+        }

       private static final float MIN_LEN = 0.35f;
       private static final float[] mTmp = new float[4];
       private final Static3D[] mRotAxis;
       private final float[] mPoint, mCamera, mTouch;
       private final int[] mEnabledRotAxis;
       private final int[][][] mEnabled;
       private final float[] mMove2D;
       private final float[][] mCastedRotAxis;
       private float[][] mTouchBorders;
-...
+        {
         super(object);
         float[][] cuts  = object.getCuts();
         boolean[][] rot = object.getLayerRotatable();
         float size      = object.getSize();
         float[] dist3D  = object.getDist3D();
         mRotAxis        = object.getRotationAxis();
         mEnabled        = object.getEnabled();
         mMove2D= new float[2];
         mPoint = new float[3];
         mCamera= new float[3];
         mTouch = new float[3];
         float[] dist3D = object.getDist3D();
         int numRotAxis = mRotAxis.length;
         int numSideAxis= numRotAxis - 1;
-...
         mEnabledRotAxis= new int[numRotAxis+1];
         mCastedRotAxis = new float[numRotAxis][2];
         computeBorders(cuts,rot,size);
         computeBorders(mCuts,mRotatable,mSize);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

       ////////////////////////////////////////////////////////////
       // end FaceInfo
       private final float[] mTouch, mLastT;
       private final float[] mLastT;
       private int mNumCubits;
       private int[] mNumFaces;
       private boolean mPreparationDone;
       private final boolean[][] mRotatable;
       private final float[][] mCuts;
       final float[] mCamera, mPoint;
       final Static3D[] mRotAxis;
       final TwistyObjectControllable mObject;
       int mTouchedCubit, mTouchedCubitFace, mNumAxis;
       FaceInfo[][] mInfos;
-...
+        {
         super(object);
         mPoint = new float[3];
         mCamera= new float[3];
         mTouch = new float[3];
         mLastT = new float[3];
         mObject= object;
         mPreparationDone = false;
         mNumAxis = mRotAxis.length;
         mRotAxis    = object.getRotationAxis() ;
         mNumAxis    = mRotAxis.length;
         mRotatable  = object.getLayerRotatable();
         mCuts       = object.getCuts();
         float size  = object.getSize();
         computeBorders(mCuts,mRotatable,size);
         computeBorders(mCuts,mRotatable,mSize);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

       protected final float[] mDistanceCenterFace3D;
       private final int mNumFaceAxis;
       private final float[] mPoint, mCamera, mTouch;
       private final float[] mPoint2D, mMove2D;
       private final float[] mPoint2D;
       private final int[] mEnabledRotAxis;
       private final Static3D[] mFaceAxis, mRotAxis;
       private final Static3D[] mFaceAxis;
       private int mLastTouchedFace;
       private float[][][] mCastedRotAxis;
       private Static4D[][] mCastedRotAxis4D;
       private float[][] mA, mB;
       private final int mSplit;
       private final int[][][] mEnabled;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        {
         super(object);
         float[][] cuts  = object.getCuts();
         boolean[][] rot = object.getLayerRotatable();
         float size      = object.getSize();
         mRotAxis        = object.getRotationAxis();
         mSplit          = object.getTouchControlSplit();
         mEnabled        = object.getEnabled();
         mFaceAxis       = faceAxis;
         mNumFaceAxis    = mFaceAxis.length;
         mPoint  = new float[3];
         mCamera = new float[3];
         mTouch  = new float[3];
         mPoint2D= new float[2];
         mMove2D = new float[2];
         mSplit      = object.getTouchControlSplit();
         mFaceAxis   = faceAxis;
         mNumFaceAxis= mFaceAxis.length;
         mPoint2D    = new float[2];
         mEnabledRotAxis = new int[mRotAxis.length+1];
         mDistanceCenterFace3D = distance3D; // distance from the center of the object to each of its faces
         computeCastedAxis(mRotAxis);
         computeBorders(cuts,rot,size);
         computeBorders(mCuts,mRotatable,mSize);
         computeLinear(mRotAxis,faceAxis);
+        }

         for(int axis=0; axis<mNumAxis; axis++)
+          {
           float x = mRotAxis[axis].get0();
             float y = mRotAxis[axis].get1();
           float y = mRotAxis[axis].get1();
           float z = mRotAxis[axis].get2();
           float w = 0.0f;

Project

General

Profile

TwistyPuzzleLib

Revision 6b2f62c9

Added by Leszek Koltunski 7 months ago