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

import java.util.ArrayList;

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

public class FactoryBandagedCuboid extends FactoryBandaged

  {

  private static final int WALL_MARKED=0;

  private static final int WALL_EMPTY =-1;

  private static final int AXIS_XP = 0;

  private static final int AXIS_XM = 1;

  private static final int AXIS_YP = 2;

  private static final int AXIS_YM = 3;

  private static final int AXIS_ZP = 4;

  private static final int AXIS_ZM = 5;

  private static FactoryBandagedCuboid mThis;

  private int mMax;

  private int[][] mWall;

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

  private FactoryBandagedCuboid()

    {

    }

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

  private void displayWall(String tmp)

    {

    StringBuilder sb = new StringBuilder();

    for(int i=0; i<mMax; i++)

      {

      for(int j=0; j<mMax; j++)

        {

        sb.append(mWall[i][j]);

        sb.append(' ');

        }

      sb.append("  -  ");

      }

    android.util.Log.e("D", tmp+" : "+sb);

    }

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

  private void createRight(int x, ArrayList<float[][]> list)

    {

    for(int i=0; i<mMax; i++)

      for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;

    for(int i=0; i<mNumElements; i++)

      {

      int[] row = mElements[i].getRotRow();

      if( row[0]==x )

        {

        int y = mNumLayers[1]-1-row[2];

        int z = mNumLayers[2]-1-row[4];

        mWall[z][y] = elementExists(x+1,row[2],row[4]) ? WALL_EMPTY : WALL_MARKED;

        }

      }

    createVertices(list,mWall,AXIS_XP,x);

    }

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

  private void createLeft(int x, ArrayList<float[][]> list)

    {

    for(int i=0; i<mMax; i++)

      for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;

    for(int i=0; i<mNumElements; i++)

      {

      int[] row = mElements[i].getRotRow();

      if( row[0]==x )

        {

        int y = mNumLayers[1]-1-row[2];

        int z = row[4];

        mWall[z][y] = elementExists(x-1,row[2],row[4]) ? WALL_EMPTY : WALL_MARKED;

        }

      }

    createVertices(list,mWall,AXIS_XM,x);

    }

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

  private void createTop(int y, ArrayList<float[][]> list)

    {

    for(int i=0; i<mMax; i++)

      for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;

    for(int i=0; i< mNumElements; i++)

      {

      int[] row = mElements[i].getRotRow();

      if( row[2]==y )

        {

        int x = row[0];

        int z = row[4];

        mWall[x][z] = elementExists(row[0],y+1,row[4]) ? WALL_EMPTY : WALL_MARKED;

        }

      }

    createVertices(list,mWall,AXIS_YP,y);

    }

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

  private void createBottom(int y, ArrayList<float[][]> list)

    {

    for(int i=0; i<mMax; i++)

      for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;

    for(int i=0; i<mNumElements; i++)

      {

      int[] row = mElements[i].getRotRow();

      if( row[2]==y )

        {

        int x = row[0];

        int z = mNumLayers[2]-1-row[4];

        mWall[x][z] = elementExists(row[0],y-1,row[4]) ? WALL_EMPTY : WALL_MARKED;

        }

      }

    createVertices(list,mWall,AXIS_YM,y);

    }

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

  private void createFront(int z, ArrayList<float[][]> list)

    {

    for(int i=0; i<mMax; i++)

      for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;

    for(int i=0; i<mNumElements; i++)

      {

      int[] row = mElements[i].getRotRow();

      if( row[4]==z )

        {

        int x = row[0];

        int y = mNumLayers[1]-1-row[2];

        mWall[x][y] = elementExists(row[0],row[2],z+1) ? WALL_EMPTY : WALL_MARKED;

        }

      }

    createVertices(list,mWall,AXIS_ZP,z);

    }

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

  private void createBack(int z, ArrayList<float[][]> list)

    {

    for(int i=0; i<mMax; i++)

      for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;

    for(int i=0; i<mNumElements; i++)

      {

      int[] row = mElements[i].getRotRow();

      if( row[4]==z )

        {

        int x = mNumLayers[0]-1-row[0];

        int y = mNumLayers[1]-1-row[2];

        mWall[x][y] = elementExists(row[0],row[2],z-1) ? WALL_EMPTY : WALL_MARKED;

        }

      }

    createVertices(list,mWall,AXIS_ZM,z);

    }

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

  private void markNeighbours(int[][] wall, int x, int y, int section)

    {

    wall[x][y] = section;

    if( x  >   0 && wall[x-1][y]==WALL_MARKED ) markNeighbours(wall,x-1,y,section);

    if( x+1<mMax && wall[x+1][y]==WALL_MARKED ) markNeighbours(wall,x+1,y,section);

    if( y  >   0 && wall[x][y-1]==WALL_MARKED ) markNeighbours(wall,x,y-1,section);

    if( y+1<mMax && wall[x][y+1]==WALL_MARKED ) markNeighbours(wall,x,y+1,section);

    }

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

  private int markSections(int[][] wall)

    {

    int sections = 0;

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

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

        if( wall[x][y]==WALL_MARKED )

          {

          sections++;

          markNeighbours(wall,x,y,sections);

          }

    return sections;

    }

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

  private float[][] buildVertices(int[][] wall, int section, float dx, float dy)

    {

    int numMarked = howManyMarked(wall,section);

    float[][] vertices = new float[numMarked][];

    int curr=0;

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

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

        if( wall[x][y]==section )

          {

          vertices[curr] = new float[12];

          vertices[curr][ 0] = x-dx;

          vertices[curr][ 1] = dy-y;

          vertices[curr][ 2] = 0.0f;

          vertices[curr][ 3] = x-dx;

          vertices[curr][ 4] = dy-y-1;

          vertices[curr][ 5] = 0.0f;

          vertices[curr][ 6] = x-dx+1;

          vertices[curr][ 7] = dy-y-1;

          vertices[curr][ 8] = 0.0f;

          vertices[curr][ 9] = x-dx+1;

          vertices[curr][10] = dy-y;

          vertices[curr][11] = 0.0f;

          curr++;

          }

    return vertices;

    }

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

  private int howManyMarked(int[][] wall, int section)

    {

    int numMarked=0;

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

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

        if( wall[x][y]==section ) numMarked++;

    return numMarked;

    }

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

  private void rotateAndMoveVertices(float[][] vertices, int axis, int layer)

    {

    int i,len = vertices.length;

    switch(axis)

      {

      case AXIS_XP: for(i=0; i<len; i++)

                      {

                      int l = vertices[i].length/3;

                      float x = layer - mNumLayers[0]/2.0f + 1.0f;

                      for(int j=0; j<l; j++)

                        {

                        vertices[i][3*j+2] = -vertices[i][3*j];

                        vertices[i][3*j]   = x;

                        }

                      }

                    break;

      case AXIS_XM: for(i=0; i<len; i++)

                      {

                      int l = vertices[i].length/3;

                      float x = layer - mNumLayers[0]/2.0f;

                      for(int j=0; j<l; j++)

                        {

                        vertices[i][3*j+2] = vertices[i][3*j];

                        vertices[i][3*j]   = x;

                        }

                      }

                    break;

      case AXIS_YP: for(i=0; i<len; i++)

                      {

                      int l = vertices[i].length/3;

                      float y = layer - mNumLayers[1]/2.0f + 1.0f;

                      for(int j=0; j<l; j++)

                        {

                        vertices[i][3*j+2] = -vertices[i][3*j+1];

                        vertices[i][3*j+1] = y;

                        }

                      }

                    break;

      case AXIS_YM: for(i=0; i<len; i++)

                      {

                      int l = vertices[i].length/3;

                      float y = layer - mNumLayers[1]/2.0f;

                      for(int j=0; j<l; j++)

                        {

                        vertices[i][3*j+2] = vertices[i][3*j+1];

                        vertices[i][3*j+1] = y;

                        }

                      }

                    break;

      case AXIS_ZP: for(i=0; i<len; i++)

                      {

                      int l = vertices[i].length/3;

                      float z = layer - mNumLayers[2]/2.0f + 1.0f;

                      for(int j=0; j<l; j++)

                        {

                        vertices[i][3*j+2] = z;

                        }

                      }

                    break;

      case AXIS_ZM: for(i=0; i<len; i++)

                      {

                      int l = vertices[i].length/3;

                      float z = layer - mNumLayers[2]/2.0f;

                      for(int j=0; j<l; j++)

                        {

                        vertices[i][3*j+2] = z;

                        vertices[i][3*j]   = -vertices[i][3*j];

                        }

                      }

                    break;

      }

    }

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

// 1. assume the 'wall' is in the XY plane

// 2. split the wall into individual connected regions and for each such region:

//   a. build the list of vertices (Z=0)

//   b. take the axis into consideration and rotate the vertices.

//   c. take layer into consideration and move the vertices.

//   d. add the resulting vertices to the list.

  private void createVertices(ArrayList<float[][]> list, int[][] wall, int axis, int layer)

    {

    int sections = markSections(wall);

    float dx = (axis==AXIS_XP || axis==AXIS_XM) ? mNumLayers[2]/2.0f : mNumLayers[0]/2.0f;

    float dy = (axis==AXIS_YP || axis==AXIS_YM) ? mNumLayers[2]/2.0f : mNumLayers[1]/2.0f;

    for(int i=0; i<sections; i++)

      {

      float[][] vertices = buildVertices(wall,i+1,dx,dy);

      rotateAndMoveVertices(vertices,axis,layer);

      list.add(vertices);

      }

    }

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

// (vertices,indices) define a cubit face, i.e. a connected subset of the NxN grid.

// Return its 'diameter', i.e. max(width,height)

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

    {

    float maxX = -Float.MAX_VALUE;

    float minX =  Float.MAX_VALUE;

    float maxY = -Float.MAX_VALUE;

    float minY =  Float.MAX_VALUE;

    float maxZ = -Float.MAX_VALUE;

    float minZ =  Float.MAX_VALUE;

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

    }

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

// PUBLIC API

  public static FactoryBandagedCuboid getInstance()

    {

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

    return mThis;

    }

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

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

    {

    int numFaces = 6;

    float[][] cuts = new float[numFaces][];

    for(int axis=0; axis<numFaces; axis++)

      {

      int len = numLayers[axis/2];

      float start = 1-len*0.5f;

      if( len>=2 )

        {

        cuts[axis] = new float[len-1];

        for(int i=0; i<len-1; i++) cuts[axis][i] = start+i;

        }

      }

    return cuts;

    }

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

  public Static3D[] getNormals()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

  public float[] getDist3D()

    {

    float dx = mNumLayers[0]/2.0f;

    float dy = mNumLayers[1]/2.0f;

    float dz = mNumLayers[2]/2.0f;

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

    }

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

  public void prepareSubclass(int numVariants, int[] numLayers)

    {

    int x = numLayers[0];

    int y = numLayers[1];

    int z = numLayers[2];

    mMax = x>y ? Math.max(x,z) : Math.max(y,z);

    mWall = new int[mMax][mMax];

    }

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

  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 sum = mNumLayers[0]+mNumLayers[1]+mNumLayers[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} };

    }

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

  public void fillUpVertexArray()

    {

    int numX = mNumLayers[0];

    int numY = mNumLayers[1];

    int numZ = mNumLayers[2];

    for(int x=0; x<numX; x++) createRight (x,mVertexArray);

    for(int x=0; x<numX; x++) createLeft  (x,mVertexArray);

    for(int y=0; y<numY; y++) createTop   (y,mVertexArray);

    for(int y=0; y<numY; y++) createBottom(y,mVertexArray);

    for(int z=0; z<numZ; z++) createFront (z,mVertexArray);

    for(int z=0; z<numZ; z++) createBack  (z,mVertexArray);

    }

  }