/ - Diff - TwistyPuzzleLib - Distorted Android

« Previous | Next »

Revision 6074bff6

Added by Leszek Koltunski about 2 years ago

ID 6074bff61f428cc0b42253772c6b9fc296b1e604
Parent 11981a15
Child e403724f

Starminx I: progress

       public static TwistyObject create(int ordinal, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream meshStream)
+        {
         if( ordinal== STAR_3.ordinal() )
+          {
           int[] numL = new int[] {3,3,3,3,3,3};
           return new TwistyStarminx( numL,meshState,iconMode,quat,move,scale,meshStream );
+          }
         int[] numL= objects[ordinal].mNumLayers;
         Class<? extends TwistyObject> clazz = objects[ordinal].mClass;

     import java.io.InputStream;
     import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.C2;
     import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.COS54;
     import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.SIN54;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
           if( mEdgeMap==null ) initializeEdgeMap();
           if( mCenterCoords==null ) initializeCenterCoords();
           mPosition = new float[NUM_EDGES][3];
           mPosition = new float[NUM_EDGES+NUM_CENTERS+3*NUM_CORNERS][3];
           for(int edge=0; edge<NUM_EDGES; edge++)
+            {
-...
             mPosition[edge][1] = (c1[1]+c2[1])/2;
             mPosition[edge][2] = (c1[2]+c2[2])/2;
+            }
           for(int center=0; center<NUM_CENTERS; center++)
+            {
             int index = center+NUM_EDGES;
             mPosition[index][0] = mCenterCoords[center][0];
             mPosition[index][1] = mCenterCoords[center][1];
             mPosition[index][2] = mCenterCoords[center][2];
+            }
           for(int petal=0; petal<3*NUM_CORNERS; petal++)
+            {
             int index  = petal+NUM_EDGES+NUM_CENTERS;
             int corner = petal/3;
             mPosition[index][0] = mCorners[corner][0];
             mPosition[index][1] = mCorners[corner][1];
             mPosition[index][2] = mCorners[corner][2];
+            }
+          }
         return mPosition;
-...
       public Static4D getCubitQuats(int cubit, int[] numLayers)
