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.objects;

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.mesh.MeshTriangle;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

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

public class CubitFactory

  {

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

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

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

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

  private static CubitFactory mThis;

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

  private CubitFactory()

    {

    }

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

  public static CubitFactory getInstance()

    {

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

    return mThis;

    }

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

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

      }

    }

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

// CUBE

  MeshBase createCubeMesh(int index)

    {

    final int MESHES=6;

    MeshBase[] meshes = new MeshPolygon[MESHES];

    int association = 1;

    float[] bands;

    float D = 0.027f;

    float E = 0.5f-D;

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

    int extraI, extraV;

    switch(index)

      {

      case 0 : bands = new float[] { 1.0f    ,-D,

                                     1.0f-D/2,-D*0.55f,

                                     1.0f-D  ,-D*0.25f,

                                     1.0f-2*D, 0.0f,

                                     0.50f, 0.040f,

                                     0.0f, 0.048f };

               extraI = 2;

               extraV = 2;

               break;

      case 1 : bands = new float[] { 1.0f    ,-D,

                                     1.0f-D*1.2f,-D*0.55f,

                                     1.0f-2*D, 0.0f,

                                     0.50f, 0.040f,

                                     0.0f, 0.048f };

               extraI = 2;

               extraV = 2;

               break;

      case 2 : bands = new float[] { 1.0f    ,-D,

                                     1.0f-D*1.2f,-D*0.55f,

                                     1.0f-2*D, 0.0f,

                                     0.50f, 0.040f,

                                     0.0f, 0.048f };

               extraI = 1;

               extraV = 2;

               break;

      default: bands = new float[] { 1.0f    ,-D,

                                     1.0f-2*D, 0.0f,

                                     0.50f, 0.025f,

                                     0.0f, 0.030f };

               extraI = 1;

               extraV = 1;

               break;

      }

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

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

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

      {

      association <<=1;

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

      meshes[i].setEffectAssociation(0,association,0);

      }

    MeshBase mesh = new MeshJoined(meshes);

    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 effect0 = new VertexEffectMove(new Static3D(0,0,+0.5f));

    VertexEffect effect1 = new VertexEffectRotate( angle180, axisX, center );

    VertexEffect effect2 = new VertexEffectRotate( angle90 , axisX, center );

    VertexEffect effect3 = new VertexEffectRotate( angle270, axisX, center );

    VertexEffect effect4 = new VertexEffectRotate( angle270, axisY, center );

    VertexEffect effect5 = new VertexEffectRotate( angle90 , axisY, center );

    effect0.setMeshAssociation(63,-1);  // all 6 sides

    effect1.setMeshAssociation(32,-1);  // back

    effect2.setMeshAssociation( 8,-1);  // bottom

    effect3.setMeshAssociation( 4,-1);  // top

    effect4.setMeshAssociation( 2,-1);  // left

    effect5.setMeshAssociation( 1,-1);  // right

    mesh.apply(effect0);

    mesh.apply(effect1);

    mesh.apply(effect2);

    mesh.apply(effect3);

    mesh.apply(effect4);

    mesh.apply(effect5);

    Static3D[] verticesCubit = new Static3D[8];

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

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

    verticesCubit[2] = new Static3D(+0.5f,-0.5f,+0.5f);

    verticesCubit[3] = new Static3D(+0.5f,-0.5f,-0.5f);

    verticesCubit[4] = new Static3D(-0.5f,+0.5f,+0.5f);

    verticesCubit[5] = new Static3D(-0.5f,+0.5f,-0.5f);

    verticesCubit[6] = new Static3D(-0.5f,-0.5f,+0.5f);

    verticesCubit[7] = new Static3D(-0.5f,-0.5f,-0.5f);

    roundCorners(mesh,center,verticesCubit,0.06f,0.12f);

    mesh.mergeEffComponents();

    return mesh;

    }

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

