Magic Cube

import static org.distorted.objectlib.main.TwistyObject.SQ2;

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

  private boolean isFaceInverted(int face)

    {

    return face>1;

    }

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

  private void addTetrahedralLattice(int size, float[][] pos)

    {

    final float DX = 1.0f;

    final float DY = SQ2/2;

    final float DZ = 1.0f;

    float startX = 0.0f;

    float startY =-DY*(size-1)/2;

    float startZ = DZ*(size-1)/2;

    int index = 0;

    for(int layer=0; layer<size; layer++)

      {

      float currX = startX;

      float currY = startY;

      for(int x=0; x<layer+1; x++)

        {

        float currZ = startZ;

        for(int z=0; z<size-layer; z++)

          {

          pos[index] = new float[] {currX,currY,currZ};

          index++;

          currZ -= DZ;

          }

        currX += DX;

        }

      startX-=DX/2;

      startY+=DY;

      startZ-=DZ/2;

      }

    }

    return dx*dx + dy*dy + dz*dz < (SQ3/4)*1.01f;

  void getTouchedPosition(float[] output, int face, float pointX, float pointY)

  float[][][] getPositions()

    int num = mSize[0];

    int numO= (num-1)*num*(num+1)/6;

    int numT= (num+1)*num*(num+2)/6;

    float[][] retO = new float[numO][];

    float[][] retT = new float[numT][];

    addTetrahedralLattice(num-1,retO);

    addTetrahedralLattice(num  ,retT);

    return new float[][][] { retO,retT };

    float y = (isFaceInverted(face) ? p[1] : -p[1]);

    float x = p[0];

    return (y >= -mDist2D) && (y <= mDist2D*(2-6*x)) && (y <= mDist2D*(2+6*x));

  MeshBase createMesh(int variant, float[] pos, boolean round)

     return factory.createMesh(variant,pos,mSize[0],false,round);