/ - Diff - Magic Cube - Distorted Android

         float sinA = (2*SIN54*SIN54-1)/COS54;
         float cosA = (float)Math.sqrt(1-sinA*sinA);
         float LEN  = 0.5f/SIN54;
         float scale= (numLayers/6.0f-MEGA_D)/(LEN*0.5f*(numLayers-1));
         float scale= (numLayers/3.0f)*(0.5f-MEGA_D)/(LEN*0.5f*(numLayers-1));
         Static3D axisA = new Static3D( SIN54, COS54, 0.0f);
         Static3D axisB = new Static3D(-SIN54, COS54, 0.0f);

     import org.distorted.main.R;
     import org.distorted.main.RubikSurfaceView;
     import static org.distorted.objects.FactoryCubit.COS18;
     import static org.distorted.objects.FactoryCubit.SIN18;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     public class TwistyMegaminx extends TwistyMinx
-...
                {  9, 11,  3, 11},
                { 11, 18,  2, 11},
                { 18,  2,  1, 11},
                { 18,  6,  2,  1},
                {  6, 16,  7,  1},
                { 18,  6,  1,  2},
                {  6, 16,  1,  7},
                { 16,  0,  8,  1},
                { 16, 10,  8,  7},
                { 10,  8,  8, 10},
                {  8, 12,  8,  9},
                { 16, 10,  7,  8},
                { 10,  8, 10,  8},
                {  8, 12,  9,  8},
                {  8, 13,  9, 10},
                { 13,  5,  9,  5},
                {  5,  4,  9,  4},
                {  5, 15,  4,  5},
                { 15,  9,  4,  3},
                {  5, 15,  5,  4},
                { 15,  9,  3,  4},
                { 11, 19,  2,  3},
                { 19,  7,  2,  6},
                {  7,  6,  2,  7},
                {  7, 17,  7,  6},
                { 17, 10,  7, 10},
                { 17,  1,  6, 10},
                {  1,  3,  6,  4},
                {  3, 19,  6,  3},
                { 17,  1, 10,  6},
                {  1,  3,  5,  6},
                {  3, 19,  3,  6},
                {  1, 13, 10,  5},
                {  3, 15,  5,  3},
                {  3, 15,  3,  5},
              };
       private static final float[][] mCenterCoords = new float[NUM_CENTERS][3];
-...
+          }
         else
+          {
           float E = 2.0f*(numLayers/6.0f - MEGA_D)/(0.5f*(numLayers-1));
           float E = 2.0f*(numLayers/3.0f)*(0.5f-MEGA_D)/(0.5f*(numLayers-1));
           int N = (numCubitsPerCorner-1)/3;
           int block = (part-1) % N;
           int index = (part-1) / N;
-...
       private void computeEdge(Static3D pos, int numLayers, int edge, int part)
+        {
         float corr = numLayers/3.0f;
         Static3D c1 = CORNERS[ mEdgeMap[edge][0] ];
         Static3D c2 = CORNERS[ mEdgeMap[edge][1] ];
         float x = (c1.get0() + c2.get0())/2;
         float y = (c1.get1() + c2.get1())/2;
         float z = (c1.get2() + c2.get2())/2;
         float x = corr*(c1.get0() + c2.get0())/2;
         float y = corr*(c1.get1() + c2.get1())/2;
         float z = corr*(c1.get2() + c2.get2())/2;
         if( part==0 )
+          {
-...
           int dir  = (part+1)%2;
           float[] center = mCenterCoords[ mEdgeMap[edge][dir+2] ];
           float vX = center[0]-x;
           float vY = center[1]-y;
           float vZ = center[2]-z;
           float vX = corr*center[0] - x;
           float vY = corr*center[1] - y;
           float vZ = corr*center[2] - z;
           float A = mult*(0.5f-MEGA_D)/((1+SQ5/5)*(numLayers-1));
           float len = (float)Math.sqrt(vX*vX+vY*vY+vZ*vZ);
           float A = mult*corr*(0.5f-MEGA_D)*COS18/((numLayers-1)*0.5f)/len;
           pos.set( x+A*vX, y+A*vY, z+A*vZ );
+          }
-...
           if( mEdgeMeshes[index][type]==null )
+            {
             mEdgeMeshes[index][type] = FactoryCubit.getInstance().createMegaminxEdgeMesh(index,type);
             float height= (numLayers/3.0f)*(0.5f-MEGA_D)*COS18/((numLayers-1)*0.5f);
             float width = (numLayers/3.0f)*2*MEGA_D + 2*type*height*SIN18/COS18;
             mEdgeMeshes[index][type] = FactoryCubit.getInstance().createMegaminxEdgeMesh(width,height);
+            }
           mesh = mEdgeMeshes[index][type].copy(true);
-...
           // TODO: centers
+          }
     */
         MatrixEffectQuaternion quat = new MatrixEffectQuaternion( QUATS[getQuat(cubit,numLayers)], new Static3D(0,0,0) );
         Static4D q = QUATS[getQuat(cubit,numLayers)];
         MatrixEffectQuaternion quat = new MatrixEffectQuaternion( q, new Static3D(0,0,0) );
         mesh.apply(quat,0xffffffff,0);
         return mesh;

       static final int[] QUAT_EDGE_INDICES
         = {
 , 56, 40, 43, 59, 35, 34, 42,  3, 25,
 , 27, 36, 39, 51, 53, 32, 20, 47, 10,
 , 37, 30,  5, 28, 33, 45, 14, 44, 38
 , 40, 43, 59,  0, 55, 10, 17, 25, 49,
 , 57, 18,  7, 53, 32, 20, 11, 31, 38,
 , 30,  8, 28, 36, 44,  1, 46, 12, 14
           };
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Project

General

Profile

Magic Cube

Revision 3d8237cc

Added by Leszek Koltunski over 3 years ago