// SKEWB

  MeshBase createSkewbCornerMesh()

    {

    float D = 0.02f;

    float E = 0.5f;

    float F = SQ2/2;

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

    float[] bands0 = { 1.0f    , 0,

                       1.0f-2*D, D*0.25f,

                       1.0f-4*D, D*0.35f,

                       1.0f-8*D, D*0.6f,

                       0.60f   , D*1.0f,

                       0.30f   , D*1.375f,

                       0.0f    , D*1.4f };

    MeshBase[] meshes = new MeshBase[6];

    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 = { 0,0, F,0, F/2,(SQ3/2)*F };

    float[] bands1 = { 1.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f };

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

    MeshBase mesh = new MeshJoined(meshes);

    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,-0.5f,-0.5f);

    VertexEffect effect0 = new VertexEffectMove(move1);

    VertexEffect effect1 = new VertexEffectScale(new Static3D(1,1,-1));

    VertexEffect effect2 = new VertexEffectRotate(angle1,axisX,center1);

    VertexEffect effect3 = new VertexEffectRotate(angle2,axisY,center1);

    VertexEffect effect4 = new VertexEffectMove(move2);

    VertexEffect effect5 = new VertexEffectRotate(angle1,axisX,center2);

    VertexEffect effect6 = new VertexEffectRotate(angle3,axisY,center2);

    VertexEffect effect7 = new VertexEffectRotate(angle4,axis0,center2);

    VertexEffect effect8 = new VertexEffectRotate(angle5,axis1,center2);

    VertexEffect effect9 = new VertexEffectRotate(angle6,axis1,center2);

    effect0.setMeshAssociation( 7,-1);  // meshes 0,1,2

    effect1.setMeshAssociation( 6,-1);  // meshes 1,2

    effect2.setMeshAssociation( 2,-1);  // mesh 1

    effect3.setMeshAssociation( 4,-1);  // mesh 2

    effect4.setMeshAssociation(56,-1);  // meshes 3,4,5

    effect5.setMeshAssociation(56,-1);  // meshes 3,4,5

    effect6.setMeshAssociation(56,-1);  // meshes 3,4,5

    effect7.setMeshAssociation(56,-1);  // meshes 3,4,5

    effect8.setMeshAssociation(16,-1);  // mesh 4

    effect9.setMeshAssociation(32,-1);  // mesh 5

    mesh.apply(effect0);

    mesh.apply(effect1);

    mesh.apply(effect2);

    mesh.apply(effect3);

    mesh.apply(effect4);

    mesh.apply(effect5);

    mesh.apply(effect6);

    mesh.apply(effect7);

    mesh.apply(effect8);

    mesh.apply(effect9);

    Static3D roundingCenter = new Static3D(-E/2,-E/2,-E/2);

    Static3D[] verticesType1 = new Static3D[1];

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

    roundCorners(mesh,roundingCenter,verticesType1,0.08f,0.15f);

    Static3D[] verticesType2 = new Static3D[3];

    verticesType2[0] = new Static3D(-E, 0, 0);

    verticesType2[1] = new Static3D( 0,-E, 0);

    verticesType2[2] = new Static3D( 0, 0,-E);

    roundCorners(mesh,roundingCenter,verticesType2,0.08f,0.20f);

    mesh.mergeEffComponents();

    return mesh;

    }

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

  MeshBase createSkewbFaceMesh()

    {

    float D = 0.03f;

    float E = SQ2/4;

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

    float[] bands0 = { 1.0f    , 0,

                       1.0f-D/2, D*0.30f,

                       1.0f- D , D*0.50f,

                       1.0f-2*D, D*0.80f,

                       0.60f   , D*1.40f,

                       0.30f   , D*1.60f,

                       0.0f    , D*1.70f };

    MeshBase[] meshes = new MeshBase[5];

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

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

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

    float[] bands1 = { 1.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f };

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

    MeshBase mesh = new MeshJoined(meshes);

    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 effect0 = new VertexEffectRotate( new Static1D(angle), axisX, center);

    VertexEffect effect1 = new VertexEffectRotate( new Static1D(  135), axisZ, center);

    VertexEffect effect2 = new VertexEffectRotate( new Static1D(   45), axisZ, center);

    VertexEffect effect3 = new VertexEffectRotate( new Static1D(  -45), axisZ, center);

    VertexEffect effect4 = new VertexEffectRotate( new Static1D( -135), axisZ, center);

    VertexEffect effect5 = new VertexEffectMove( new Static3D(0,0,-0.5f) );

    effect0.setMeshAssociation(30,-1);  // meshes 1,2,3,4

    effect1.setMeshAssociation( 2,-1);  // mesh 1

    effect2.setMeshAssociation( 5,-1);  // meshes 0,2

    effect3.setMeshAssociation( 8,-1);  // mesh 3

    effect4.setMeshAssociation(16,-1);  // mesh 4

    effect5.setMeshAssociation(30,-1);  // meshes 1,2,3,4

    mesh.apply(effect0);

    mesh.apply(effect1);

    mesh.apply(effect2);

    mesh.apply(effect3);

    mesh.apply(effect4);

    mesh.apply(effect5);

    Static3D roundingCenter = new Static3D(0,0,-0.2f);

    Static3D[] vertices = new Static3D[4];

    vertices[0] = new Static3D(-E*SQ2,      0, 0);

    vertices[1] = new Static3D(+E*SQ2,      0, 0);

    vertices[2] = new Static3D(     0, -E*SQ2, 0);

    vertices[3] = new Static3D(     0, +E*SQ2, 0);

    roundCorners(mesh,roundingCenter,vertices,0.10f,0.10f);

    mesh.mergeEffComponents();

    mesh.addEmptyTexComponent();

    return mesh;

    }

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

