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

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

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

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;

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

public class FactoryBandagedPyraminx extends FactoryBandaged

  {

  private static FactoryBandagedPyraminx mThis;

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

  private FactoryBandagedPyraminx()

    {

    }

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

// TODO

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

    {

    return null;

    }

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

// (vertices,indices) define a cubit face. Return its 'diameter', i.e. max distance between vertices.

  float faceDiameter(float[][] vertices, int[][] indices)

    {

    /*

    float maxX = -dX;

    float minX =  dX;

    float maxY = -dY;

    float minY =  dY;

    float maxZ = -dZ;

    float minZ =  dZ;

    for (int[] ind : indices)

      for(int index : ind)

        {

        float[] v = vertices[index];

        if (v[0] > maxX) maxX = v[0];

        if (v[0] < minX) minX = v[0];

        if (v[1] > maxY) maxY = v[1];

        if (v[1] < minY) minY = v[1];

        if (v[2] > maxZ) maxZ = v[2];

        if (v[2] < minZ) minZ = v[2];

        }

    float diffX = maxX-minX;

    float diffY = maxY-minY;

    float diffZ = maxZ-minZ;

    return diffX>diffY ? Math.max(diffX,diffZ) : Math.max(diffY,diffZ);

     */

    return 0;

    }

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

// PUBLIC API

  public static FactoryBandagedPyraminx getInstance()

    {

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

    return mThis;

    }

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

  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 TouchControlTetrahedron.FACE_AXIS;

    }

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

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

            };

    }

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

  public float[] getDist3D()

    {

    return TouchControlTetrahedron.D3D;

    }

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

  public float[][] getBands(boolean iconMode)

    {

    float height= iconMode ? 0.001f : 0.048f;

    int[] angle = {60,50,40,32,28,23};

    float R     = 0.2f;

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

    }

  }