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.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 CubitFactory mThis;

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

  private CubitFactory()

    {

    }

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

  public static CubitFactory getInstance()

    {

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

    return mThis;

    }

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

// CUBE

  MeshBase createCubeMesh(int index)

    {

    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;

      }

    return createCubeMesh(vertices,bands,extraI,extraV);

    }

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

  private MeshBase createCubeMesh(float[] vertices, float[] bands, int extraI, int extraV)

    {

    final int MESHES=6;

    int association = 1;

    MeshBase[] meshes = new MeshPolygon[MESHES];

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

    float d1 = 1.0f;

    float d2 =-0.05f;

    float d3 = 0.12f;

    Static3D dCen0 = new Static3D( d1*(+0.5f), d1*(+0.5f), d1*(+0.5f) );

    Static3D dCen1 = new Static3D( d1*(+0.5f), d1*(+0.5f), d1*(-0.5f) );

    Static3D dCen2 = new Static3D( d1*(+0.5f), d1*(-0.5f), d1*(+0.5f) );

    Static3D dCen3 = new Static3D( d1*(+0.5f), d1*(-0.5f), d1*(-0.5f) );

    Static3D dCen4 = new Static3D( d1*(-0.5f), d1*(+0.5f), d1*(+0.5f) );

    Static3D dCen5 = new Static3D( d1*(-0.5f), d1*(+0.5f), d1*(-0.5f) );

    Static3D dCen6 = new Static3D( d1*(-0.5f), d1*(-0.5f), d1*(+0.5f) );

    Static3D dCen7 = new Static3D( d1*(-0.5f), d1*(-0.5f), d1*(-0.5f) );

    Static3D dVec0 = new Static3D( d2*(+0.5f), d2*(+0.5f), d2*(+0.5f) );

    Static3D dVec1 = new Static3D( d2*(+0.5f), d2*(+0.5f), d2*(-0.5f) );

    Static3D dVec2 = new Static3D( d2*(+0.5f), d2*(-0.5f), d2*(+0.5f) );

    Static3D dVec3 = new Static3D( d2*(+0.5f), d2*(-0.5f), d2*(-0.5f) );

    Static3D dVec4 = new Static3D( d2*(-0.5f), d2*(+0.5f), d2*(+0.5f) );

    Static3D dVec5 = new Static3D( d2*(-0.5f), d2*(+0.5f), d2*(-0.5f) );

    Static3D dVec6 = new Static3D( d2*(-0.5f), d2*(-0.5f), d2*(+0.5f) );

    Static3D dVec7 = new Static3D( d2*(-0.5f), d2*(-0.5f), d2*(-0.5f) );

    Static4D dReg  = new Static4D(0,0,0,d3);

    Static1D dRad  = new Static1D(1);

    VertexEffectMove effect0 = new VertexEffectMove(new Static3D(0,0,+0.5f));

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

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

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

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

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

    VertexEffectDeform effect6 = new VertexEffectDeform(dVec0, dRad, dCen0, dReg);

    VertexEffectDeform effect7 = new VertexEffectDeform(dVec1, dRad, dCen1, dReg);

    VertexEffectDeform effect8 = new VertexEffectDeform(dVec2, dRad, dCen2, dReg);

    VertexEffectDeform effect9 = new VertexEffectDeform(dVec3, dRad, dCen3, dReg);

    VertexEffectDeform effect10= new VertexEffectDeform(dVec4, dRad, dCen4, dReg);

    VertexEffectDeform effect11= new VertexEffectDeform(dVec5, dRad, dCen5, dReg);

    VertexEffectDeform effect12= new VertexEffectDeform(dVec6, dRad, dCen6, dReg);

    VertexEffectDeform effect13= new VertexEffectDeform(dVec7, dRad, dCen7, dReg);

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

    mesh.apply(effect6);

    mesh.apply(effect7);

    mesh.apply(effect8);

    mesh.apply(effect9);

    mesh.apply(effect10);

    mesh.apply(effect11);

    mesh.apply(effect12);

    mesh.apply(effect13);

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

    float d0 =-0.04f;

    float d1 = 0.04f;

    float r0 = 0.15f;

    float r1 = 0.10f;

    Static3D vec0   = new Static3D(d0*(+SQ3/3),d0*(+SQ3/3),d0*(+SQ3/3));

    Static3D vec1   = new Static3D(d1*(+SQ3/3),d1*(-SQ3/3),d1*(-SQ3/3));

    Static3D vec2   = new Static3D(d1*(-SQ3/3),d1*(+SQ3/3),d1*(-SQ3/3));

    Static3D vec3   = new Static3D(d1*(-SQ3/3),d1*(-SQ3/3),d1*(+SQ3/3));

    Static1D radius = new Static1D(0.5f);

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

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

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

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

    Static4D reg0   = new Static4D(0,0,0,r0);

    Static4D reg1   = new Static4D(0,0,0,r1);

    VertexEffectMove   effect0 = new VertexEffectMove(move1);

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

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

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

    VertexEffectMove   effect4 = new VertexEffectMove(move2);

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

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

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

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

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

    VertexEffectDeform effect10= new VertexEffectDeform(vec0,radius,cent0,reg0);

    VertexEffectDeform effect11= new VertexEffectDeform(vec1,radius,cent1,reg1);

    VertexEffectDeform effect12= new VertexEffectDeform(vec2,radius,cent2,reg1);

    VertexEffectDeform effect13= new VertexEffectDeform(vec3,radius,cent3,reg1);

    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

    effect10.setMeshAssociation(63,-1); // all meshes

    effect11.setMeshAssociation(63,-1); // all meshes

    effect12.setMeshAssociation(63,-1); // all meshes

    effect13.setMeshAssociation(63,-1); // all meshes

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

    mesh.apply(effect10);

    mesh.apply(effect11);

    mesh.apply(effect12);

    mesh.apply(effect13);

    mesh.mergeEffComponents();

    return mesh;

    }

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

  MeshBase createSkewbFaceMesh()

    {

    int association = 1;

    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[6];

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

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

    association <<= 1;

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

    for(int i=2; i<5; i++)

      {

      association <<= 1;

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

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

      }

    association <<= 1;

    meshes[5] = new MeshTriangle(1);                  // empty triangle so that

    meshes[5].setEffectAssociation(0,association,0);  // all cubits have 6 faces

    MeshBase mesh = new MeshJoined(meshes);

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

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

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

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

    float f = 0.05f;

    float r = 0.10f;

    float d = 0.5f;

    float e = +D*0.6f;

    Static3D vector0 = new Static3D(-f, 0, 0);

    Static3D vector1 = new Static3D( 0,+f, 0);

    Static3D vector2 = new Static3D(+f, 0, 0);

    Static3D vector3 = new Static3D( 0,-f, 0);

    Static1D radius  = new Static1D(1.0f);

    Static4D region  = new Static4D(0,0,0,r);

    Static3D center0 = new Static3D(+d, 0, e);

    Static3D center1 = new Static3D( 0,-d, e);

    Static3D center2 = new Static3D(-d, 0, e);

    Static3D center3 = new Static3D( 0,+d, e);

    VertexEffectRotate effect0 = new VertexEffectRotate( new Static1D(angle), axis1, center);

    VertexEffectRotate effect1 = new VertexEffectRotate( new Static1D(  135), axis2, center);

    VertexEffectRotate effect2 = new VertexEffectRotate( new Static1D(   45), axis2, center);

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

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

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

    VertexEffectDeform effect6 = new VertexEffectDeform(vector0,radius,center0,region);

    VertexEffectDeform effect7 = new VertexEffectDeform(vector1,radius,center1,region);

    VertexEffectDeform effect8 = new VertexEffectDeform(vector2,radius,center2,region);

    VertexEffectDeform effect9 = new VertexEffectDeform(vector3,radius,center3,region);

    VertexEffectScale  effect10= new VertexEffectScale(0.01f);

    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

    effect6.setMeshAssociation(31,-1);  // meshes 0,1,2,3,4

    effect7.setMeshAssociation(31,-1);  // meshes 0,1,2,3,4

    effect8.setMeshAssociation(31,-1);  // meshes 0,1,2,3,4

    effect9.setMeshAssociation(31,-1);  // meshes 0,1,2,3,4

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

    mesh.apply(effect10);

    mesh.mergeEffComponents();

    return mesh;

    }

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

