Magic Cube

  private static final float SQ5 = (float)Math.sqrt(5);

  // KILO / MEGAMINX

  public static final float SIN54    = (SQ5+1)/4;

  public static final float COS54    = (float)(Math.sqrt(10-2*SQ5)/4);

  public static final float SIN18    = (SQ5-1)/4;

  public static final float COS18    = (float)(0.25f*Math.sqrt(10.0f+2.0f*SQ5));

  public static final float COS_HALFD= (float)(Math.sqrt(0.5f-0.1f*SQ5)); // cos(half the dihedral angle)

  public static final float SIN_HALFD= (float)(Math.sqrt(0.5f+0.1f*SQ5)); // sin(half the dihedral angle)

  public static final float DIHEDRAL1= (float)(Math.acos(-SQ5/5)*180/Math.PI);

  public static final float DIHEDRAL2= (float)((180/Math.PI)*Math.asin((2*SIN54*SIN54-1)/COS54) - 90);

///////////////////////////////////////////////////////////////////////////////////////////////////

  MeshBase createFacesMegaminxEdge(int numLayers, float width, float height)

    {

    MeshBase[] meshes = new MeshPolygon[6];

    float D = height/COS18;

    float W = D*SIN18;

    float Y1 = 0.5f*width;

    float Y2 = 0.5f*width + W;

    float Y3 = 0.5f*width + 2*W;

    float X2 = D*SIN54;

    float X1 = 0.5f*height;

    float Y4 = D*COS54;

    float[] vertices0 = { -X1, Y1, -X1, -Y1, X1, -Y2, X1, Y2 };

    float[] vertices1 = { -X1, Y3, -X1, -Y3, X1, -Y2, X1, Y2 };

    float[] vertices2 = { -X2, 0.0f, 0.0f, -Y4, X2, 0.0f, 0.0f, Y4 };

    int numBands0 = numLayers==3 ? 5 : 3;

    int numBands1 = numLayers==3 ? 2 : 2;

    float h       = numLayers==3 ? 0.03f : 0.03f;

    float[] bands0 = computeBands(h    ,34,0.2f,0.2f,numBands0);

    float[] bands1 = computeBands(0.00f,34,0.3f,0.2f,numBands1);

    meshes[0] = new MeshPolygon(vertices0, bands0, 0, 0);

    meshes[0].setEffectAssociation(0, 1,0);

    meshes[1] = meshes[0].copy(true);

    meshes[1].setEffectAssociation(0, 2,0);

    meshes[2] = new MeshPolygon(vertices1, bands1, 0, 0);

    meshes[2].setEffectAssociation(0, 4,0);

    meshes[3] = meshes[2].copy(true);

    meshes[3].setEffectAssociation(0, 8,0);

    meshes[4] = new MeshPolygon(vertices2, bands1, 0, 0);

    meshes[4].setEffectAssociation(0,16,0);

    meshes[5] = meshes[4].copy(true);

    meshes[5].setEffectAssociation(0,32,0);

    return new MeshJoined(meshes);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  MeshBase createFacesMegaminxCenter(int numLayers)

    {

    MeshBase[] meshes = new MeshPolygon[2];

    float R  = 0.5f;

    float X1 = R*COS54;

    float Y1 = R*SIN54;

    float X2 = R*COS18;

    float Y2 = R*SIN18;

    float[] vertices0 = { -X1,+Y1, -X2,-Y2, 0.0f,-R, +X2,-Y2, +X1,+Y1 };

    int numBands0 = numLayers==3 ? 4 : 3;

    int numBands1 = numLayers==3 ? 2 : 2;

    float h       = numLayers==3 ? 0.04f : 0.04f;

    float[] bands0 = computeBands( h    ,45, R/3,0.2f, numBands0);

    float[] bands1 = computeBands( 0.00f,34, R/3,0.2f, numBands1);

    meshes[0] = new MeshPolygon(vertices0, bands0, 0, 0);

    meshes[0].setEffectAssociation(0,1,0);

    meshes[1] = new MeshPolygon(vertices0, bands1, 0, 0);

    meshes[1].setEffectAssociation(0,2,0);

    return new MeshJoined(meshes);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  VertexEffect[] createVertexEffectsMegaminxEdge(float width, float height)

    {

    VertexEffect[] effect = new VertexEffect[11];

    float X = 0.5f*height;

    float Y = height*(COS54/COS18) + width*0.5f;

    float Z = 2*height*COS_HALFD;

    float alpha = 90-DIHEDRAL1/2;

    float beta  = DIHEDRAL2;

    Static1D angle1 = new Static1D(alpha);

    Static1D angle2 = new Static1D(180-alpha);

    Static1D angle3 = new Static1D(beta);

    Static3D move1 = new Static3D(X,0,0);

    Static3D move2 = new Static3D(X,0,-Z);

    Static3D move3 = new Static3D(0,+Y,0);

    Static3D move4 = new Static3D(0,-Y,0);

    Static3D scale = new Static3D(+1,+1,-1);

    Static3D axisXplus = new Static3D(+1, 0, 0);

    Static3D axisXminus= new Static3D(-1, 0, 0);

    Static3D axisYplus = new Static3D( 0,+1, 0);

    Static3D axisYminus= new Static3D( 0,-1, 0);

    Static3D center1= new Static3D( 0, 0, 0);

    Static3D center2= new Static3D( 0, 0,-Z);

    Static3D center3= new Static3D( 0,+width*0.5f, 0);

    Static3D center4= new Static3D( 0,-width*0.5f, 0);

    effect[ 0] = new VertexEffectMove(move1);

    effect[ 1] = new VertexEffectMove(move2);

    effect[ 2] = new VertexEffectMove(move3);

    effect[ 3] = new VertexEffectMove(move4);

    effect[ 4] = new VertexEffectScale(scale);

    effect[ 5] = new VertexEffectRotate(angle1, axisYplus , center1);

    effect[ 6] = new VertexEffectRotate(angle2, axisYplus , center1);

    effect[ 7] = new VertexEffectRotate(angle1, axisYminus, center2);

    effect[ 8] = new VertexEffectRotate(angle2, axisYminus, center2);

    effect[ 9] = new VertexEffectRotate(angle3, axisXplus , center3);

    effect[10] = new VertexEffectRotate(angle3, axisXminus, center4);

    effect[ 0].setMeshAssociation( 3,-1);  // meshes 0,1

    effect[ 1].setMeshAssociation(12,-1);  // meshes 2,3

    effect[ 2].setMeshAssociation(16,-1);  // mesh 4

    effect[ 3].setMeshAssociation(32,-1);  // mesh 5

    effect[ 4].setMeshAssociation( 2,-1);  // mesh 1

    effect[ 5].setMeshAssociation( 1,-1);  // mesh 0

    effect[ 6].setMeshAssociation( 2,-1);  // mesh 1

    effect[ 7].setMeshAssociation( 4,-1);  // mesh 2

    effect[ 8].setMeshAssociation( 8,-1);  // mesh 3

    effect[ 9].setMeshAssociation(16,-1);  // mesh 4

    effect[10].setMeshAssociation(32,-1);  // mesh 5

    return effect;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  VertexEffect[] createVertexEffectsMegaminxCenter(float width)

    {

    VertexEffect[] effect = new VertexEffect[2];

    Static1D angle = new Static1D(DIHEDRAL2);

    Static3D axisX = new Static3D( 1.0f, 0.0f, 0.0f);

    Static3D center= new Static3D( 0, 0, 0);

    effect[0] = new VertexEffectScale(width/COS54);

    effect[1] = new VertexEffectRotate(angle, axisX, center);

    return effect;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// numLayers==3 --> index=0; numLayers=5 --> index=1 ...

// type: 0,1,... 0 --> edge, 1 --> 1 layer deeper, etc

  public MeshBase createMegaminxEdgeMesh(int numLayers, float width, float height)

    {

    MeshBase mesh = createFacesMegaminxEdge(numLayers,width,height);

    VertexEffect[] effects = createVertexEffectsMegaminxEdge(width,height);

    for( VertexEffect effect : effects ) mesh.apply(effect);

    mesh.mergeEffComponents();

    return mesh;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public MeshBase createMegaminxCenterMesh(int numLayers, float width)

    {

    MeshBase mesh = createFacesMegaminxCenter(numLayers);

    VertexEffect[] effects = createVertexEffectsMegaminxCenter(width);

    for( VertexEffect effect : effects ) mesh.apply(effect);

    mesh.mergeEffComponents();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    return mesh;

    }

    printStickerCoords();