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

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

public class FactoryBandagedOctahedron extends FactoryBandaged

  {

  private static FactoryBandagedOctahedron mThis;

  private float[][][] mVertices;

  private int[][][] mIndices;

  private int[] mTetraToFaceMap;

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

  private FactoryBandagedOctahedron()

    {

    }

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

  public static FactoryBandagedOctahedron getInstance()

    {

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

    return mThis;

    }

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

  static int getNumOctahedrons(int layers)

    {

    return layers==1 ? 1 : 4*(layers-1)*(layers-1) + 2;

    }

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

  static int getNumTetrahedrons(int layers)

    {

    return 4*layers*(layers-1);

    }

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

  private static int createOctaPositions(float[][] centers, int index, int layers, float height)

    {

    float x = (layers-1)*0.5f;

    float z = (layers+1)*0.5f;

    for(int i=0; i<layers; i++, index++)

      {

      z -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    for(int i=0; i<layers-1; i++, index++)

      {

      x -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    for(int i=0; i<layers-1; i++, index++)

      {

      z += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    for(int i=0; i<layers-2; i++, index++)

      {

      x += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    return index;

    }

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

  private static int createTetraPositions(float[][] centers, int index, int layers, float height)

    {

    float x = (layers-1)*0.5f;

    float z =  layers*0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      z -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    x += 0.5f;

    z -= 0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      x -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    x -= 0.5f;

    z -= 0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      z += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    x -= 0.5f;

    z += 0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      x += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    return index;

    }

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

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

    {

    int numO = getNumOctahedrons(size);

    int numT = getNumTetrahedrons(size);

    int index = 0;

    float height = 0.0f;

    float[][][] ret = new float[2][][];

    ret[0] = new float[numO][3];

    ret[1] = new float[numT][3];

    index = createOctaPositions(ret[0],index,size,height);

    for(int i=size-1; i>0; i--)

      {

      height += SQ2/2;

      index = createOctaPositions(ret[0],index,i,+height);

      index = createOctaPositions(ret[0],index,i,-height);

      }

    height = SQ2/4;

    index = 0;

    for(int i=size; i>1; i--)

      {

      index = createTetraPositions(ret[1],index,i,-height);

      index = createTetraPositions(ret[1],index,i,+height);

      height += SQ2/2;

      }

    return ret;

    }

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

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

      }

    }

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

// element is an octahedron iff its Y is an integer multiple of (SQ2/2).

  public static boolean isOctahedron(float y)

    {

    float H = SQ2/2;

    int num = (int)(2*(y+10*H)/H + 0.1f);

    return num%2 == 0;

    }

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

  public int getNumVariants(int[] numLayers)

    {

    return 2;

    }

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

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

    {

    return isOctahedron(y) ? 0 : 1;

    }

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

  private int retFaceTetraBelongsTo(int tetra, int numLayers)

    {

    if( mTetraToFaceMap==null ) mTetraToFaceMap = new int[] {5,6,7,4,1,2,3,0};

    for(int i=numLayers-1; i>0; i--)

      {

      if( tetra < 8*i ) return mTetraToFaceMap[tetra/i];

      tetra -= 8*i;

      }

    return -1;

    }

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

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

    {

    int numL = numLayers[0];

    int numO = getNumOctahedrons(numL);

    if( cubitIndex<numO ) return QUAT;

    switch( retFaceTetraBelongsTo(cubitIndex-numO, numL) )

      {

      case 0: return QUAT;

      case 1: return new Static4D(0,-SQ2/2,0,SQ2/2);

      case 2: return QUAT;

      case 3: return new Static4D(0, SQ2/2,0,SQ2/2);

      case 4: return new Static4D(0,     0,1,    0);

      case 5: return QUAT;

      case 6: return new Static4D(     1,0,0,    0);

      case 7: return QUAT;

      }

    return null;

    }

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

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

    {

    return createPositions(numLayers[0]);

    }

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

  public Static3D[] getNormals()

    {

    return TouchControlOctahedron.FACE_AXIS;

    }

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

// normalized 'edges' of the octahedron.

  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 = TouchControlOctahedron.DIST3D*numLayers[0];

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

    }

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

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

    {

    float height= iconMode ? 0.001f : 0.05f;

    int[] angle = {1,26,24,22,20,18,16,14,12,10,8};

    float R     = 0.3f;

    float S     = 0.5f;

    int extraI  = numLayers[0]>2 ? 0:1;

    int extraV  = numLayers[0]>2 ? 0:1;

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

    int numVertI= numLayers[0]>4 ? 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}

                          };

    }

  }