// SKEWB DIAMOND / PYRAMINX

  MeshBase createOctaMesh()

    {

    int association = 1;

    float C = 0.06f;

    float D = 0.031f;

    float E = SQ3/2;

    float F = 0.5f;

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

    float[] bands = new float[] { 1.0f    , 0,

                                  1.0f  -C, D*0.55f,

                                  1.0f-2*C, D*0.85f,

                                  1.0f-4*C, D*1.20f,

                                  0.5f    , D*1.40f,

                                  0.0f    , D*1.50f };

    MeshBase[] meshes = new MeshPolygon[8];

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

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

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

      {

      association <<= 1;

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

      meshes[i].setEffectAssociation(0,association,0);

      }

    MeshBase mesh = new MeshJoined(meshes);

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

    VertexEffect effect0 = new VertexEffectMove(move1);

    VertexEffect effect1 = new VertexEffectRotate(alpha , axisX, cent1);

    VertexEffect effect2 = new VertexEffectRotate(angle1, axisY, cent0);

    VertexEffect effect3 = new VertexEffectRotate(angle2, axisY, cent0);

    VertexEffect effect4 = new VertexEffectRotate(angle3, axisY, cent0);

    VertexEffect effect5 = new VertexEffectScale(flipY);

    effect2.setMeshAssociation ( 34,-1); // apply to meshes 1 & 5

    effect3.setMeshAssociation ( 68,-1); // apply to meshes 2 & 6

    effect4.setMeshAssociation (136,-1); // apply to meshes 3 & 7

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

    mesh.apply(effect0);

    mesh.apply(effect1);

    mesh.apply(effect2);

    mesh.apply(effect3);

    mesh.apply(effect4);

    mesh.apply(effect5);

    Static3D[] verticesRound = new Static3D[6];

    verticesRound[0] = new Static3D(    0, SQ2/2,    0 );

    verticesRound[1] = new Static3D( 0.5f,     0, 0.5f );

    verticesRound[2] = new Static3D(-0.5f,     0, 0.5f );

    verticesRound[3] = new Static3D(    0,-SQ2/2,    0 );

    verticesRound[4] = new Static3D(-0.5f,     0,-0.5f );

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

    roundCorners(mesh,cent0,verticesRound,0.06f,0.20f);

    mesh.mergeEffComponents();

    return mesh;

    }

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

  MeshBase createTetraMesh()

    {

    MeshBase[] meshes = new MeshBase[4];

    int association = 1;

    float C = 0.06f;

    float D = 0.035f;

    float E = SQ3/2;

    float F = 0.5f;

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

    float[] bands = new float[] { 1.0f    , 0,

                                  1.0f  -C, D*0.50f,

                                  1.0f-2*C, D*0.80f,

                                  1.0f-4*C, D*1.10f,

                                  0.5f    , D*1.30f,

                                  0.0f    , D*1.35f };

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

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

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

      {

      association <<= 1;

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

      meshes[i].setEffectAssociation(0,association,0);

      }

    MeshBase mesh = new MeshJoined(meshes);

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

    VertexEffect effect0 = new VertexEffectRotate(angle2, axisZ, cent0);

    VertexEffect effect1 = new VertexEffectMove(move1);

    VertexEffect effect2 = new VertexEffectRotate(alpha , axisX, cent1);

    VertexEffect effect3 = new VertexEffectScale(flipZ);

    VertexEffect effect4 = new VertexEffectRotate(angle1, axisY, cent0);

    VertexEffect effect5 = new VertexEffectRotate(angle2, axisZ, cent0);

    effect0.setMeshAssociation(15,-1); // meshes 0,1,2,3

    effect1.setMeshAssociation(15,-1); // meshes 0,1,2,3

    effect2.setMeshAssociation(15,-1); // meshes 0,1,2,3

    effect3.setMeshAssociation(10,-1); // meshes 1 & 3

    effect4.setMeshAssociation(12,-1); // meshes 2 & 3

    effect5.setMeshAssociation(12,-1); // meshes 2 & 3

    mesh.apply(effect0);

    mesh.apply(effect1);

    mesh.apply(effect2);

    mesh.apply(effect3);

    mesh.apply(effect4);

    mesh.apply(effect5);

    Static3D[] verticesRound = new Static3D[4];

    verticesRound[0] = new Static3D(-0.5f,+SQ2/4,   0 );

    verticesRound[1] = new Static3D(+0.5f,+SQ2/4,   0 );

    verticesRound[2] = new Static3D(    0,-SQ2/4,+0.5f);

    verticesRound[3] = new Static3D(    0,-SQ2/4,-0.5f);

    roundCorners(mesh,cent0,verticesRound,0.08f,0.15f);

    mesh.mergeEffComponents();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    return mesh;

    }

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

