TwistyPuzzleLib

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

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.objectlib.bandaged;

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

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;

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

public class FactoryBandagedPyraminx extends FactoryBandaged

  {

  private static FactoryBandagedPyraminx mThis;

  private float[][][] mVertices;

  private int[][][] mIndices;

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

  private FactoryBandagedPyraminx()

    {

    }

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

  public static FactoryBandagedPyraminx getInstance()

    {

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

    return mThis;

    }

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

  private static 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++)

          {

          if( x==0 || x==layer || z==0 || z==size-layer-1 )

            {

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

            index++;

            }

          currZ -= DZ;

          }

        currX += DX;

        }

      startX -= DX/2;

      startY += DY;

      startZ -= DZ/2;

      }

    }

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

  public static int numEntriesInFullLattice(int size)

    {

    return size*(size+1)*(size+2)/6;

    }

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

  public static int numEntriesInEmptyLattice(int size)

    {

    int full = numEntriesInFullLattice(size);

    if( size>=5 ) full -= numEntriesInFullLattice(size-4);

    return full;

    }

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

  public static float[][][] createPositions(int size)

    {

    int numO= numEntriesInEmptyLattice(size-1);

    int numT= numEntriesInEmptyLattice(size);

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

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

    addTetrahedralLattice(size-1,retO);

    addTetrahedralLattice(size  ,retT);

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

    }

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

  public float[][] getVertices(int[] numLayers, int variant)

    {

    if( mVertices==null ) mVertices = new float[2][][];

    if( variant==0 )

      {

      if( mVertices[0]==null )

        mVertices[0] = new float[][] { { 0.5f,0.0f,0.5f},{ 0.5f,0.0f,-0.5f},{-0.5f,0.0f,-0.5f},{-0.5f,0.0f,0.5f},{ 0.0f,SQ2/2,0.0f},{ 0.0f,-SQ2/2,0.0f} };

      return mVertices[0];

      }

    else

      {

      if( mVertices[1]==null )

        mVertices[1] = new float[][] { {-0.5f, SQ2/4, 0.0f},{ 0.5f, SQ2/4, 0.0f},{ 0.0f,-SQ2/4, 0.5f},{ 0.0f,-SQ2/4,-0.5f} };

      return mVertices[1];

      }

    }

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

  public int[][] getIndices(int[] numLayers, int variant)

    {

    if( mIndices==null ) mIndices = new int[2][][];

    if( variant==0 )

      {

      if( mIndices[0]==null )

        mIndices[0] = new int[][] { {3,0,4},{0,1,4},{1,2,4},{2,3,4},{5,0,3},{5,1,0},{5,2,1},{5,3,2} };

      return mIndices[0];

      }

    else

      {

      if( mIndices[1]==null )

        mIndices[1] = new int[][] { {2,1,0},{3,0,1},{3,2,0},{2,3,1} };

      return mIndices[1];

      }

    }

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

// see BandagedObjectPyraminx.addTetrahedralLattice()

// from there, 'y' is always of the form -DY*(size-1)/2 + K*DY, where DY = SQ2/2, K integer

// and 'size' is mNumLayers[0]-1 in case of Octahedrons and mNumLayers[0] in case of Tetrahedrons.

// From the above, the below quickly follows. +20*size to avoid negative values.

  public static boolean isOctahedron(int size, float y)

    {

    int num = (int)(2*SQ2*y + 20*size + 0.1f);

    return (num-size)%2 == 0;

    }

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

  public int getNumVariants(int[] numLayers)

    {

    return 2;

    }

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

  public int getElementVariant(int[] numLayers, float x, float y, float z)

    {

    return isOctahedron(numLayers[0],y) ? 0 : 1;

    }

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

  public Static4D getElementQuat(int[] numLayers, int cubitIndex)

    {

    return QUAT;

    }

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

  public float[][][] getPositions(int[] numLayers)

    {

    return createPositions(numLayers[0]);

    }

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

  public Static3D[] getNormals()

    {

    return TouchControlTetrahedron.FACE_AXIS;

    }

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

// normalized 'edges' of the tetrahedron.

  public float[][] getDiameterAxis()

    {

    return new float[][]

            {

                    {    1,    0,    0},

                    {    0,    0,    1},

                    { 0.5f,SQ2/2, 0.5f},

                    { 0.5f,SQ2/2,-0.5f},

                    {-0.5f,SQ2/2, 0.5f},

                    {-0.5f,SQ2/2,-0.5f},

            };

    }

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

  public float sizeCorrection(int[] numLayers)

    {

    return 1.0f;

    }

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

  public int diameterMap(float diameter)

    {

    if( diameter>=5.49f ) return 11;

    if( diameter>1.1f && diameter<1.9f ) return 3;

    return (int)(2*diameter+0.01f);

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    final float d = TouchControlTetrahedron.DIST3D*numLayers[0];

    return new float[] {d,d,d,d};

    }

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

  public float[][] getBands(boolean iconMode, int[] numLayers)

    {

    float height= iconMode ? 0.001f : 0.055f;

    int[] angle = {1,56,50,43,39,35,32,30,28,26,25};

    float R     = 0.3f;

    float S     = 0.5f;

    int extraI  = 0;

    int extraV  = 0;

    int numVertA= numLayers[0]>=5 ? 4 : 5;

    int numVertI= numLayers[0]>=5 ? 2 : 3;

    return new float[][] { {  0.001f    ,angle[ 0],R,S,numVertI,extraV,extraI},

                           {height      ,angle[ 1],R,S,numVertA,extraV,extraI},

                           {height      ,angle[ 1],R,S,numVertA,extraV,extraI},

                           {height/ 1.5f,angle[ 2],R,S,numVertA,extraV,extraI},

                           {height/ 2.0f,angle[ 3],R,S,numVertA,extraV,extraI},

                           {height/ 2.5f,angle[ 4],R,S,numVertA,extraV,extraI},

                           {height/ 3.0f,angle[ 5],R,S,numVertA,extraV,extraI},

                           {height/ 3.5f,angle[ 6],R,S,numVertA,extraV,extraI},

                           {height/ 4.0f,angle[ 7],R,S,numVertA,extraV,extraI},

                           {height/ 4.5f,angle[ 8],R,S,numVertA,extraV,extraI},

                           {height/ 5.0f,angle[ 9],R,S,numVertA,extraV,extraI},

                           {height/ 5.5f,angle[10],R,S,numVertA,extraV,extraI}

                          };

    }

  }