+        {
         if( mQuatIndex==null ) mQuatIndex = new int[] { //35,55,38,48,41,42,58,57, 0,46,29,59,
 ,12,13,20, 0, 4,25, 5,24,16,
         if( mQuatIndex==null ) mQuatIndex = new int[] { 17,12,13,20, 0, 4,25, 5,24,16,
 ,21, 1,34, 8,11,30,43,26,14,
 ,45,33,28,10, 2,29, 6, 7, 3,
                                                          //0, 2,20,42,13,41,16,33, 8,51,
                                                          //1,25,12,27, 4, 3,21,28, 5, 6
 ,55,38,48,41,42,58,57, 0,46,29,59,
 , 0, 0, 29,29,29, 59,59,59, 48,48,48,
 ,18,18, 53,53,53, 22,22,22, 49,49,49,
 ,11,11, 54,54,54, 10,10,10, 52,52,52,
 ,17,17, 27,27,27, 19,19,19, 26,26,26,
 , 9, 9, 28,28,28, 23,23,23, 45,45,45
                                                          };
         return mObjectQuats[mQuatIndex[cubit]];
+        }
-...
+        {
         if( variant==0 ) // edge
+          {
           float X = 0.8f;
           float Z1= 0.4f;
           float Z2= 3*C2-1.5f;
           float A = 1.5f;
           float B = 3*C2;
           float C = 3*SIN54;
           float X = (A*C)/(A+C);
           float Z1= A*(B-C)/(A+C);
           float Z2= B-A;
           float[][] vertices =
+             {
                  { 0.0f, 1.5f, 0,0f },
                  { 0.0f,-1.5f, 0,0f },
                  {   -X, 0.0f,  -Z1 },
                  {   +X, 0.0f,  -Z1 },
                  {   -X, 0.0f,  -Z2 },
                  {   +X, 0.0f,  -Z2 },
                  { 0, A,  0 },
                  { 0,-A,  0 },
                  {-X, 0,-Z1 },
                  {+X, 0,-Z1 },
                  {-X, 0,-Z2 },
                  {+X, 0,-Z2 },
              };
           int[][] indices =
+             {
                  {2,1,0},
                  {3,0,1},
                  {2,4,1},
                  {2,0,4},
                  {3,1,5},
-...
           return new ObjectShape(vertices, indices);
+          }
         if( variant==1 ) // center
+          {
           final double ANGLE = 0.825f*Math.PI;
           final float cosA  = (float)Math.cos(ANGLE);
           final float sinA  = (float)Math.sin(ANGLE);
           float TAN54 = SIN54/COS54;
           float R  = 1.5f*(TAN54-(1/TAN54));
           float X1 = R*COS54;
           float Y1 = R*SIN54;
           float X2 = R*COS18;
           float Y2 = R*SIN18;
           float Z  = 1.6f*R;  // TODO: about
         return null;
           float[][] vertices =
+            {
               {-X1,-Y1*sinA,-Y1*cosA},
               {-X2,+Y2*sinA,+Y2*cosA},
               { 0 ,+R*sinA ,+R*cosA },
               {+X2,+Y2*sinA,+Y2*cosA},
               {+X1,-Y1*sinA,-Y1*cosA},
               { 0 , Z*cosA ,-Z*sinA }
             };
           int[][] indices =
+            {
               {0,1,2,3,4},
               {5,1,0},
               {5,2,1},
               {5,3,2},
               {5,4,3},
               {5,0,4}
             };
           return new ObjectShape(vertices, indices);
+          }
         else
+          {
           float A = 1.5f;
           float B = 3*C2;
           float K = 1/(4*SIN54*SIN54);
           float X = A*K;
           float Y = (B-A)*K;
           float Z = B*K;
           float[][] vertices =
+             {
                  { 0, 0,   0 },
                  {-X, Y,  -Z },
                  {+X, Y,  -Z },
                  { 0, 0,-2*Z },
              };
           int[][] indices =
+             {
                  {2,1,0},
                  {1,2,3},
                  {2,0,3},
                  {1,3,0}
              };
           return new ObjectShape(vertices, indices);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
           int[] centerIndices = { 0,0,0,0,-1,-1 };
           return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,null);
+          }
         return null;
         else if( variant==1 )
+          {
           float h1 = isInIconMode() ? 0.001f : 0.02f;
           float[][] bands     = { {h1,10,0.5f,0.2f,5,1,0}, {0.001f, 1,0.5f,0.2f,5,1,0} };
           int[] bandIndices   = { 0,1,1,1,1,1 };
           float[][] corners   = { { 0.015f, 0.20f } };
           int[] cornerIndices = { 0,0,0,0,0,-1 };
           float[][] centers   = { { 0.0f,0.0f,-1.0f } };
           int[] centerIndices = { 0,0,0,0,0,-1 };
           return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,null);
+          }
         else
+          {
           float Z = 3*C2/(4*SIN54*SIN54);
           float h1 = isInIconMode() ? 0.001f : 0.02f;
           float[][] bands     = { {h1,6,0.5f,0.2f,5,1,0}, {0.001f, 1,0.5f,0.2f,5,1,0} };
           int[] bandIndices   = { 0,1,1,1 };
           float[][] corners   = { { 0.015f, 0.20f } };
           int[] cornerIndices = { 0,0,0,-1 };
           float[][] centers   = { { 0.0f,0.0f,-Z } };
           int[] centerIndices = { 0,0,0,-1 };
           return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,null);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getNumCubitVariants(int[] numLayers)
+        {
         return 1;
         return 3;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Also available in: Unified diff

Project

General

Profile

TwistyPuzzleLib

Revision 6074bff6

Added by Leszek Koltunski about 2 years ago