// DINO

  MeshBase createDinoMesh()

    {

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

    final int MESHES=4;

    float D = 0.02f;

    float E = 0.5f*SQ2;

    float F = 0.5f;

    float[] bands0 = { 1.0f    , 0,

                       1.0f-2*D, D*0.25f,

                       1.0f-4*D, D*0.35f,

                       1.0f-8*D, D*0.6f,

                       0.60f   , D*1.0f,

                       0.30f   , D*1.375f,

                       0.0f    , D*1.4f };

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

    MeshBase[] meshes = new MeshPolygon[MESHES];

    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[] bands1 = { 1.0f    , 0,

                       0.50f   , 0.10f,

                       0.0f    , 0.20f };

    float[] vertices1 = { -E/2,-E*(SQ3/6), E/2,-E*(SQ3/6), 0,E*(SQ3/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);

    MeshBase mesh = new MeshJoined(meshes);

    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 effect0 = new VertexEffectScale ( new Static3D(3,3,3) );

    VertexEffect effect1 = new VertexEffectMove  ( new Static3D(0,-F,0) );

    VertexEffect effect2 = new VertexEffectRotate( new Static1D(90), axisX, center0 );

    VertexEffect effect3 = new VertexEffectScale ( new Static3D(1,-1,1) );

    VertexEffect effect4 = new VertexEffectMove  ( new Static3D(3*E/2,E*(SQ3/2)-3*F,0) );

    VertexEffect effect5 = new VertexEffectRotate( new Static1D(+90), axisY, center1 );

    VertexEffect effect6 = new VertexEffectScale ( new Static3D(-1,1,1) );

    VertexEffect effect7 = new VertexEffectRotate( new Static1D( 45), axisX, center1 );

    VertexEffect effect8 = new VertexEffectRotate( angle1           , axisZ, center1 );

    VertexEffect effect9 = new VertexEffectRotate( angle2           , axisZ, center1 );

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

    effect1.setMeshAssociation( 3,-1);  // apply to meshes 0,1

    effect2.setMeshAssociation( 2,-1);  // apply to mesh 1

    effect3.setMeshAssociation( 2,-1);  // apply to mesh 0

    effect4.setMeshAssociation(12,-1);  // apply to meshes 2,3

    effect5.setMeshAssociation(12,-1);  // apply to meshes 2,3

    effect6.setMeshAssociation( 8,-1);  // apply to mesh 3

    effect7.setMeshAssociation(12,-1);  // apply to meshes 2,3

    effect8.setMeshAssociation( 4,-1);  // apply to mesh 2

    effect9.setMeshAssociation( 8,-1);  // apply to mesh 3

    mesh.apply(effect0);

    mesh.apply(effect1);

    mesh.apply(effect2);

    mesh.apply(effect3);

    mesh.apply(effect4);

    mesh.apply(effect5);

    mesh.apply(effect6);

    mesh.apply(effect7);

    mesh.apply(effect8);

    mesh.apply(effect9);

    Static3D roundingCenter = new Static3D(0.0f, -1.5f*F, -1.5f*F);

    Static3D[] verticesRound = new Static3D[4];

    verticesRound[0] = new Static3D(     0,-3*F,    0 );

    verticesRound[1] = new Static3D(     0,   0, -3*F );

    verticesRound[2] = new Static3D(  -3*F,   0,    0 );

    verticesRound[3] = new Static3D(  +3*F,   0,    0 );

    roundCorners(mesh,roundingCenter,verticesRound,0.10f,0.40f);

    mesh.mergeEffComponents();

    return mesh;

    }

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

// Helicopter

  MeshBase createHelicopterCornerMesh()

    {

    float D = 0.02f;

    float E = 0.5f;

    float F = SQ2/4;

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

    float[] bands0 = { 1.0f    , 0,

                       1.0f-2*D, D*0.25f,

                       1.0f-4*D, D*0.35f,

                       1.0f-8*D, D*0.6f,

                       0.60f   , D*1.0f,

                       0.30f   , D*1.375f,

                       0.0f    , D*1.4f };