/ - Diff - TwistyPuzzleLib - Distorted Android

         private float mUnscaledX, mUnscaledY, mUnscaledZ;
         private float[] mPosition;
         private float[][] mRotRow;
         private boolean mIsAttached;
         private long mMarkedEffectID;
-...
             Static4D q = fact.getQuaternion(i);
             QuatHelper.rotateVectorByQuat(mTmp,0,0,1,0,q);
             int index = mObject.computeMapsIndex(mTmp);
             if( index>=mTextureMaps.length )
+              {
               android.util.Log.e("D", "index="+index+" texMapLen="+mTextureMaps.length);
+              }
             maps[i] = mTextureMaps[index];
+            }
-...
           mObject = object;
           mRoundCorners = roundCorners;
           mPosition = position;
           mRotRow = mObject.getRotRows(mPosition);
           mIsAttached = true;
           mMarkedEffectID = -1;
-...
           System.arraycopy(mPosition, 0, tmpPosition,    0, len1);
           System.arraycopy(position , 0, tmpPosition, len1, len2);
           mPosition = tmpPosition;
           mRotRow = mObject.getRotRows(mPosition);
           computeMove(mPosition);
           MeshBase mesh = mObject.createMesh(mPosition,mRoundCorners);
-...
           return mPosition;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public float[][] getRotRow()
