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 static org.distorted.objectlib.main.TwistyObject.SQ3;

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

import org.distorted.library.type.Static3D;

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

public class FactoryBandagedPyraminx extends FactoryBandaged

  {

  private static final float[][] TET_VER =

          {

                  {    0,-SQ2/4,-0.5f },

                  {    0,-SQ2/4, 0.5f },

                  { 0.5f, SQ2/4,    0 },

                  {-0.5f, SQ2/4,    0 }

          };

  private static final float[][] OCT_VER =

          {

                  {    0, SQ2/2,    0 },

                  {    0,-SQ2/2,    0 },

                  { 0.5f,     0, 0.5f },

                  { 0.5f,     0,-0.5f },

                  {-0.5f,     0,-0.5f },

                  {-0.5f,     0, 0.5f },

          };

  private static FactoryBandagedPyraminx mThis;

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

  private FactoryBandagedPyraminx()

    {

    }

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

  public static FactoryBandagedPyraminx getInstance()

    {

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

    return mThis;

    }

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

  private float[] tetVertices(int ax, boolean left, float[] pos)

    {

    if( !left )

      {

      int i1=-1,i2=-1,i3=-1;

      switch(ax)

        {

        case 0: i1=1; i2=2; i3=3; break;

        case 1: i1=0; i2=3; i3=2; break;

        case 2: i1=0; i2=1; i3=3; break;

        case 3: i1=0; i2=2; i3=1; break;

        }

      float[] T1 = TET_VER[i1];

      float[] T2 = TET_VER[i2];

      float[] T3 = TET_VER[i3];

      return new float[] { pos[0]+T1[0], pos[1]+T1[1], pos[2]+T1[2],

                           pos[0]+T2[0], pos[1]+T2[1], pos[2]+T2[2],

                           pos[0]+T3[0], pos[1]+T3[1], pos[2]+T3[2] };

      }

    return null;

    }

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

  private float[] octVertices(int ax, boolean left, float[] pos)

    {

    int i1=-1,i2=-1,i3=-1;

    if( left )

      {

      switch(ax)

        {

        case 0: i1=1; i2=4; i3=3; break;

        case 1: i1=1; i2=2; i3=5; break;

        case 2: i1=0; i2=2; i3=3; break;

        case 3: i1=0; i2=4; i3=5; break;

        }

      }

    else

      {

      switch(ax)

        {

        case 0: i1=0; i2=5; i3=2; break;

        case 1: i1=0; i2=3; i3=4; break;

        case 2: i1=1; i2=5; i3=4; break;

        case 3: i1=1; i2=3; i3=2; break;

        }

      }

    float[] T1 = OCT_VER[i1];

    float[] T2 = OCT_VER[i2];

    float[] T3 = OCT_VER[i3];

    return new float[] { pos[0]+T1[0], pos[1]+T1[1], pos[2]+T1[2],

                         pos[0]+T2[0], pos[1]+T2[1], pos[2]+T2[2],

                         pos[0]+T3[0], pos[1]+T3[1], pos[2]+T3[2] };

    }

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

  public float[] elementVertices(int ax, boolean left, int element)

    {

    int variant = mElements[element].getVariant();

    float[] pos = mElements[element].getPos();

    if( variant==0 ) return octVertices(ax,left,pos);

    else             return tetVertices(ax,left,pos);

    }

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

  public boolean elementFaceNotNull(int ax, boolean left, int element)

    {

    int variant = mElements[element].getVariant();

    return ( variant==0 || !left );

    }

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

// 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*num1 to avoid negative values.

  public static int getElementVariant(int size, float y)

    {

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

    return (num-size)%2;

    }

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

  public int getElementVariant(float x, float y, float z)

    {

    return getElementVariant(mNumLayers[0],y);

    }

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

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

    {

    int numL = numLayers[0];

    float[][] ret = new float[4][numL-1];

    for(int i=0; i<numL-1; i++)

      {

      float cut = (1.0f+i-numL/4.0f)*(SQ6/3);

      ret[0][i] = cut;

      ret[1][i] = cut;

      ret[2][i] = cut;

      ret[3][i] = cut;

      }

    return ret;

    }

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

  public Static3D[] getNormals()

    {

    return new Static3D[]

            {

                    new Static3D(     0, SQ3/3, SQ6/3),

                    new Static3D(     0, SQ3/3,-SQ6/3),

                    new Static3D(-SQ6/3,-SQ3/3,     0),

                    new Static3D( SQ6/3,-SQ3/3,     0),

            };

    }

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

  public float[][] getRotAxis()

    {

    return new float[][]

            {

                    {     0,-SQ3/3,-SQ6/3 },

                    {     0,-SQ3/3, SQ6/3 },

                    { SQ6/3, SQ3/3,     0 },

                    {-SQ6/3, SQ3/3,     0 },

            };

    }

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

// 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[] getDist3D()

    {

    final float d = (SQ6/12)*mNumLayers[0];

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

    }

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

  public float[][] getBands(boolean iconMode)

    {

    float height= iconMode ? 0.001f : 0.055f;

    int[] angle = {68,54,43,35,30,26};

    float R     = 0.3f;

    float S     = 0.5f;

    int extraI  = 0;

    int extraV  = 0;

    int numVertA= mNumLayers[0]>=5 ? 3 : (mNumLayers[0]==4 ? 4:5);

    int numVertI= mNumLayers[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/2,angle[2],R,S,numVertA,extraV,extraI},

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

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

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

    }

  }