/src/main/java/org/distorted/objects/TwistyDiamond.java - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision 31cd7256

Added by Leszek Koltunski about 3 years ago

ID 31cd725613d0cffc6af6dfcd8ec02f6910c466ee
Parent b1f2ccf5
Child 596d62a4

Convert the second and third object, the Pyraminx and the Diamond, to the new Cubit-creating engine.

       private static final int[] mTetraToFaceMap = new int[] {1,2,3,0,5,6,7,4};
       private final double[][] VERTICES_TETRA = new double[][]
       private static final double[][] VERTICES_TETRA = new double[][]
+              {
                  {-0.5, SQ2/4, 0.0},
                  { 0.5, SQ2/4, 0.0},
-...
                  { 0.0,-SQ2/4,-0.5}
               };
       private final int[][] VERT_INDEXES_TETRA = new int[][]
       private static final int[][] VERT_INDEXES_TETRA = new int[][]
+              {
                  {2,1,0},   // counterclockwise!
                  {2,3,1},
-...
                  {3,0,1}
               };
       private final double[][] VERTICES_OCTA = new double[][]
       private static final double[][] VERTICES_OCTA = new double[][]
+              {
                  { 0.5,   0.0, 0.5},
                  { 0.5,   0.0,-0.5},
-...
                  { 0.0,-SQ2/2, 0.0}
               };
       private final int[][] VERT_INDEXES_OCTA = new int[][]
       private static final int[][] VERT_INDEXES_OCTA = new int[][]
+              {
                  {3,0,4},   // counterclockwise!
                  {0,1,4},
-...
                  {5,3,2}
               };
       private static MeshBase mOctaMesh, mTetraMesh;
       private static final float[][] STICKERS = new float[][]
+              {
                  { -0.4330127f, -0.25f, 0.4330127f, -0.25f, 0.0f, 0.5f }
               };
       private static MeshBase[] mMeshes;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       double[][] getVertices(int cubitType)
+        {
         if( cubitType==0 )  // Tetrahedron
+          {
           return VERTICES_TETRA;
+          }
         if( cubitType==1 )  // Octahedron
+          {
           return VERTICES_OCTA;
+          }
         if( cubitType==0 ) return VERTICES_OCTA;
         if( cubitType==1 ) return VERTICES_TETRA;
         return null;
+        }
-...
       int[][] getVertIndexes(int cubitType)
+        {
         if( cubitType==0 )  // Tetrahedron
+          {
           return VERT_INDEXES_TETRA;
+          }
         if( cubitType==1 )  // Octahedron
+          {
           return VERT_INDEXES_OCTA;
+          }
         if( cubitType==0 ) return VERT_INDEXES_OCTA;
         if( cubitType==1 ) return VERT_INDEXES_TETRA;
         return null;
+        }
-...
       int getNumStickerTypes(int numLayers)
+        {
         return 1;
         return STICKERS.length;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int createOctahedrons(float[][] centers, int index, int layers, float height)
       private int createOctaPositions(float[][] centers, int index, int layers, float height)
+        {
         float x = DIST*(layers-1);
         float z = DIST*(layers+1);
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int createTetrahedrons(float[][] centers, int index, int layers, float height)
       private int createTetraPositions(float[][] centers, int index, int layers, float height)
+        {
         float x = DIST*(layers-1);
         float z = DIST*layers;
-...
         float[][] CENTERS = new float[numO+numT][3];
         index = createOctahedrons(CENTERS,index,layers,height);
         index = createOctaPositions(CENTERS,index,layers,height);
         for(int i=layers-1; i>0; i--)
+          {
           height += SQ2*DIST;
           index = createOctahedrons(CENTERS,index,i,+height);
           index = createOctahedrons(CENTERS,index,i,-height);
           index = createOctaPositions(CENTERS,index,i,+height);
           index = createOctaPositions(CENTERS,index,i,-height);
+          }
         height = DIST*SQ2/2;
         for(int i=layers; i>1; i--)
+          {
           index = createTetrahedrons(CENTERS,index,i,+height);
           index = createTetrahedrons(CENTERS,index,i,-height);
           index = createTetraPositions(CENTERS,index,i,+height);
           index = createTetraPositions(CENTERS,index,i,-height);
           height += SQ2*DIST;
+          }
-...
       MeshBase createCubitMesh(int cubit, int numLayers)
+        {
         if( mMeshes==null )
+          {
           FactoryCubit factory = FactoryCubit.getInstance();
           factory.clear();
           mMeshes = new MeshBase[2];
+          }
         MeshBase mesh;
         int numO = getNumOctahedrons(numLayers);
         if( cubit<numO )
+          {
           if( mOctaMesh==null ) mOctaMesh = FactoryCubit.getInstance().createOctaMesh();
           mesh = mOctaMesh.copy(true);
           if( mMeshes[0]==null )
+            {
             float[][] bands     = new float[][] { {0.05f,35,0.5f,0.8f,6,2,2} };
             int[] bandIndexes   = new int[] { 0,0,0,0,0,0,0,0 };
             float[][] corners   = new float[][] { {0.04f,0.20f} };
             int[] cornerIndexes = new int[] { 0,0,0,0,0,0 };
             FactoryCubit factory = FactoryCubit.getInstance();
             factory.createNewFaceTransform(VERTICES_OCTA,VERT_INDEXES_OCTA);
             mMeshes[0] = factory.createRoundedSolid(VERTICES_OCTA, VERT_INDEXES_OCTA,
                                                     bands, bandIndexes,
                                                     corners, cornerIndexes,
                                                     getNumCubitFaces() );
+            }
           mesh = mMeshes[0].copy(true);
+          }
         else
+          {
           if( mTetraMesh==null ) mTetraMesh = FactoryCubit.getInstance().createTetraMesh();
           mesh = mTetraMesh.copy(true);
           if( mMeshes[1]==null )
+            {
             float[][] bands     = new float[][] { {0.05f,35,0.5f,0.8f,6,2,2} };
             int[] bandIndexes   = new int[] { 0,0,0,0 };
             float[][] corners   = new float[][] { {0.08f,0.15f} };
             int[] cornerIndexes = new int[] { 0,0,0,0 };
             FactoryCubit factory = FactoryCubit.getInstance();
             factory.createNewFaceTransform(VERTICES_TETRA,VERT_INDEXES_TETRA);
             mMeshes[1] = factory.createRoundedSolid(VERTICES_TETRA, VERT_INDEXES_TETRA,
                                                     bands, bandIndexes,
                                                     corners, cornerIndexes,
                                                     getNumCubitFaces() );
+            }
           mesh = mMeshes[1].copy(true);
+          }
         Static4D sQ = getQuat(cubit,numLayers,numO);
-...
       void createFaceTexture(Canvas canvas, Paint paint, int face, int left, int top)
+        {
         float E = 0.75f;
         float F = 0.50f;
         float R = 0.06f;
         float S = 0.07f;
         float[] vertices = { -F,-E/3, +F,-E/3, 0.0f,2*E/3};
         FactorySticker factory = FactorySticker.getInstance();
         factory.drawRoundedPolygon(canvas, paint, left, top, vertices, S, FACE_COLORS[face], R);
         factory.drawRoundedPolygon(canvas, paint, left, top, STICKERS[0], S, FACE_COLORS[face], R);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision 31cd7256

Added by Leszek Koltunski about 3 years ago