+          {
           return mRotRow;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public DistortedNode getNode()

         private final DistortedScreen mScreen;
         private final float[][] mFaceAxis;
         private BandagedCubit[] mCubits;
         private final float[][] mRotAxis;
         float[][] mCuts;
         final int[] mSize;
         final float mDist2D;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        BandagedObject(DistortedScreen screen, int numRotAxis)
        BandagedObject(DistortedScreen screen)
+         {
          mScreen = screen;
          mSize = new int[numRotAxis];
          mRotAxis = getRotAxis();
          mSize = new int[mRotAxis.length];
          mDist2D = getDist2D();
          Static3D[] axis = getFaceAxis();
          int numAxis = axis.length;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        abstract float[][] getRotAxis();
        abstract float getDist2D();
        abstract int[] getColors();
        abstract float[][][] getPositions();
-...
        public abstract Static3D[] getFaceAxis();
        public abstract float getScreenRatio();
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float getRotRow(int ax, float d)
+        {
         float[] cuts = mCuts[ax];
         int numCuts = cuts.length;
         for(int c=0; c<numCuts; c++) if( d<=cuts[c] ) return c;
         return numCuts;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float[][] getRotRows(float[] pos)
+        {
         int num = pos.length/3;
         int numAx = mRotAxis.length;
         float[][] ret = new float[num][numAx];
         for(int p=0; p<num; p++)
           for(int a=0; a<numAx; a++)
+            {
             float[] ax = mRotAxis[a];
             float x = pos[3*p];
             float y = pos[3*p+1];
             float z = pos[3*p+2];
             float d = ax[0]*x + ax[1]*y + ax[2]*z;
             ret[p][a] = getRotRow(a,d);
+            }
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        public void createCubits(Static4D quatT, Static4D quatA, Static3D scale)
-...
          for(float[][] po : pos)
             for(float[] p : po)
                mCubits[c++]=new BandagedCubit(this, p, quatT, quatA, scale, false);
               mCubits[c++] = new BandagedCubit(this, p, quatT, quatA, scale, false);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         float y = point3D[1]*mMax;
         float z = point3D[2]*mMax;
         int minIndex = -1;
         float minDist = Float.MAX_VALUE;
         int numAxis = mRotAxis.length;
         float[] rotRow = new float[numAxis];
         for(int a=0; a<numAxis; a++)
+          {
           float[] ax = mRotAxis[a];
           float d = ax[0]*x + ax[1]*y + ax[2]*z;
           rotRow[a] = getRotRow(a,d);
+          }
         int diff = Integer.MAX_VALUE;
         int currBest = -1;
         for(int c=0; c<mNumCubits; c++)
           if( mCubits[c].isAttached() )
+            {
             float[] pos = mCubits[c].getPosition();
             int len = pos.length/3;
             float[][] cubitRotRow = mCubits[c].getRotRow();
             for(int p=0; p<len; p++)
             for(float[] row : cubitRotRow)
+              {
               float dx = pos[3*p  ]-x;
               float dy = pos[3*p+1]-y;
               float dz = pos[3*p+2]-z;
               float dist = dx*dx + dy*dy + dz*dz;
               int currDiff = 0;
               for(int a=0; a<numAxis; a++)
+                {
                 float d = rotRow[a]-row[a];
                 currDiff += d*d;
+                }
               if( dist<minDist )
               if( currDiff<diff )
+                {
                 minDist = dist;
                 minIndex = c;
                 diff = currDiff;
                 currBest = c;
+                }
+              }
+            }
         return minIndex;
         return currBest;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     public class BandagedObjectCuboid extends BandagedObject
+    {
       private float[][] getCuts(int[] numLayers)
+        {
         float[][] ret = new float[3][];
         for(int axis=0; axis<3; axis++)
+          {
           int len = numLayers[axis];
           float start = (2-len)*0.5f;
           if( len>=2 )
+            {
             ret[axis] = new float[len-1];
             for(int i=0; i<len-1; i++) ret[axis][i] = start+i;
+            }
+          }
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float[][] getRotAxis()
+        {
         return new float[][]
+          {
             {1,0,0},
             {0,1,0},
             {0,0,1},
           };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float getDist2D()
+         {
          return 0.5f;
-...
       public BandagedObjectCuboid(DistortedScreen screen)
+         {
          super(screen,3);
          super(screen);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
             mSize[2] = z;
             mMax = x>y ? Math.max(x,z) : Math.max(y,z);
             mNumCubits = ( x<=1 || y<=1 || z<=1 ) ? x*y*z : x*y*z-(x-2)*(y-2)*(z-2);
             mCuts = getCuts(mSize);
             return true;
+            }

     package org.distorted.objectlib.bandaged;
     import static org.distorted.objectlib.main.TwistyObject.SQ5;
     import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.C2;
     import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.COS54;
     import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.LEN;
     import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.SIN54;
     import org.distorted.library.main.DistortedScreen;
-...
       private static final int NUM_CENTERS = 12;
       private static final int NUM_EDGES   = 30;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float[][] getCuts(int[] numLayers)
+        {
         int numL = numLayers[0];
         int distL = numL;
         boolean megaminx = isMegaminx(numL);
         float dist = megaminx ? 0.5f-MEGA_D : 0.5f;
         if( (numL%2)==0 ) numL++;
         float[][] ret = new float[6][numL-1];
         float D = distL*TouchControlDodecahedron.DIST3D;
         float X = 2*D/(2+SIN18);  // height of the 'upper' part of a dodecahedron, i.e. put it on a table,
                                   // its height is then 2D, it has one 'lower' part of height X, one
                                   // 'middle' part of height Y and one upper part of height X again.
         int num = (numL-1)/2;
         float G = X*dist/num;     // height of one Layer
         for(int i=0; i<num; i++)
+          {
           float cut = -D + (i+0.85f)*G;  // 0.85? not fully correct; attempt to make it
                                          // easier to rotate the outer layers
           int j = 2*num-1-i;
           ret[0][i] =  cut;
           ret[0][j] = -cut;
           ret[1][i] =  cut;
           ret[1][j] = -cut;
           ret[2][i] =  cut;
           ret[2][j] = -cut;
           ret[3][i] =  cut;
           ret[3][j] = -cut;
           ret[4][i] =  cut;
           ret[4][j] = -cut;
           ret[5][i] =  cut;
           ret[5][j] = -cut;
+          }
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // The pair (distance,angle) defines a point P in R^2 in polar coordinate system. Let V be the vector
     // from the center of the coordinate system to P.
-...
           case 5: float x5_0 = 2.5f*(0.5f-MEGA_D);
                   float x5_1 = 2.5f*(0.5f+MEGA_D);
                   float x5_2 = 2.5f*(0.5f-MEGA_D)*COS18;
                   float x5_3 = x5_1 + 2.5f*(0.5f-MEGA_D)*SIN18;
                   float x5_4 = 2.5f*SIN54 - x5_2;
                   float x5_2 = x5_0*COS18;
                   float x5_3 = x5_1 + x5_0*SIN18;
                   float x5_4 = 2.5f*SIN54/COS54 - x5_2;
                   float d5_0 = len-x5_0*x5_0;
                   float d5_1 = len-x5_1*x5_1;
                   float d5_2 = len-x5_2*x5_2;
-...
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float[][] getRotAxis()
+        {
         return new float[][]
+          {
              {    C2/LEN, SIN54/LEN,    0      },
              {   -C2/LEN, SIN54/LEN,    0      },
              { 0        ,    C2/LEN, SIN54/LEN },
              { 0        ,   -C2/LEN, SIN54/LEN },
              { SIN54/LEN,    0     ,    C2/LEN },
              { SIN54/LEN,    0     ,   -C2/LEN }
           };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float[][][] getPositions()
-...
       public BandagedObjectMegaminx(DistortedScreen screen)
+        {
         super(screen,6);
         super(screen);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
           mMax = x;
           mNumCubits = numCubits(x);
           mCuts = getCuts(mSize);
           return true;
+          }

         return face>1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float[][] getCuts(int[] numLayers)
+        {
         int numL = numLayers[0];
         float[][] ret = new float[4][numL-1];
         for(int i=0; i<numL-1; i++)
+          {
           float cut = (1.0f+i-numL/4.0f)*(SQ6/3);
           ret[0][i] = cut;
           ret[1][i] = cut;
           ret[2][i] = cut;
           ret[3][i] = cut;
+          }
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float[][] getRotAxis()
+        {
         return new float[][]
+          {
             {     0,-SQ3/3,-SQ6/3 },
             {     0,-SQ3/3, SQ6/3 },
             { SQ6/3, SQ3/3,     0 },
             {-SQ6/3, SQ3/3,     0 },
           };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float getDist2D()
-...
       public BandagedObjectPyraminx(DistortedScreen screen)
+        {
         super(screen,4);
         super(screen);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
           int numOcta = FactoryBandagedPyraminx.numEntriesInEmptyLattice(x-1);
           int numTetra= FactoryBandagedPyraminx.numEntriesInEmptyLattice(x);
           mNumCubits = numOcta + numTetra;
           mCuts = getCuts(mSize);
           return true;
+          }

     // the signature must contain ceil( 12*(N-1)^2 / 64 ) bytes.
     // a pyraminx of size N has 4 + 6*(N-1)(N-2) places two adjacent cubies can be 'glued' so much less.
     // Gigaminx has 480 such places (so more if N<=7)
     // Gigaminx has 540 such places (so more if N<=7)
       private static int computeNum()
+        {
         int max = MAX_SUPPORTED_SIZE-1;
         int ret = (int)(0.99f + (12*max*max)/64.0f);
         int giga= (int)(0.99f + (       480)/64.0f);
         int giga= (int)(0.99f + (       540)/64.0f);
         return Math.max(ret,giga);
+        }
-...
         ArrayList<float[]> mTouch = new ArrayList<>();
         int t=0;
         for(int i=0; i<numCubits; i++)
+          {
           float[] first = getPosition(i,centers,numVariants);
-...
               float zc = (tz+oz)/2;
               float[] touch = new float[] {xc, yc, zc};
               android.util.Log.e("D", "cubit touch: "+t+" : "  +xc+" "+yc+" "+zc );
               t++;
               mTouch.add(touch);
+              }
+            }

Project

General

Profile

TwistyPuzzleLib

Revision d2e06841

Added by Leszek Koltunski about 2 years ago