Magic Cube

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

// Copyright 2020 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.helpers;

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.effect.VertexEffectDeform;

import org.distorted.library.effect.VertexEffectMove;

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.effect.VertexEffectScale;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshJoined;

import org.distorted.library.mesh.MeshPolygon;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

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

public class FactoryCubit

  {

  private static final float SQ2 = (float)Math.sqrt(2);

  private static final float SQ3 = (float)Math.sqrt(3);

  private static final float SQ5 = (float)Math.sqrt(5);

  private static final float SQ6 = (float)Math.sqrt(6);

  private static final Static1D RADIUS = new Static1D(1);

  private static FactoryCubit mThis;

  // IVY

  static final float IVY_D = 0.003f;

  static final float IVY_C = 0.59f;

  static final float IVY_M = 0.35f;

  private static final int IVY_N = 8;

  // REX

  public static final float REX_D = 0.2f;

  // KILO / MEGAMINX

  public static final float SIN54    = (SQ5+1)/4;

  public static final float COS54    = (float)(Math.sqrt(10-2*SQ5)/4);

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

  public static final float COS18    = (float)(0.25f*Math.sqrt(10.0f+2.0f*SQ5));

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

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

  public static final float DIHEDRAL1= (float)(Math.acos(-SQ5/5)*180/Math.PI);

  public static final float DIHEDRAL2= (float)((180/Math.PI)*Math.asin((2*SIN54*SIN54-1)/COS54) - 90);

  public static final float MINX_SC  = 0.5f;

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

  private FactoryCubit()

    {

    }

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

  public static FactoryCubit getInstance()

    {

    if( mThis==null ) mThis = new FactoryCubit();

    return mThis;

    }

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

// H - height of the band in the middle

// alpha - angle of the edge  [0,90]

// dist - often in a polygon the distance from edge to center is not 1, but something else.

// This is the distance.

// K - where to begin the second, much more flat part of the band. [0,1]

// N - number of bands. N>=3

//

// theory: two distinct parts to the band:

// 1) (0,B) - steep

// 2) (B,1) - flat

//

// In first part, we have y = g(x) ; in second - y = g(f(x)) where

//

// g(x) = sqrt( R^2 - (x-D)^2 ) - R*cos(alpha)

// f(x) = ((D-B)/(1-B)*x + B*(1-D)/(1-B)

// h(x) = R*(sin(alpha) - sin(x))

// R = H/(1-cos(alpha))

// D = H*sin(alpha)

// B = h(K*alpha)

//

// The N points are taken at:

//

// 1) in the second part, there are K2 = (N-3)/3 such points

// 2) in the first - K1 = (N-3) - K2

// 3) also, the 3 points 0,B,1

//

// so we have the sequence A[i] of N points

//

// 0

// h((i+1)*(1-K)*alpha/(K1+1)) (i=0,1,...,K1-1)

// B

// (1-B)*(i+1)/(K2+1) + B   (i=0,i,...,K2-1)

// 1

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

  private float f(float D, float B, float x)

    {

    return ((D-B)*x + B*(1-D))/(1-B);

    }

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

  private float g(float R, float D, float x, float cosAlpha)

    {

    float d = x-D;

    return (float)(Math.sqrt(R*R-d*d)-R*cosAlpha);

    }

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

  private float h(float R, float sinAlpha, float x)

    {

    return R*(sinAlpha-(float)Math.sin(x));

    }

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

  private float[] computeBands(float H, int alpha, float dist, float K, int N)

    {

    float[] bands = new float[2*N];

    bands[0] = 1.0f;

    bands[1] = 0.0f;

    float beta = (float)Math.atan(dist*Math.tan(Math.PI*alpha/180));

    float sinBeta = (float)Math.sin(beta);

    float cosBeta = (float)Math.cos(beta);

    float R = cosBeta<1.0f ? H/(1.0f-cosBeta) : 0.0f;

    float D = R*sinBeta;

    float B = h(R,sinBeta,K*beta);

    if( D>1.0f )

      {

      for(int i=1; i<N; i++)

        {

        bands[2*i  ] = (float)(N-1-i)/(N-1);

        bands[2*i+1] = H*(1-bands[2*i]);

        }

      }

    else

      {

      int K2 = (int)((N-3)*K);

      int K1 = (N-3)-K2;

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

        {

        float angle = K*beta + (1-K)*beta*(K1-i)/(K1+1);

        float x = h(R,sinBeta,angle);

        bands[2*i+2] = 1.0f - x;

        bands[2*i+3] = g(R,D,x,cosBeta);

        }

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

        {

        float x = (1-B)*(i+1)/(K2+1) + B;

        bands[2*K1+2 + 2*i+2] = 1.0f - x;

        bands[2*K1+2 + 2*i+3] = g(R,D,f(D,B,x),cosBeta);

        }

      }

    bands[2*N-2] = 0.0f;

    bands[2*N-1] =    H;

    return bands;

    }

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

  private void roundCorners(MeshBase mesh, Static3D center, Static3D[] vertices, float strength, float regionRadius)

    {

    Static4D reg= new Static4D(0,0,0,regionRadius);

    float centX = center.get0();

    float centY = center.get1();

    float centZ = center.get2();

    for (Static3D vertex : vertices)

      {

      float x = strength*(centX - vertex.get0());

      float y = strength*(centY - vertex.get1());

      float z = strength*(centZ - vertex.get2());

      VertexEffect effect = new VertexEffectDeform(new Static3D(x,y,z), RADIUS, vertex, reg);

      mesh.apply(effect);

      }

    }

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

  MeshBase createFacesCube(int sizeIndex)

    {

    MeshBase[] meshes = new MeshPolygon[6];

    float E = 0.5f;

    int extraI, extraV, num;

    switch(sizeIndex)

      {

      case 0 : num = 6; extraI = 2; extraV = 2; break;

      case 1 : num = 5; extraI = 2; extraV = 2; break;

      case 2 : num = 5; extraI = 1; extraV = 2; break;

      default: num = 4; extraI = 1; extraV = 1; break;

      }

    float[] vertices = { -E,-E, +E,-E, +E,+E, -E,+E };

    float[] bands = computeBands(0.048f,35,E,0.7f,num);

    meshes[0] = new MeshPolygon(vertices,bands,extraI,extraV);

    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] = meshes[0].copy(true);

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

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

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

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

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

    return new MeshJoined(meshes);

    }

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

  MeshBase createFacesSkewbCorner()

    {

    MeshBase[] meshes = new MeshBase[6];

    float E = 0.5f;

    float F = SQ2/2;

    float G = SQ6/16;

    float[] vertices0 = { -E+E/4,E/4, E/4,-E+E/4, E/4,E/4};

    float[] bands0 = computeBands(0.028f,35,E/3,0.7f,7);

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

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

    float[] vertices1 = { -F/2,-2*G, F/2,-2*G, 3*F/8,-G, 1*F/8,G, 0,2*G };

    float[] bands1 = computeBands(0,0,1,0,3);

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

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

    }

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

  MeshBase createFacesSkewbFace()

    {

    MeshBase[] meshes = new MeshBase[5];

    float E = SQ2/4;

    float[] vertices0 = { -E,-E, +E,-E, +E,+E, -E,+E };

    float[] bands0 = computeBands(0.051f,35,E/2,0.9f,7);

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

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

    float[] vertices1 = { -E,-SQ3*E, -E*0.7f,-SQ3*E, +E*0.7f,-SQ3*E, +E,-SQ3*E, 0,0 };

    float[] bands1 = computeBands(0,0,1,0,3);

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

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

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

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

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

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

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

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

    return new MeshJoined(meshes);

    }

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

  MeshBase createFacesOcta()

    {

    MeshBase[] meshes = new MeshPolygon[8];

    float E = 0.75f;

    float F = 0.5f;

    float[] vertices = { -F,-E/3, +F,-E/3, 0.0f,2*E/3};

    float[] bands = computeBands(0.05f,35,F,0.8f,6);

    meshes[0] = new MeshPolygon(vertices, bands, 2,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] = meshes[0].copy(true);

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

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

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

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

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

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

    meshes[6].setEffectAssociation(0,64,0);

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

    meshes[7].setEffectAssociation(0,128,0);

    return new MeshJoined(meshes);

    }

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

  MeshBase createFacesTetra()

    {

    MeshBase[] meshes = new MeshBase[4];

    float E = 0.75f;

    float F = 0.5f;

    float[] vertices = { -F,-E/3, +F,-E/3, 0.0f,2*E/3};

    float[] bands = computeBands(0.05f,35,F,0.8f,6);

    meshes[0] = new MeshPolygon(vertices, bands, 2,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] = meshes[0].copy(true);

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

    return new MeshJoined(meshes);

    }

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

  MeshBase createFacesDino()

    {

    MeshBase[] meshes = new MeshPolygon[4];

    float E = 0.5f*SQ2;

    float F = 0.5f;

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

    float[] bands0 = computeBands(0.028f,30,F/3,0.8f,7);

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

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

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

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

    float[] vertices1 = { -E/2,-E*(SQ3/6), E/2,-E*(SQ3/6), 0,E*(SQ3/3) };

    float[] bands1 = computeBands(0.02f,45,F/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);

    return new MeshJoined(meshes);

    }

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

  MeshBase createFacesHelicopterCorner()

    {

    MeshBase[] meshes = new MeshBase[6];

    float E = 0.5f;

    float F = SQ2/4;

    float G = 1.0f/12;

    float[] vertices0 = { -E+E/4,E/4, E/4,-E+E/4, E/4,E/4};

    float[] bands0 = computeBands(0.028f,35,E/4,0.7f,7);

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

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

    float[] vertices1 = { -F,-G, 0,-G, +F,-G, 0,2*G };

    float[] bands1 = computeBands(0.00f,0,0,0.0f,3);

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

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

    }

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

  MeshBase createFacesHelicopterFace()

    {

    MeshBase[] meshes = new MeshBase[4];

    float E = 0.5f;

    float F = SQ2/4;

    float G = 1.0f/12;

    float[] vertices0 = { -E+E/4,E/4, E/4,-E+E/4, E/4,E/4};

    float[] bands0 = computeBands(0.028f,35,E/4,0.7f,7);

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

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

    float[] vertices1 = { -F,-G, +F,-G, 0,2*G};

    float[] bands1 = computeBands(0.01f,45,F,0.0f,3);

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

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

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

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

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

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

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

    return new MeshJoined(meshes);

    }

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

  MeshBase createFacesRediEdge()

    {

    MeshBase[] meshes = new MeshPolygon[6];

    float F = 0.25f;

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

    float[] bands0 = computeBands(0.038f,35,F,0.7f,7);

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

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

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

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

    float[] bands1 = computeBands(0.02f,35,F/2,0.2f,3);

    float[] vertices1 = { -F/2, +F/2, -F/2, -1.5f*F, 1.5f*F, +F/2 };

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

    float X = 0.25f*SQ2;

    float Y = SQ6/16;

    float[] vertices2 = { -X, Y, -1.5f*X, -Y, +1.5f*X, -Y, +X, Y };

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

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

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

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

    return new MeshJoined(meshes);

    }

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

  MeshBase createFacesRediCorner()

    {

    MeshBase[] meshes = new MeshBase[6];

    float E = 0.5f;

    float[] vertices0 = { -E,-E, +E,-E, +E,+E, -E,+E };

    float[] bands0 = computeBands(0.06f,35,E,0.7f,6);

    meshes[0] = new MeshPolygon(vertices0,bands0,2,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);

    float F = 0.5f;

    float X = 0.5f;

    float G = 0.72f;

    float[] vertices1 = { -E,+F, -E+X,0, -E,-F, -E*G,-F, +E*G,-F, +E,-F, +E-X,0, +E,+F, +E*G,+F, -E*G,+F };

    float[] bands1 = computeBands(0.0f,0,1.0f,0.0f,2);

    meshes[3] = new MeshPolygon(vertices1,bands1,0,0);

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

    }

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

  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;

      }

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

    float[] bands1 = 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);

    }

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

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

      }

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

    float[] bands1 = 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);

    }

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

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

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

    float[] bands1 = 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};

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

    float[] bands1 = 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];

    float E = 0.5f - REX_D;

    float F = 0.5f;

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

    float[] bands0 = 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 = 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);

    }

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

  MeshBase createFacesKilominxCenter()

    {

    MeshBase[] meshes = new MeshPolygon[6];

    float X1= 0.5f*SIN54;

    float Y1= 0.5f*SIN_HALFD;

    float Y2= Y1 - 0.5f*COS54;

    float H = 0.5f* SIN54 /COS54  ;

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

    float[] vertices0 = { -X1, Y2, 0, -Y1, X1, Y2, 0, Y1 };

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

    float[] vertices1 = { -X2, Y4, 0, -Y3, X2, Y4, 0, Y3 };

    float[] bands1 = computeBands(0.00f, 0,0.25f,0.5f,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(vertices1, bands1, 0, 0);

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

    }

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

  MeshBase createFacesMinxCorner(int numLayers)

    {

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

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

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

    float h       = numLayers==3 ? 0.04f : 0.03f;

    int   e       = numLayers==3 ? 4 : 1;

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

    float[] bands1 = computeBands(0.00f,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] = meshes[0].copy(true);

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

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

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

    }

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

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

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

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

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

    return new MeshJoined(meshes);

    }

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

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

    {

    MeshBase[] meshes = new MeshPolygon[6];

    float D = height/COS18;

    float W = D*SIN18;

    float Y1 = 0.5f*width;

    float Y2 = 0.5f*width + W;

    float Y3 = 0.5f*width + 2*W;

    float X2 = D*SIN54;

    float X1 = 0.5f*height;

    float Y4 = D*COS54;

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

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

    float[] vertices2 = { -X2, 0.0f, 0.0f, -Y4, X2, 0.0f, 0.0f, Y4 };

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

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

    float h       = numLayers==3 ? 0.03f : 0.03f;

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

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

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

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

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

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

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

    return new MeshJoined(meshes);

    }

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

  MeshBase createFacesMegaminxCenter(int numLayers)

    {

    MeshBase[] meshes = new MeshPolygon[2];

    float R  = 0.5f;

    float X1 = R*COS54;

    float Y1 = R*SIN54;

    float X2 = R*COS18;

    float Y2 = R*SIN18;

    float[] vertices0 = { -X1,+Y1, -X2,-Y2, 0.0f,-R, +X2,-Y2, +X1,+Y1 };

    int numBands0 = numLayers==3 ? 4 : 3;

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

    float h       = numLayers==3 ? 0.04f : 0.04f;

    float[] bands0 = computeBands( h    ,45, R/3,0.2f, numBands0);

    float[] bands1 = computeBands( 0.00f,34, R/3,0.2f, numBands1);

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

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

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

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

    return new MeshJoined(meshes);

    }

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

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

    }

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

  MeshBase createCuboid(int[] dimensions)

    {

    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 = computeBands( defHeight/X,65,0.25f,0.5f,5);

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

    float[] bandsZ = 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);

    }

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

