/ - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision 0919eba7

Added by Leszek Koltunski over 4 years ago

ID 0919eba7214afd2a2e622ebac62521c38b6f45e6
Parent b0ed406c
Child 728cff8b

Correct still one bug with collapsing stickers in teh new Cubit engine.
Convert the Helicopter corner cubits to the new engine.

+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       MeshBase createFacesHelicopterCorner()
+        {
         MeshBase[] meshes = new MeshBase[6];
         float E = 0.5f;
         float F = SQ2/4;
         float G = 1.0f/12;
         float[] vertices0 = { -E+E/4,E/4, E/4,-E+E/4, E/4,E/4};
         float[] bands0 = computeBands(0.028f,35,E/4,0.7f,7);
         meshes[0] = new MeshPolygon(vertices0, bands0, 3, 3);
         meshes[0].setEffectAssociation(0,1,0);
         meshes[1] = meshes[0].copy(true);
         meshes[1].setEffectAssociation(0,2,0);
         meshes[2] = meshes[0].copy(true);
         meshes[2].setEffectAssociation(0,4,0);
         float[] vertices1 = { -F,-G, 0,-G, +F,-G, 0,2*G };
         float[] bands1 = computeBands(0.00f,0,0,0.0f,3);
         meshes[3] = new MeshPolygon(vertices1,bands1,1,5);
         meshes[3].setEffectAssociation(0,8,0);
         meshes[4] = meshes[3].copy(true);
         meshes[4].setEffectAssociation(0,16,0);
         meshes[5] = meshes[3].copy(true);
         meshes[5].setEffectAssociation(0,32,0);
         return new MeshJoined(meshes);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       MeshBase createFacesHelicopterFace()
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // EFFECTS
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       VertexEffect[] createVertexEffectsHelicopterCorner()
+        {
         float E = 0.5f;
         Static3D axisX  = new Static3D(1,0,0);
         Static3D axisY  = new Static3D(0,1,0);
         Static3D axis0  = new Static3D(-SQ2/2,0,SQ2/2);
         Static3D axis1  = new Static3D(+SQ3/3,+SQ3/3,+SQ3/3);
         Static1D angle1 = new Static1D(+90);
         Static1D angle2 = new Static1D(-90);
         Static1D angle3 = new Static1D(-135);
         Static1D angle4 = new Static1D(90);
         Static1D angle5 = new Static1D(120);
         Static1D angle6 = new Static1D(240);
         Static3D center1= new Static3D(0,0,0);
         Static3D center2= new Static3D(-0.25f,-0.25f,-0.25f);
         Static3D move1  = new Static3D(-E/4,-E/4,0);
         Static3D move2  = new Static3D(-0.25f,(-1.0f/6)-0.25f,-0.25f);
         VertexEffect[] effect = new VertexEffect[10];
         effect[0] = new VertexEffectMove(move1);
         effect[1] = new VertexEffectScale(new Static3D(1,1,-1));
         effect[2] = new VertexEffectRotate(angle1,axisX,center1);
         effect[3] = new VertexEffectRotate(angle2,axisY,center1);
         effect[4] = new VertexEffectMove(move2);
         effect[5] = new VertexEffectRotate(angle1,axisX,center2);
         effect[6] = new VertexEffectRotate(angle3,axisY,center2);
         effect[7] = new VertexEffectRotate(angle4,axis0,center2);
         effect[8] = new VertexEffectRotate(angle5,axis1,center2);
         effect[9] = new VertexEffectRotate(angle6,axis1,center2);
         effect[0].setMeshAssociation( 7,-1);  // meshes 0,1,2
         effect[1].setMeshAssociation( 6,-1);  // meshes 1,2
         effect[2].setMeshAssociation( 2,-1);  // mesh 1
         effect[3].setMeshAssociation( 4,-1);  // mesh 2
         effect[4].setMeshAssociation(56,-1);  // meshes 3,4,5
         effect[5].setMeshAssociation(56,-1);  // meshes 3,4,5
         effect[6].setMeshAssociation(56,-1);  // meshes 3,4,5
         effect[7].setMeshAssociation(56,-1);  // meshes 3,4,5
         effect[8].setMeshAssociation(16,-1);  // mesh 4
         effect[9].setMeshAssociation(32,-1);  // mesh 5
         return effect;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       VertexEffect[] createVertexEffectsHelicopterFace()
-...
     // OBJECTS
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Helicopter
       public MeshBase createHelicopterCornerMesh()
+        {
         MeshBase mesh = createFacesHelicopterCorner();
         VertexEffect[] effects = createVertexEffectsHelicopterCorner();
         for( VertexEffect effect : effects ) mesh.apply(effect);
         float E = 0.5f;
         Static3D roundingCenter = new Static3D(-E/2,-E/2,-E/2);
         Static3D[] verticesType1 = new Static3D[1];
         verticesType1[0] = new Static3D(0.0f,0.0f,0.0f);
         roundCorners(mesh,roundingCenter,verticesType1,0.08f,0.15f);
         Static3D[] verticesType2 = new Static3D[3];
         verticesType2[0] = new Static3D(-E, 0, 0);
         verticesType2[1] = new Static3D( 0,-E, 0);
         verticesType2[2] = new Static3D( 0, 0,-E);
         roundCorners(mesh,roundingCenter,verticesType2,0.08f,0.20f);
         mesh.mergeEffComponents();
         return mesh;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public MeshBase createHelicopterFaceMesh()
+        {
         MeshBase mesh = createFacesHelicopterFace();
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private double computeScale(double[] v1, double[] v2)
       private double computeScale(double[] v1, double[] v2, int v1i, int v2i)
+        {
         double lenSq1 = v1[0]*v1[0] + v1[1]*v1[1];
         double lenSq2 = v2[0]*v2[0] + v2[1]*v2[1];
         double v1x = v1[2*v1i];
         double v1y = v1[2*v1i+1];
         double v2x = v2[2*v2i];
         double v2y = v2[2*v2i+1];
         double lenSq1 = v1x*v1x + v1y*v1y;
         double lenSq2 = v2x*v2x + v2y*v2y;
         return Math.sqrt(lenSq2/lenSq1);
+        }
-...
       private boolean isScaledVersionOf(double[] newVert, double[] oldVert, int len, int vertex, boolean inverted)
+        {
         int newZeroIndex = computeRotatedIndex(0,len,vertex,inverted);
         double EPSILON = 0.001;
         double scale = computeScale(newVert,oldVert);
         double scale = computeScale(newVert,oldVert,newZeroIndex,0);
         for(int i=1; i<len; i++)
+          {
-...
           if( isScaledVersionOf(buffer,oldVert,len,vertex,inverted) )
+            {
             double scale = computeScale(oldVert,newVert);
             int newZeroIndex = computeRotatedIndex(0,len,vertex,inverted);
             double scale = computeScale(oldVert,newVert,0,newZeroIndex);
             correctInfo(info,scale,sin,cos,oldSticker,inverted);
             return true;
+            }

     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Static4D;
     import org.distorted.main.R;
     import org.distorted.main.RubikSurfaceView;
     import java.util.Random;
-...
       private static final int[] QUAT_INDICES =
           { 0,13,14,1,12,2,3,7,20,6,13,17,7,23,18,12,22,10,8,16,11,21,19,9,3,15,14,0,5,2,1,4 };
       private final double[][] VERTICES_CORNER = new double[][]
       private static final double[][] VERTICES_CORNER = new double[][]
+              {
                 // TODO
                 {-0.50f, 0.00f, 0.00f},
                 { 0.00f,-0.50f, 0.00f},
                 { 0.00f, 0.00f,-0.50f},
                 {-0.25f,-0.25f,-0.25f},
                 { 0.00f, 0.00f, 0.00f}
               };
       private final int[][] VERT_INDEXES_CORNER = new int[][]
       private static final int[][] VERT_INDEXES_CORNER = new int[][]
+              {
                 // TODO
                 {0,1,4},
                 {2,0,4},
                 {1,2,4},
                 {3,1,0},
                 {3,2,1},
                 {3,0,2}
               };
       private final double[][] VERTICES_FACE = new double[][]
       private static final float E = 0.1666666f;
       private static final double[][] VERTICES_FACE = new double[][]
+              {
                 { 0.00f +E, 0.00f +E, 0.00f },
                 { 0.50f +E, 0.00f +E, 0.00f },
                 { 0.00f +E, 0.50f +E, 0.00f },
                 { 0.25f +E, 0.25f +E,-0.25f },
               };
       private static final int[][] VERT_INDEXES_FACE = new int[][]
+              {
                 // TODO
                 { 0,1,2 },
                 { 2,1,3 },
                 { 0,1,3 },
                 { 2,0,3 }
               };
       private final int[][] VERT_INDEXES_FACE = new int[][]
       private static final float[][] STICKERS = new float[][]
+              {
                 // TODO
                 { -0.5f, 0.25f, 0.25f, -0.5f, 0.25f, 0.25f }
               };
       private static MeshBase mCornerMesh, mFaceMesh;
       private static MeshBase[] mMeshes;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       double[][] getVertices(int cubitType)
+        {
          if( cubitType==0 )  // Corner
+          {
           return VERTICES_CORNER;
+          }
         if( cubitType==1 )  // Face
+          {
           return VERTICES_FACE;
+          }
         if( cubitType==0 ) return VERTICES_CORNER;
         if( cubitType==1 ) return VERTICES_FACE;
         return null;
+        }
-...
       int[][] getVertIndexes(int cubitType)
+        {
         if( cubitType==0 )  // Corner
+          {
           return VERT_INDEXES_CORNER;
+          }
         if( cubitType==1 )  // Face
+          {
           return VERT_INDEXES_FACE;
+          }
         if( cubitType==0 ) return VERT_INDEXES_CORNER;
         if( cubitType==1 ) return VERT_INDEXES_FACE;
         return null;
+        }
-...
       int getNumCubitTypes(int numLayers)
+        {
         return 1;
         return 2;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       MeshBase createCubitMesh(int cubit, int numLayers)
+        {
         if( mMeshes==null )
+          {
           FactoryCubit factory = FactoryCubit.getInstance();
           factory.clear();
           mMeshes = new MeshBase[2];
+          }
         MeshBase mesh;
         if( cubit<8 )
+          {
           if( mCornerMesh==null ) mCornerMesh = FactoryCubit.getInstance().createHelicopterCornerMesh();
           mesh = mCornerMesh.copy(true);
           if( mMeshes[0]==null )
+            {
             float[][] bands= new float[][]
+              {
                  {0.028f,35,0.16f,0.7f,7,3,3},
                  {0.000f, 0,1.00f,0.0f,3,1,5}
               };
             int[] bandIndexes   = new int[] { 0,0,0,1,1,1 };
             float[][] corners   = new float[][] { {0.08f,0.15f}, {0.08f,0.20f} };
             int[] cornerIndexes = new int[] { 1,1,1,0,0 };
             float[][] centers   = new float[][] { {-0.25f, -0.25f, -0.25f} };
             int[] centerIndexes = new int[] { 0,0,0,-1,0 };
             FactoryCubit factory = FactoryCubit.getInstance();
             factory.createNewFaceTransform(VERTICES_CORNER,VERT_INDEXES_CORNER);
             mMeshes[0] = factory.createRoundedSolid(VERTICES_CORNER, VERT_INDEXES_CORNER,
                                                     bands, bandIndexes,
                                                     corners, cornerIndexes,
                                                     centers, centerIndexes,
                                                     getNumCubitFaces() );
+            }
           mesh = mMeshes[0].copy(true);
+          }
         else
+          {
           if( mFaceMesh==null ) mFaceMesh = FactoryCubit.getInstance().createHelicopterFaceMesh();
           mesh = mFaceMesh.copy(true);
           if( mMeshes[1]==null ) mMeshes[1] = FactoryCubit.getInstance().createHelicopterFaceMesh();
             /*
+            {
             float[][] bands= new float[][]
+              {
                  {0.028f,35,0.16f,0.7f,7,3,3},
                  {0.000f, 0,1.00f,0.0f,3,1,3}
               };
             int[] bandIndexes   = new int[] { 0,1,1,1 };
             float[][] corners   = new float[][] { {0.06f,0.15f}, {0.06f,0.20f} };
             int[] cornerIndexes = new int[] { 0,1,1,-1 };
             float[][] centers   = new float[][] { {-1.0f/12, -1.0f/12, -1.0f/4} };
             int[] centerIndexes = new int[] { 0,0,0,-1 };
             FactoryCubit factory = FactoryCubit.getInstance();
             factory.createNewFaceTransform(VERTICES_FACE,VERT_INDEXES_FACE);
             mMeshes[1] = factory.createRoundedSolid(VERTICES_FACE, VERT_INDEXES_FACE,
                                                     bands, bandIndexes,
                                                     corners, cornerIndexes,
                                                     centers, centerIndexes,
                                                     getNumCubitFaces() );
+            }
              */
           mesh = mMeshes[1].copy(true);
+          }
         int index = QUAT_INDICES[cubit];

src/main/java/org/distorted/objects/TwistySkewb.java
521	521	corners, cornerIndexes,
522	522	centers, centerIndexes,
523	523	getNumCubitFaces() );
524		//mMeshes[0] = FactoryCubit.getInstance().createSkewbCornerMesh();
525	524	}
526	525	mesh = mMeshes[0].copy(true);
527	526	}

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision 0919eba7

Added by Leszek Koltunski over 4 years ago