Magic Cube

import static org.distorted.objects.TwistyMegaminx.MEGA_D;

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

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

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

  static final float MINX_SC  = 0.5f;

  MeshBase createFacesKilominxCorner()

    float X2= MINX_SC*H* SIN_HALFD;

    float Y3= MINX_SC*H/(2*COS_HALFD);

    float Y4= MINX_SC*H*(1/(2*COS_HALFD) - COS_HALFD);

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

  MeshBase createFacesMegaminxCorner()

    {

    MeshBase[] meshes = new MeshPolygon[6];

    float Y = COS54/(2*SIN54);

    float[] vertices0 = { -0.5f, 0.0f, 0.0f, -Y, 0.5f, 0.0f, 0.0f, Y };

    float[] bands0 = computeBands(0.04f,34,0.3f,0.2f,5);

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

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

    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);

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

    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);

    }

  VertexEffect[] createVertexEffectsKilominxCorner()

    float Y2= H/(2*COS_HALFD);

    float LEN   = (float)Math.sqrt(H*H/(COS_HALFD*COS_HALFD) + 0.25f);

    Static3D axisC = new Static3D( H/LEN, -0.5f/LEN,-H* SIN_HALFD /(COS_HALFD*LEN));

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

  VertexEffect[] createVertexEffectsMegaminxCorner(int numLayers)

    {

    VertexEffect[] effect = new VertexEffect[9];

    float Y = COS54/(2*SIN54);

    float A = (float)(Math.acos(-SQ5/5)*180/Math.PI);  // dihedral angle of a dedecahedron in degrees

    float sinA = (2*SIN54*SIN54-1)/COS54;

    float cosA = (float)Math.sqrt(1-sinA*sinA);

    float LEN  = 0.5f/SIN54;

    float scale= 2*SIN54*(0.5f-MEGA_D)/(0.5f*(numLayers-1));

    Static3D axisA = new Static3D( SIN54, COS54, 0.0f);

    Static3D axisB = new Static3D(-SIN54, COS54, 0.0f);

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

    Static3D centerU = new Static3D( 0.0f, Y, 0.0f);

    Static3D centerD = new Static3D( 0.0f,-Y, 0.0f);

    Static3D move1= new Static3D(0.0f, -sinA*LEN, -cosA*LEN );

    Static3D move2= new Static3D(0.0f, Y , 0.0f );

    Static1D angleD = new Static1D(A);

    Static1D angleE = new Static1D(360-A);

    Static1D angleF = new Static1D( (float)((180/Math.PI)*Math.asin(sinA) - 90) );

    effect[0] = new VertexEffectScale ( new Static3D( 1, 1,-1) );

    effect[1] = new VertexEffectRotate(angleE, axisA, centerU);

    effect[2] = new VertexEffectRotate(angleD, axisB, centerU);

    effect[3] = new VertexEffectMove(move1);

    effect[4] = new VertexEffectRotate(angleE, axisA, centerD);

    effect[5] = new VertexEffectRotate(angleD, axisB, centerD);

    effect[6] = new VertexEffectRotate(angleF, axisX, centerD);

    effect[7] = new VertexEffectMove(move2);

    effect[8] = new VertexEffectScale(scale);

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

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

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

    effect[3].setMeshAssociation( 56,-1);  // meshes 3,4,5

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

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

    return effect;

    }

  MeshBase createKilominxCornerMesh()

    MeshBase mesh = createFacesKilominxCorner();

    VertexEffect[] effects = createVertexEffectsKilominxCorner();

    float X = SIN_HALFD * SIN54 *COS54  ;

    float Z = COS_HALFD* SIN54 *COS54  ;

    return mesh;

    }

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

  MeshBase createMegaminxCornerMesh(int numLayers)

    {

    MeshBase mesh = createFacesMegaminxCorner();

    VertexEffect[] effects = createVertexEffectsMegaminxCorner(numLayers);

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

    float A = (2*SQ3/3)* SIN54;

    float B = 0.4f;

    float X = SIN_HALFD* SIN54 * COS54;

    float Y = SIN54 * SIN54 - 0.5f;

    float Z = COS_HALFD* SIN54 * COS54;

    float S = 2*SIN54*(0.5f-MEGA_D)/(0.5f*(numLayers-1));

    Static3D center = new Static3D(0.0f, -(float)Math.sqrt(1-A*A)*B,-A*B);

    Static3D[] vertices = new Static3D[4];

    vertices[0] = new Static3D( 0.0f, 0.0f  , 0.0f);

    vertices[1] = new Static3D( 0.0f,-0.5f*S, 0.0f);

    vertices[2] = new Static3D(-X*S , Y*S   ,-Z*S );

    vertices[3] = new Static3D(+X*S , Y*S   ,-Z*S );

    roundCorners(mesh,center,vertices,0.04f,0.10f);

    mesh.mergeEffComponents();