/src/main/java/org/distorted/objectlib/touchcontrol/TouchControlShapeChanging.java - Diff - TwistyPuzzleLib - Distorted Android

« Previous | Next »

Revision 0c5d8bf7

Added by Leszek Koltunski over 2 years ago

ID 0c5d8bf7418e2d572e5dd273dde76c8d19170269
Parent 92a6fc8b
Child 32c1697e

FIx some issues with ShapeChanging; implement per-object TouchControlSquare and TouchControlMirror.

     public class TouchControlShapeChanging extends TouchControl
+      {
       private static final float NOT_TOUCHED = 1000000.0f;
       private static final float[] mTmp = new float[4];
       static final float[] mTmp = new float[4];
       private static class FaceInfo
       static class FaceInfo
+        {
         private final float[] vector;
         private final float distance;
         private final float[][] vertices;
         private final float[][] rotated;
         private final float[] normal;      // vector normal to the surface of the face, pointing outside.
         private final float distance;      // distance from (0,0,0) to the surface of the face
         private final float[][] vertices;  // vertices of the face. Already rotated by the initQuat and
                                            // moved by 'position' (arithmetic average of all positions)
         private final float[][] rotated;   // temp array to store vertices times rotation quaternion.
         //////////////////////////////////////////////////////////
         FaceInfo(float[][] verts, float size)
+          {
-...
           vy/=len;
           vz/=len;
           float dist = vx*vertices[0][0] + vy*vertices[0][1] + vz*vertices[0][2];
           distance = vx*vertices[0][0] + vy*vertices[0][1] + vz*vertices[0][2];
           if( dist<0 )
+            {
             dist = -dist;
             vx = -vx;
             vy = -vy;
             vz = -vz;
+            }
           normal = new float[4];
           normal[0] = vx;
           normal[1] = vy;
           normal[2] = vz;
           normal[3] = 0.0f;
+          }
           vector = new float[4];
           vector[0] = vx;
           vector[1] = vy;
           vector[2] = vz;
           vector[3] = 0.0f;
         //////////////////////////////////////////////////////////
           distance = dist;
         public float[] getNormal()
+          {
           return normal;
+          }
+        }
       private final float[] mPoint, mCamera, mTouch;
       private final TwistyObject mObject;
       private float[][] mQuats;
       private final float[] mTouch;
       private final Static4D mTmpAxis;
       private int mNumCubits;
       private int[] mNumFaces;
       private boolean mPreparationDone;
       private FaceInfo[][] mInfos;
       private int mTouchedCubit;
       private int mTouchedFace;
       private final Static3D[] mRotAxis;
       private final int mNumAxis;
       private final Static4D mTmpAxis;
       final float[] mCamera, mPoint;
       final Static3D[] mRotAxis;
       final TwistyObject mObject;
       int mTouchedCubit, mTouchedFace, mNumAxis;
       FaceInfo[][] mInfos;
       float[][] mQuats;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         mPreparationDone = false;
         mRotAxis = object.getRotationAxis();
         mNumAxis = mRotAxis.length;
         mTmpAxis = new Static4D(0,0,0,0);
+        }
-...
     //
     // output = camera + alpha*(point-camera), where alpha = [dist-normalVec*camera] / [normalVec*(point-camera)]
       private void castTouchPointOntoFace(float nx, float ny, float nz, float distance, float[] output)
       void castTouchPointOntoFace(float nx, float ny, float nz, float distance, float[] output)
+        {
         float d0 = mPoint[0]-mCamera[0];
         float d1 = mPoint[1]-mCamera[1];
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private boolean faceIsVisible(float nx, float ny, float nz, float distance)
       private boolean cubitFaceIsVisible(float nx, float ny, float nz, float distance)
+        {
         return mCamera[0]*nx + mCamera[1]*ny + mCamera[2]*nz > distance;
+        }
-...
     // 2) else, cast the line passing through mPoint and mCamera onto this plane
     // 3) if Z of this point is further from us than the already computed closestSoFar, return NOT_TOUCHED
     // 4) else, rotate 'vertices' by quat and see if the casted point lies inside the polygon defined by them
     // 5) if yes, return its Z; otherwise, return NOT_TOUCHED
     // 5) if yes, return the distance form this point to the camera; otherwise, return NOT_TOUCHED
       private float cubitFaceTouched(FaceInfo info, float[] quat, float closestSoFar)
+        {
         QuatHelper.rotateVectorByQuat(mTmp,info.vector,quat);
         QuatHelper.rotateVectorByQuat(mTmp,info.normal,quat);
         float nx = mTmp[0];
         float ny = mTmp[1];
         float nz = mTmp[2];
         if( faceIsVisible(nx,ny,nz,info.distance) )
         if( cubitFaceIsVisible(nx,ny,nz,info.distance) )
+          {
           castTouchPointOntoFace(nx,ny,nz,info.distance,mTouch);
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int computeDisabledAxis()
+        {
         float cx = mCamera[0];
         float cy = mCamera[1];
         float cz = mCamera[2];
         float len = (float)Math.sqrt(cx*cx+cy*cy+cz*cz);
         cx /= len;
         cy /= len;
         cz /= len;
         float max = -1.0f;
         int maxAxis = -1;
         for(int axis=0; axis<mNumAxis; axis++)
+          {
           float ax = mRotAxis[axis].get0();
           float ay = mRotAxis[axis].get1();
           float az = mRotAxis[axis].get2();
           float angle = ax*cx + ay*cy + az*cz;
           if( angle<0 ) angle = -angle;
           if( angle>max )
+            {
             max=angle;
             maxAxis = axis;
+            }
+          }
         return maxAxis;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int computeRotationIndex(int disabled, float dx, float dy, float dz)
+        {
         float min = Float.MAX_VALUE;
         int minAxis = -1;
         for(int axis=0; axis<mNumAxis; axis++)
           if( axis!=disabled )
+            {
             float ax = mRotAxis[axis].get0();
             float ay = mRotAxis[axis].get1();
             float az = mRotAxis[axis].get2();
             float angle = dx*ax + dy*ay + dz*az;
             if( angle<0 ) angle=-angle;
             if( angle<min )
+              {
               min=angle;
               minAxis = axis;
+              }
+            }
         return minAxis;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int computeRow(int cubit, int rotIndex)
       int computeRow(int cubit, int rotIndex)
+        {
         int row = mObject.getCubitRotRow(cubit,rotIndex);
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // really implemented in derived classes; here present only because we need to be able to
     // instantiate an object of this class for MODE_REPLACE.
       public void newRotation(int[] output, Static4D rotatedTouchPoint)
+        {
         if( !mPreparationDone ) prepare();
         float dx = mPoint[0] - rotatedTouchPoint.get0()/mObjectRatio;
         float dy = mPoint[1] - rotatedTouchPoint.get1()/mObjectRatio;
         float dz = mPoint[2] - rotatedTouchPoint.get2()/mObjectRatio;
         int disabledAxis = computeDisabledAxis();
         int rotIndex     = computeRotationIndex(disabledAxis,dx,dy,dz);
         int row          = computeRow(mTouchedCubit,rotIndex);
         output[0] = rotIndex;
         output[1] = row;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Also available in: Unified diff

Project

General

Profile

TwistyPuzzleLib

Revision 0c5d8bf7

Added by Leszek Koltunski over 2 years ago