Magic Cube

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.effect.VertexEffectMove;

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.effect.VertexEffectScale;

import org.distorted.library.mesh.MeshJoined;

import org.distorted.library.mesh.MeshPolygon;

import org.distorted.library.type.Static1D;

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

  private float[] createVertices(int A, int B)

    {

    float E = 0.5f / Math.max(A,B);

    return new float[] { -A*E,-B*E, +A*E,-B*E, +A*E,+B*E, -A*E,+B*E };

    }

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

  private MeshBase createCuboid(int[] dimensions)

    {

    FactoryCubit factory = FactoryCubit.getInstance();

    int X = dimensions[0];

    int Y = dimensions[1];

    int Z = dimensions[2];

    float[] verticesXY = createVertices(X,Y);

    float[] verticesXZ = createVertices(X,Z);

    float[] verticesYZ = createVertices(Z,Y);

    float defHeight = 0.048f;

    float[] bandsX = factory.computeBands( defHeight/X,65,0.25f,0.5f,5);

    float[] bandsY = factory.computeBands( defHeight/Y,65,0.25f,0.5f,5);

    float[] bandsZ = factory.computeBands( defHeight/Z,65,0.25f,0.5f,5);

    MeshBase[] meshes = new MeshPolygon[6];

    meshes[0] = new MeshPolygon(verticesYZ,bandsX,1,2);

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

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

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

    meshes[2] = new MeshPolygon(verticesXZ,bandsY,1,2);

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

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

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

    meshes[4] = new MeshPolygon(verticesXY,bandsZ,1,2);

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

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

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

    return new MeshJoined(meshes);

    }

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

  private VertexEffect[] createCuboidEffects(int[] dimensions)

    {

    float X = dimensions[0];

    float Y = dimensions[1];

    float Z = dimensions[2];

    float MAX_XY = Math.max(X,Y);

    float MAX_XZ = Math.max(X,Z);

    float MAX_YZ = Math.max(Z,Y);

    Static1D angle = new Static1D(90);

    Static3D move  = new Static3D( 0.0f, 0.0f, 0.5f);

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

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

    Static3D center= new Static3D( 0.0f, 0.0f, 0.0f);

    Static3D scale3 = new Static3D(MAX_XY,MAX_XY,+Z);

    Static3D scale4 = new Static3D(MAX_XY,MAX_XY,-Z);

    Static3D scale5 = new Static3D(MAX_XZ,+Y,MAX_XZ);

    Static3D scale6 = new Static3D(MAX_XZ,-Y,MAX_XZ);

    Static3D scale7 = new Static3D(+X,MAX_YZ,MAX_YZ);

    Static3D scale8 = new Static3D(-X,MAX_YZ,MAX_YZ);

    VertexEffect[] effect = new VertexEffect[9];

    effect[0] = new VertexEffectMove(move);

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

    effect[2] = new VertexEffectRotate(angle, axisY, center);

    effect[3] = new VertexEffectScale(scale3);

    effect[4] = new VertexEffectScale(scale4);

    effect[5] = new VertexEffectScale(scale5);

    effect[6] = new VertexEffectScale(scale6);

    effect[7] = new VertexEffectScale(scale7);

    effect[8] = new VertexEffectScale(scale8);

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

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

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

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

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

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

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

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

    return effect;

    }

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

  private MeshBase createCuboidMesh(int[] dimensions)

    {

    MeshBase mesh = createCuboid(dimensions);

    VertexEffect[] effects = createCuboidEffects(dimensions);

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

    int X = dimensions[0];

    int Y = dimensions[1];

    int Z = dimensions[2];

    float strength = 0.04f;

    float radius   = 0.15f;

    Static3D[] vertices = new Static3D[1];

    Static3D center;

    FactoryCubit factory = FactoryCubit.getInstance();

    vertices[0] = new Static3D(+0.5f*X,+0.5f*Y,+0.5f*Z);

    center = new Static3D(+0.5f*(X-1),+0.5f*(Y-1),+0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(+0.5f*X,+0.5f*Y,-0.5f*Z);

    center = new Static3D(+0.5f*(X-1),+0.5f*(Y-1),-0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(+0.5f*X,-0.5f*Y,+0.5f*Z);

    center = new Static3D(+0.5f*(X-1),-0.5f*(Y-1),+0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(+0.5f*X,-0.5f*Y,-0.5f*Z);

    center = new Static3D(+0.5f*(X-1),-0.5f*(Y-1),-0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(-0.5f*X,+0.5f*Y,+0.5f*Z);

    center = new Static3D(-0.5f*(X-1),+0.5f*(Y-1),+0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(-0.5f*X,+0.5f*Y,-0.5f*Z);

    center = new Static3D(-0.5f*(X-1),+0.5f*(Y-1),-0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(-0.5f*X,-0.5f*Y,+0.5f*Z);

    center = new Static3D(-0.5f*(X-1),-0.5f*(Y-1),+0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(-0.5f*X,-0.5f*Y,-0.5f*Z);

    center = new Static3D(-0.5f*(X-1),-0.5f*(Y-1),-0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    mesh.mergeEffComponents();

    return mesh;

    }

        mMeshes[i] = createCuboidMesh(mDimensions[i]);