TwistyPuzzleLib

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

// Copyright 2020 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 org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

public class FactoryBandagedCuboid extends FactoryBandaged

  {

  private static FactoryBandagedCuboid mThis;

  private float[][] mVertices;

  private int[][] mIndices;

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

  private FactoryBandagedCuboid()

    {

    }

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

  public static FactoryBandagedCuboid getInstance()

     {

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

     return mThis;

     }

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

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

    {

    if( mVertices==null )

      mVertices = new float[][]

       {

        { 0.5f, 0.5f, 0.5f },

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

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

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

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

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

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

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

       };

    return mVertices;

    }

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

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

    {

    if( mIndices==null )

      mIndices = new int[][]

       {

        {2,3,1,0},

        {7,6,4,5},

        {4,0,1,5},

        {7,3,2,6},

        {6,2,0,4},

        {3,7,5,1}

       };

    return mIndices;

    }

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

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

    {

    int sx = numLayers[0];

    int sy = numLayers[1];

    int sz = numLayers[2];

    int numCubits = ( sx<=1 || sy<=1 || sz<=1 ) ? sx*sy*sz : sx*sy*sz-(sx-2)*(sy-2)*(sz-2);

    float[][][] pos = new float[1][numCubits][];

    int c=0;

    float begX = 0.5f*(1-sx);

    float begY = 0.5f*(1-sy);

    float begZ = 0.5f*(1-sz);

    for(int x=0; x<sx; x++)

      for(int y=0; y<sy; y++)

        for(int z=0; z<sz; z++)

          if( x==0 || x==sx-1 || y==0 || y==sy-1 || z==0 || z==sz-1 )

            {

            pos[0][c++] = new float[] { begX+x,begY+y,begZ+z };

            }

    return pos;

    }

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

  public int getNumVariants(int[] numLayers)

    {

    return 1;

    }

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

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

     {

     return 0;

     }

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

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

    {

    return QUAT;

    }

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

  public Static3D[] getNormals()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

  public float[][] getDiameterAxis()

     {

     return new float[][] { {1,0,0},{0,1,0},{0,0,1} };

     }

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

  public float sizeCorrection(int[] numLayers)

    {

    return 1.0f;

    }

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

  public int diameterMap(float diameter)

     {

     return diameter>7 ? 7 : (int)diameter;

     }

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

  public float[] getDist3D(int[] numLayers)

    {

    float dx = numLayers[0]/2.0f;

    float dy = numLayers[1]/2.0f;

    float dz = numLayers[2]/2.0f;

    return new float[] {dx,dx,dy,dy,dz,dz};

    }

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

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

    {

    int sum = numLayers[0]+numLayers[1]+numLayers[2];

    float height= iconMode ? 0.001f : 0.05f;

    int[] angle = {1,54,43,35,30,26,23,21};

    float R     = 0.3f;

    float S     = 0.5f;

    int extraI  = sum>6 ? 0 : 2;

    int extraV  = sum>6 ? 0 : 2;

    int numVertA= sum>=19 ? 3 : (sum>=16 ? 4:5);

    int numVertI= sum>=13 ? 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},

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

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

                         };

    }

  }