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 IVY_D = 0.003f;

  public static final float IVY_C = 0.59f;

  public static final float IVY_M = 0.35f;

  private static final int IVY_N = 8;

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

  MeshBase createFacesIvyCorner()

    {

    MeshBase[] meshes = new MeshBase[6];

    final float angle = (float)Math.PI/(2*IVY_N);

    final float CORR  = 1.0f - 2*IVY_D;

    final float DIST  = -0.5f*CORR + IVY_D;

    float[] vertices  = new float[2*(IVY_N+1)+6];

    vertices[0] = (0.5f-IVY_M) * IVY_C;

    vertices[1] = (DIST-IVY_M) * IVY_C;

    vertices[2] = (0.5f-IVY_M) * IVY_C;

    vertices[3] = (0.5f-IVY_M) * IVY_C;

    vertices[4] = (DIST-IVY_M) * IVY_C;

    vertices[5] = (0.5f-IVY_M) * IVY_C;

    for(int i=0; i<=IVY_N; i++)

      {

      float ang = (IVY_N-i)*angle;

      float sin = (float)Math.sin(ang);

      float cos = (float)Math.cos(ang);

      vertices[2*i+6] = (CORR*(cos-0.5f)-IVY_M)*IVY_C;

      vertices[2*i+7] = (CORR*(sin-0.5f)-IVY_M)*IVY_C;

      }

    FactoryCubit factory = FactoryCubit.getInstance();

    float[] bands0 = factory.computeBands(+0.012f,20,0.2f,0.5f,7);

    float[] bands1 = factory.computeBands(-0.100f,20,0.2f,0.0f,2);

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

    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(vertices,bands1,1,2);

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

    }

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

  private VertexEffect[] createVertexEffectsIvyCorner()

    {

    Static3D axisX  = new Static3D(1,0,0);

    Static3D axisY  = new Static3D(0,1,0);

    Static1D angle1 = new Static1D(+90);

    Static1D angle2 = new Static1D(-90);

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

    Static3D move1  = new Static3D(IVY_M-0.5f,IVY_M-0.5f,0);

    VertexEffect[] effect = new VertexEffect[5];

    effect[0] = new VertexEffectScale(1/IVY_C);

    effect[1] = new VertexEffectMove(move1);

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

    effect[3] = new VertexEffectRotate(angle1,axisX,center);

    effect[4] = new VertexEffectRotate(angle2,axisY,center);

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

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

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

    return effect;

    }

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

  private MeshBase createFacesIvyFace()

    {

    MeshBase[] meshes = new MeshBase[2];

    final float angle = (float)Math.PI/(2*IVY_N);

    final float CORR  = 1.0f - 2*IVY_D;

    float[] vertices = new float[4*IVY_N];

    for(int i=0; i<IVY_N; i++)

      {

      float sin = (float)Math.sin(i*angle);

      float cos = (float)Math.cos(i*angle);

      vertices[2*i          ] = CORR*(0.5f-cos);

      vertices[2*i+1        ] = CORR*(0.5f-sin);

      vertices[2*i  +2*IVY_N] = CORR*(cos-0.5f);

      vertices[2*i+1+2*IVY_N] = CORR*(sin-0.5f);

      }

    FactoryCubit factory = FactoryCubit.getInstance();

    float[] bands0 = factory.computeBands(+0.03f,35,0.5f,0.5f,5);

    float[] bands1 = factory.computeBands(-0.10f,45,0.5f,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);

    }

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

  private MeshBase createIvyFaceMesh()

    {

    MeshBase mesh = createFacesIvyFace();

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

    Static3D[] vertices = new Static3D[2];

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

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

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

    mesh.mergeEffComponents();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    return mesh;

    }

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

  private MeshBase createIvyCornerMesh()

    {

    MeshBase mesh = createFacesIvyCorner();

    VertexEffect[] effects = createVertexEffectsIvyCorner();

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

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

    Static3D[] vertices = new Static3D[4];

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

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

    vertices[2] = new Static3D(+0.0f,-1.0f,+0.0f);

    vertices[3] = new Static3D(+0.0f,+0.0f,-1.0f);

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

    mesh.mergeEffComponents();

    return mesh;

    }

      if( mCornerMesh==null ) mCornerMesh = createIvyCornerMesh();

      if( mFaceMesh==null ) mFaceMesh = createIvyFaceMesh();