Magic Cube

  MeshBase createFacesMinxCorner(int numLayers)

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

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

    {

     MeshBase[] meshes = new MeshPolygon[6];

    float D = height/COS18;

    float W = D*SIN18;

    float X1 = height/2;

    float Y1 = width/2;

    float Y2 = (width+W)/2;

    float X3 = D*SIN54;

    float Y3 = D*COS54;

    float X4 = height*SIN_HALFD;

    float Y4 = height*COS_HALFD;

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

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

    float[] vertices2 = { -X3, 0.0f, 0.0f, -Y3, X3, 0.0f, 0.0f, Y3 };

    float[] vertices3 = { -X4, 0.0f, 0.0f, -Y4, X4, 0.0f, 0.0f, Y4 };

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

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

    float h       = numLayers<=5 ? 0.03f : 0.03f;

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

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

    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] = 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, 1, 2);

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

    meshes[5] = new MeshPolygon(vertices3, bands1, 1, 2);

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

    return new MeshJoined(meshes);

    }

  VertexEffect[] createVertexEffectsMinxCorner(float width)

    float scale= width/LEN;

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

  VertexEffect[] createVertexEffectsKilominxEdge(float width, float height, boolean left)

    {

    VertexEffect[] effect = new VertexEffect[11 + (left ? 0:1)];

    float D = height/COS18;

    float W = D*SIN18;

    float X1 = height/2;

    float Y1 = width/2;

    float Y2 = (width+W)/2;

    float Y3 = D*COS54;

    float Y4 = height*COS_HALFD;

    float Z = 2*height*COS_HALFD;

    float alpha = 90-DIHEDRAL1/2;

    Static1D angle1 = new Static1D(alpha);

    Static1D angle2 = new Static1D(180-alpha);

    Static1D angle3 = new Static1D(DIHEDRAL2);

    Static1D angle4 = new Static1D(90);

    Static3D move1 = new Static3D(+X1,-Y1,0);

    Static3D move2 = new Static3D(-X1,-Y2+W,-Z);

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

    Static3D move4 = new Static3D(0,-Y4-width,0);

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

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

    Static3D axisYplus = 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);

    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, axisYplus , center2);

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

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

    effect[10] = new VertexEffectRotate(angle4, axisXplus , center3);

    if( !left )

      {

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

      effect[11] = new VertexEffectScale(scale1);

      }

    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;

    }

  MeshBase createKilominxEdgeMesh(int numLayers, float width, float height, boolean left)

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

    VertexEffect[] effects = createVertexEffectsKilominxEdge(width,height,left);

// round...

  MeshBase createMinxCornerMesh(int numLayers, float width)

    MeshBase mesh = createFacesMinxCorner(numLayers);

    VertexEffect[] effects = createVertexEffectsMinxCorner(width);

/*

    float S = 2*width;

*/

    Static3D[] vertices = new Static3D[1];

/*

*/

    int leftRight = 2*(part%2) -1;

      float T = 0.5f + leftRight/(numLayers-1.0f);

      float x = D * (T*c1[0]+(1.0f-T)*c2[0]);

      float y = D * (T*c1[1]+(1.0f-T)*c2[1]);

      float z = D * (T*c1[2]+(1.0f-T)*c2[2]);

      float x = 0.5f * D * (c1[0]+c2[0]);

      float y = 0.5f * D * (c1[1]+c2[1]);

      float z = 0.5f * D * (c1[2]+c2[2]);

      float T = 0.5f + leftRight*(mult*D*SIN18 + 1.0f)/(numLayers-1);

      x = D * (T*c1[0]+(1.0f-T)*c2[0]);

      y = D * (T*c1[1]+(1.0f-T)*c2[1]);

      z = D * (T*c1[2]+(1.0f-T)*c2[2]);

      float H = mult*D*COS18/(numLayers-1);

      H /= (float)Math.sqrt(vX*vX+vY*vY+vZ*vZ);

      return new float[] { x + H*vX, y + H*vY, z + H*vZ };

        float width = (numLayers/3.0f)/(numLayers-1);

        mCornerMeshes[indexCornerEdge] = FactoryCubit.getInstance().createMinxCornerMesh(numLayers,width);

        mEdgeMeshes[indexCornerEdge][type] = FactoryCubit.getInstance().createKilominxEdgeMesh(numLayers,width,height, (type%2)==0 );

        float width = (numLayers/3.0f)*(0.5f-MEGA_D)/(0.5f*(numLayers-1));

        mCornerMeshes[index] = FactoryCubit.getInstance().createMinxCornerMesh(numLayers, width);

  // the quadruple ( corner1, corner2, face1, face2 ) defining an edge.

  // In fact the 2 corners already define it, the faces only provide easy

  // the 'left' or right of vector corner1 --> corner2, according to Quat.