// SKEWB DIAMOND / PYRAMINX

  MeshBase createOctaMesh()

    {

    int association = 1;

    float C = 0.06f;

    float D = 0.02f;

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

    float d1 = SQ2/2;

    float d2 =-0.06f;

    float d3 = 0.20f;

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

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

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

    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 dCen0 = new Static3D( d1*a0.get0(), d1*a0.get1(), d1*a0.get2() );

    Static3D dCen1 = new Static3D( d1*a1.get0(), d1*a1.get1(), d1*a1.get2() );

    Static3D dCen2 = new Static3D( d1*a2.get0(), d1*a2.get1(), d1*a2.get2() );

    Static3D dCen3 = new Static3D(-d1*a0.get0(),-d1*a0.get1(),-d1*a0.get2() );

    Static3D dCen4 = new Static3D(-d1*a1.get0(),-d1*a2.get1(),-d1*a2.get2() );

    Static3D dCen5 = new Static3D(-d1*a2.get0(),-d1*a1.get1(),-d1*a1.get2() );

    Static3D dVec0 = new Static3D( d2*a0.get0(), d2*a0.get1(), d2*a0.get2() );

    Static3D dVec1 = new Static3D( d2*a1.get0(), d2*a1.get1(), d2*a1.get2() );

    Static3D dVec2 = new Static3D( d2*a2.get0(), d2*a2.get1(), d2*a2.get2() );

    Static3D dVec3 = new Static3D(-d2*a0.get0(),-d2*a0.get1(),-d2*a0.get2() );

    Static3D dVec4 = new Static3D(-d2*a1.get0(),-d2*a1.get1(),-d2*a1.get2() );

    Static3D dVec5 = new Static3D(-d2*a2.get0(),-d2*a2.get1(),-d2*a2.get2() );

    Static4D dReg  = new Static4D(0,0,0,d3);

    Static1D dRad  = new Static1D(1);

    VertexEffectMove   effect0 = new VertexEffectMove(move1);

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

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

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

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

    VertexEffectScale  effect5 = new VertexEffectScale(flipY);

    VertexEffectDeform  effect6 = new VertexEffectDeform(dVec0, dRad, dCen0, dReg);

    VertexEffectDeform  effect7 = new VertexEffectDeform(dVec1, dRad, dCen1, dReg);

    VertexEffectDeform  effect8 = new VertexEffectDeform(dVec2, dRad, dCen2, dReg);

    VertexEffectDeform  effect9 = new VertexEffectDeform(dVec3, dRad, dCen3, dReg);

    VertexEffectDeform  effect10= new VertexEffectDeform(dVec4, dRad, dCen4, dReg);

    VertexEffectDeform  effect11= new VertexEffectDeform(dVec5, dRad, dCen5, dReg);

    effect0.setMeshAssociation (255,-1); // apply to all meshes

    effect1.setMeshAssociation (255,-1); // apply to all meshes

    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

    effect6.setMeshAssociation (255,-1); // apply to all meshes

    effect7.setMeshAssociation (255,-1); // apply to all meshes

    effect8.setMeshAssociation (255,-1); // apply to all meshes

    effect9.setMeshAssociation (255,-1); // apply to all meshes

    effect10.setMeshAssociation(255,-1); // apply to all meshes

    effect11.setMeshAssociation(255,-1); // apply to all meshes

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

    mesh.apply(effect10);

    mesh.apply(effect11);

    mesh.mergeEffComponents();

    return mesh;

    }

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

  MeshBase createTetraMesh()

    {

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

    MeshBase[] meshes = new MeshBase[8];

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

      }

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

      {

      association <<= 1;

      meshes[i] = new MeshTriangle(1);

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

    float d1 =-1.00f;

    float d2 = 0.10f;

    float d3 = 0.15f;

    float vx = 0.5f   ;

    float vy = (SQ2/4);

    Static3D a0 = new Static3D(+vx,-vy, 0 );

    Static3D a1 = new Static3D(-vx,-vy, 0 );

    Static3D a2 = new Static3D(  0, vy,-vx);

    Static3D a3 = new Static3D(  0, vy,+vx);

    Static4D dReg  = new Static4D(0,0,0,d3);

    Static1D dRad  = new Static1D(1);

    Static3D dCen0 = new Static3D( d1*a0.get0(), d1*a0.get1(), d1*a0.get2() );

    Static3D dCen1 = new Static3D( d1*a1.get0(), d1*a1.get1(), d1*a1.get2() );

    Static3D dCen2 = new Static3D( d1*a2.get0(), d1*a2.get1(), d1*a2.get2() );

    Static3D dCen3 = new Static3D( d1*a3.get0(), d1*a3.get1(), d1*a3.get2() );