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;

  public static final float REX_D = 0.2f;

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

  MeshBase createFacesRexCorner()

    {

    MeshBase[] meshes = new MeshBase[2];

    float F = REX_D*SQ2;

    float G = (1-REX_D)*SQ2/2;

    float H = 0.1f;

    float J = +2*G/3 - H*G;

    float[] vertices = { -F/2, -G/3, +F/2, -G/3, H*F/2, J, -H*F/2, J};

    FactoryCubit factory = FactoryCubit.getInstance();

    float[] bands0 = factory.computeBands(+0.016f,10,G/3,0.5f,5);

    float[] bands1 = factory.computeBands(-0.230f,45,G/3,0.0f,2);

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

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

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

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

    return new MeshJoined(meshes);

    }

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

  MeshBase createFacesRexFace()

    {

    MeshBase[] meshes = new MeshBase[2];

    float[] vertices = { -REX_D,0.0f, 0.0f, -REX_D, +REX_D, 0.0f, 0.0f, +REX_D};

    FactoryCubit factory = FactoryCubit.getInstance();

    float[] bands0 = factory.computeBands(0.016f,10,REX_D/2,0.5f,5);

    float[] bands1 = factory.computeBands(0.000f,45,REX_D/2,0.0f,2);

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

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

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

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

    return new MeshJoined(meshes);

    }

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

  MeshBase createFacesRexEdge()

    {

    MeshBase[] meshes = new MeshPolygon[6];

    FactoryCubit factory = FactoryCubit.getInstance();

    float E = 0.5f - REX_D;

    float F = 0.5f;

    float[] vertices0 = { -F,E/3, 0,-2*E/3, +F,E/3 };

    float[] bands0 = factory.computeBands(0.03f,27,F/3,0.8f,5);

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

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

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

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

    float G = (float)Math.sqrt(E*E+F*F);

    float[] vertices1 = { -2*G/3, -E/3, G/3, -E/3, G/3, 2*E/3 };

    float[] bands1 = factory.computeBands(0.00f,45,G/3,0.2f,3);

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

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

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

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

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

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

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

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

    return new MeshJoined(meshes);

    }

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

  private VertexEffect[] createVertexEffectsRexEdge()

    {

    float E = 0.5f - REX_D;

    float F = 0.5f;

    float G = (float)Math.sqrt(E*E+F*F);

    float A = (float)((180/Math.PI)*Math.asin(E/G));

    Static3D move1 = new Static3D(    0.0f, -E/3, 0.0f);

    Static3D move2 = new Static3D(2*G/3 -F, +E/3, 0.0f);

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

    Static3D center1= new Static3D(  -F, 0.0f, 0.0f);

    Static3D center2= new Static3D(  +F, 0.0f, 0.0f);

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

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

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

    Static1D angle180 = new Static1D(180);

    Static1D angle90  = new Static1D( 90);

    Static1D angle270 = new Static1D(270);

    Static1D angle1   = new Static1D(+A);

    Static1D angle2   = new Static1D(-A);

    VertexEffect[] effect = new VertexEffect[12];

    effect[0] = new VertexEffectMove(move1);

    effect[1] = new VertexEffectMove(move2);

    effect[2] = new VertexEffectRotate(  angle90, axisX, center0 );

    effect[3] = new VertexEffectRotate( angle270, axisX, center0 );

    effect[4] = new VertexEffectRotate( angle180, axisX, center0 );

    effect[5] = new VertexEffectRotate( angle180, axisY, center0 );

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

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

    effect[8] = new VertexEffectRotate(   angle1, axisY, center1);

    effect[9] = new VertexEffectRotate(   angle2, axisY, center2);

    effect[10]= new VertexEffectRotate(   angle2, axisZ, center1);

    effect[11]= new VertexEffectRotate(   angle1, axisZ, center2);

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

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

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

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

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

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

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

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

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

    effect[9].setMeshAssociation(32,-1);  // apply to mesh 5

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

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

    return effect;

    }

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

  private VertexEffect[] createVertexEffectsRexCorner()

    {

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

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

    Static1D angle = new Static1D(225);

    VertexEffect[] effect = new VertexEffect[1];

    effect[0] = new VertexEffectRotate(angle, axisZ, center);

    return effect;

    }

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

  private MeshBase createRexCornerMesh()

    {

    MeshBase mesh = createFacesRexCorner();

    VertexEffect[] effects = createVertexEffectsRexCorner();

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

    final float G = (1-REX_D)/3;

    Static3D center = new Static3D(0.0f,0.0f,-G*SQ2/2);

    Static3D[] vertices = new Static3D[1];

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

    FactoryCubit.getInstance().roundCorners(mesh,center,vertices,0.10f,0.10f);

    mesh.mergeEffComponents();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    return mesh;

    }

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

  private MeshBase createRexFaceMesh()

    {

    MeshBase mesh = createFacesRexFace();

    mesh.mergeEffComponents();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    return mesh;

    }

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

  private MeshBase createRexEdgeMesh()

    {

    MeshBase mesh = createFacesRexEdge();

    VertexEffect[] effects = createVertexEffectsRexEdge();

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

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

    Static3D[] vertices = new Static3D[2];

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

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

    FactoryCubit.getInstance().roundCorners(mesh,center,vertices,0.06f,0.10f);

    mesh.mergeEffComponents();

    return mesh;

    }

      if( mCornerMesh==null ) mCornerMesh = createRexCornerMesh();

      if( mFaceMesh==null ) mFaceMesh = createRexFaceMesh();

      if( mEdgeMesh==null ) mEdgeMesh = createRexEdgeMesh();