// EFFECTS

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

  VertexEffect[] createVertexEffectsCube()

    {

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

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

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

    Static1D angle90 = new Static1D(90);

    Static1D angle180= new Static1D(180);

    Static1D angle270= new Static1D(270);

    VertexEffect[] effect = new VertexEffect[6];

    effect[0] = new VertexEffectMove(new Static3D(0,0,+0.5f));

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

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

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

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

    effect[5] = new VertexEffectRotate( angle90 , axisY, center );

    effect[0].setMeshAssociation(63,-1);  // all 6 sides

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

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

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

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

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

    return effect;

    }

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

  VertexEffect[] createVertexEffectsSkewbCorner()

    {

    float E = 0.5f;

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

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

    Static3D axis0  = new Static3D(-SQ2/2,0,SQ2/2);

    Static3D axis1  = new Static3D(+SQ3/3,+SQ3/3,+SQ3/3);

    Static1D angle1 = new Static1D(+90);

    Static1D angle2 = new Static1D(-90);

    Static1D angle3 = new Static1D(-15);

    Static1D angle4 = new Static1D((float)((180.0f/Math.PI)*Math.acos(SQ3/3)));

    Static1D angle5 = new Static1D(120);

    Static1D angle6 = new Static1D(240);

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

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

    Static3D move1  = new Static3D(-E/4,-E/4,0);

    Static3D move2  = new Static3D(-0.5f+SQ2/4,-0.5f+SQ6/8,-0.5f);

    VertexEffect[] effect = new VertexEffect[10];

    effect[0] = new VertexEffectMove(move1);

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

    effect[2] = new VertexEffectRotate(angle1,axisX,center1);

    effect[3] = new VertexEffectRotate(angle2,axisY,center1);

    effect[4] = new VertexEffectMove(move2);

    effect[5] = new VertexEffectRotate(angle1,axisX,center2);

    effect[6] = new VertexEffectRotate(angle3,axisY,center2);

    effect[7] = new VertexEffectRotate(angle4,axis0,center2);

    effect[8] = new VertexEffectRotate(angle5,axis1,center2);

    effect[9] = new VertexEffectRotate(angle6,axis1,center2);

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

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

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

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

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

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

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

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

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

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

    return effect;

    }

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

  VertexEffect[] createVertexEffectsSkewbFace()

    {

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

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

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

    float angle = -(float)((180.0f/Math.PI)*Math.acos(SQ3/3));

    VertexEffect[] effect = new VertexEffect[6];

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

    effect[1] = new VertexEffectRotate( new Static1D(  135), axisZ, center);

    effect[2] = new VertexEffectRotate( new Static1D(   45), axisZ, center);

    effect[3] = new VertexEffectRotate( new Static1D(  -45), axisZ, center);

    effect[4] = new VertexEffectRotate( new Static1D( -135), axisZ, center);

    effect[5] = new VertexEffectMove( new Static3D(0,0,-0.5f) );

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

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

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

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

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

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

    return effect;

    }

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

  VertexEffect[] createVertexEffectsOcta()

    {

    Static1D alpha = new Static1D((float)(-(180/Math.PI)*Math.asin(SQ3/3)));

    Static1D angle1= new Static1D( 90);

    Static1D angle2= new Static1D(180);

    Static1D angle3= new Static1D(270);

    Static3D move1 = new Static3D(0,SQ2/2-SQ3/3,0);

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

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

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

    Static3D cent1 = new Static3D(0,SQ2/2,0);

    Static3D flipY = new Static3D( 1,-1, 1);

    Static3D scale = new Static3D( 1, 2*SQ3/3, 1);

    VertexEffect[] effect = new VertexEffect[7];

    effect[0] = new VertexEffectScale(scale);

    effect[1] = new VertexEffectMove(move1);

    effect[2] = new VertexEffectRotate(alpha , axisX, cent1);

    effect[3] = new VertexEffectRotate(angle1, axisY, cent0);

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

    effect[5] = new VertexEffectRotate(angle3, axisY, cent0);

    effect[6] = new VertexEffectScale(flipY);

    effect[3].setMeshAssociation ( 34,-1); // apply to meshes 1 & 5

    effect[4].setMeshAssociation ( 68,-1); // apply to meshes 2 & 6

    effect[5].setMeshAssociation (136,-1); // apply to meshes 3 & 7

    effect[6].setMeshAssociation (240,-1); // apply to meshes 4,5,6,7

    return effect;

    }

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

  VertexEffect[] createVertexEffectsTetra()

    {

    Static3D flipZ = new Static3D( 1, 1,-1);

    Static1D alpha = new Static1D((float)(-(180/Math.PI)*Math.asin(SQ3/3)));

    Static1D angle1= new Static1D( 90);

    Static1D angle2= new Static1D(180);

    Static3D move1 = new Static3D(0,SQ2/4-SQ3/6,0);

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

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

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

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

    Static3D cent1 = new Static3D(0,SQ2/4,0);

    Static3D scale = new Static3D( 1, 2*SQ3/3, 1);

    VertexEffect[] effect = new VertexEffect[7];

    effect[0] = new VertexEffectScale(scale);

    effect[1] = new VertexEffectRotate(angle2, axisZ, cent0);

    effect[2] = new VertexEffectMove(move1);

    effect[3] = new VertexEffectRotate(alpha , axisX, cent1);

    effect[4] = new VertexEffectScale(flipZ);

    effect[5] = new VertexEffectRotate(angle1, axisY, cent0);

    effect[6] = new VertexEffectRotate(angle2, axisZ, cent0);

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

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

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

    return effect;

    }

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

  VertexEffect[] createVertexEffectsDino()

    {

    float E = 0.5f*SQ2;

    float F = 0.5f;

    final float ANGLE = (float)((180/Math.PI)*(Math.atan(SQ2)));

    Static1D angle1 = new Static1D(-ANGLE);

    Static1D angle2 = new Static1D(+ANGLE);

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

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

    Static3D axisZ  = new Static3D(0,-1,1);

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

    Static3D center1= new Static3D(0,-3*F,0);

    VertexEffect[] effect = new VertexEffect[10];

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

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

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

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

    effect[4] = new VertexEffectMove  ( new Static3D(3*E/2,E*(SQ3/2)-3*F,0) );

    effect[5] = new VertexEffectRotate( new Static1D(+90), axisY, center1 );

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

    effect[7] = new VertexEffectRotate( new Static1D( 45), axisX, center1 );

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

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

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

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

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

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

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

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

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

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

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

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

    return effect;

    }

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

  VertexEffect[] createVertexEffectsHelicopterCorner()

    {

    float E = 0.5f;

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

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

    Static3D axis0  = new Static3D(-SQ2/2,0,SQ2/2);

    Static3D axis1  = new Static3D(+SQ3/3,+SQ3/3,+SQ3/3);

    Static1D angle1 = new Static1D(+90);

    Static1D angle2 = new Static1D(-90);

    Static1D angle3 = new Static1D(-135);

    Static1D angle4 = new Static1D(90);

    Static1D angle5 = new Static1D(120);

    Static1D angle6 = new Static1D(240);

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

    Static3D center2= new Static3D(-0.25f,-0.25f,-0.25f);

    Static3D move1  = new Static3D(-E/4,-E/4,0);

    Static3D move2  = new Static3D(-0.25f,(-1.0f/6)-0.25f,-0.25f);

    VertexEffect[] effect = new VertexEffect[10];

    effect[0] = new VertexEffectMove(move1);

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

    effect[2] = new VertexEffectRotate(angle1,axisX,center1);

    effect[3] = new VertexEffectRotate(angle2,axisY,center1);

    effect[4] = new VertexEffectMove(move2);

    effect[5] = new VertexEffectRotate(angle1,axisX,center2);

    effect[6] = new VertexEffectRotate(angle3,axisY,center2);

    effect[7] = new VertexEffectRotate(angle4,axis0,center2);

    effect[8] = new VertexEffectRotate(angle5,axis1,center2);

    effect[9] = new VertexEffectRotate(angle6,axis1,center2);

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

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

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

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

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

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

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

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

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

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

    return effect;

    }

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

  VertexEffect[] createVertexEffectsHelicopterFace()

    {

    float E = 0.5f;

    float F = SQ2/4;

    Static3D move0  = new Static3D(-E/4, -E/4, 0);

    Static3D move1  = new Static3D(-(SQ2/24)-E/2, -(SQ2/24)-E/2, 0);

    Static3D move2  = new Static3D(-E/2, F/3, 0);

    Static3D move3  = new Static3D(+E/2, F/3, 0);

    Static3D move4  = new Static3D(+E/3,+E/3, 0);

    Static1D angle1 = new Static1D(135);

    Static1D angle2 = new Static1D(90);

    Static1D angle3 = new Static1D(-90);

    Static1D angle4 = new Static1D(-135);

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

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

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

    Static3D axis1  = new Static3D(1,-1,0);

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

    Static3D center1= new Static3D(-E/2,-E/2,0);

    VertexEffect[] effect = new VertexEffect[10];

    effect[0] = new VertexEffectMove(move0);

    effect[1] = new VertexEffectRotate(angle1, axisZ, center);

    effect[2] = new VertexEffectMove(move1);

    effect[3] = new VertexEffectRotate(angle2, axis1, center1);

    effect[4] = new VertexEffectMove(move2);

    effect[5] = new VertexEffectMove(move3);

    effect[6] = new VertexEffectRotate(angle3, axisZ, center);

    effect[7] = new VertexEffectRotate(angle4, axisX, center);

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

    effect[9] = new VertexEffectMove(move4);

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

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

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

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

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

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

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

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

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

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

    return effect;

    }

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

  VertexEffect[] createVertexEffectsRediEdge()

    {

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

    Static3D move1 = new Static3D(0.25f, -0.25f, 0.0f);

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

    Static3D move3 = new Static3D(0.0f, (SQ3-6)/8, (SQ3-6)/8);

    Static3D flipZ = new Static3D(1,1,-1);

    Static3D flipX = new Static3D(-1,1,1);

    Static3D scale = new Static3D(2,2,2);

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

    Static3D cent1 = new Static3D(0,0, -1.5f);

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

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

    Static3D axis  = new Static3D(0,SQ2/2,-SQ2/2);

    Static1D angle1= new Static1D(90);

    Static1D angle2= new Static1D(45);

    Static1D angle3= new Static1D( (float)(180/Math.PI*Math.acos(SQ3/3)) );

    VertexEffect[] effect = new VertexEffect[12];

    effect[0] = new VertexEffectScale(scale);

    effect[1] = new VertexEffectMove(move0);

    effect[2] = new VertexEffectScale(flipZ);

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

    effect[4] = new VertexEffectMove(move1);

    effect[5] = new VertexEffectRotate(angle1,axisY,cent0);

    effect[6] = new VertexEffectMove(move2);

    effect[7] = new VertexEffectScale(flipX);

    effect[8] = new VertexEffectRotate(angle2,axisX,cent0);

    effect[9] = new VertexEffectMove(move3);

    effect[10]= new VertexEffectRotate(angle3,axis ,cent1);

    effect[11]= new VertexEffectScale(flipX);

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

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

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

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

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

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

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

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

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

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

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

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

    return effect;

    }

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

  VertexEffect[] createVertexEffectsRediCorner()

    {

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

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

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

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

    Static1D angle90 = new Static1D(90);

    Static1D angle270= new Static1D(270);

    Static1D angle45 = new Static1D(-45);

    Static3D scale   = new Static3D(1.0f, SQ2, 1.0f);

    VertexEffect[] effect = new VertexEffect[7];

    effect[0] = new VertexEffectMove(new Static3D(0,0,+0.5f));

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

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

    effect[3] = new VertexEffectScale(scale);

    effect[4] = new VertexEffectRotate( angle45 , axisX, center );

    effect[5] = new VertexEffectRotate( angle90 , axisY, center );

    effect[6] = new VertexEffectRotate( angle270, axisZ, center );

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

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

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

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

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

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

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

    return effect;

    }

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

  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;

    }

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

  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;

    }

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

  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;

    }

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

  VertexEffect[] createVertexEffectsKilominxCenter(float width)

    {

    VertexEffect[] effect = new VertexEffect[11];

    float H = 0.5f*(SIN54/COS54);

    float Y1= 0.5f*SIN_HALFD;

    float Y2= H/(2*COS_HALFD);

    float cos18 = (float)(Math.sqrt(1- SIN18 * SIN18));

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

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

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

    Static3D axisA = new Static3D(-SIN18, cos18, 0.0f);

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

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

    Static3D move2 = new Static3D(0,-Y2,0);

    Static3D move3 = new Static3D(0.5f*cos18,0.5f*SIN18,0);

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

    Static1D angle1 = new Static1D(54);

    Static1D angle2 = new Static1D(DIHEDRAL1/2+18);

    Static1D angle3 = new Static1D(90);

    Static1D angle4 = new Static1D(120);

    Static1D angle5 = new Static1D(240);

    Static1D angle6 = new Static1D(90-DIHEDRAL1/2);

    effect[0] = new VertexEffectMove(move1);

    effect[1] = new VertexEffectScale(1/MINX_SC);

    effect[2] = new VertexEffectMove(move2);

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

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

    effect[5] = new VertexEffectRotate(angle3, axisA, center);

    effect[6] = new VertexEffectMove(move3);

    effect[7] = new VertexEffectRotate(angle4, axisC, center);

    effect[8] = new VertexEffectRotate(angle5, axisC, center);

    effect[9] = new VertexEffectRotate(angle6, axisY, center);

    effect[10]= new VertexEffectScale(width/0.5f);

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

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

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

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

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

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

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

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

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

    return effect;

    }

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

  VertexEffect[] createVertexEffectsMinxCorner(float width)

    {

    VertexEffect[] effect = new VertexEffect[9];

    float Y = COS54/(2*SIN54);

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

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

    float LEN  = 0.5f/SIN54;

    float scale= width/LEN;

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

    Static1D angleE = new Static1D(360-DIHEDRAL1);

    Static1D angleF = new Static1D(DIHEDRAL2);

    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