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.mesh.MeshBase;

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

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

public class FactoryBandagedCubit

  {

  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 final float[][] VECTOR =

      {

          {-1.0f,-1.0f,-1.0f},

          {-1.0f,-1.0f,+1.0f},

          {-1.0f,+1.0f,-1.0f},

          {-1.0f,+1.0f,+1.0f},

          {+1.0f,-1.0f,-1.0f},

          {+1.0f,-1.0f,+1.0f},

          {+1.0f,+1.0f,-1.0f},

          {+1.0f,+1.0f,+1.0f}

      };

  private static FactoryBandagedCubit mThis;

  private ArrayList<float[]> mVertexArray;

  private ArrayList<float[]> mTmpArray;

  private float[][][] mVertices;

  private int[][][] mIndices;

  private int[][] mBandIndices;

  private float[][] mMove;

  private int mX, mY, mZ, mMax;

  private float dX, dY, dZ;

  private int[][] mWall;

  private int[][] mPoints;

  private boolean[][][] mTmp;

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

  private FactoryBandagedCubit()

    {

    }

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

  private float[][] getVertices(ArrayList<float[]> list, float[] move, int variant)

    {

    int numMoves = move.length/3;

    mMove[variant][0]=0.0f;

    mMove[variant][1]=0.0f;

    mMove[variant][2]=0.0f;

    for(int m=0; m<numMoves; m++)

      {

      mMove[variant][0] += move[3*m  ];

      mMove[variant][1] += move[3*m+1];

      mMove[variant][2] += move[3*m+2];

      }

    mMove[variant][0]/=numMoves;

    mMove[variant][1]/=numMoves;

    mMove[variant][2]/=numMoves;

    int total  = 0;

    int length = list.size();

    float[][] vertices = new float[length][];

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

      {

      vertices[i] = list.get(i);

      total += vertices[i].length/3;

      }

    float[][] verts = new float[total][3];

    int pointer = 0;

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

      {

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

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

        {

        verts[pointer][0] = vertices[i][3*j  ] - mMove[variant][0];

        verts[pointer][1] = vertices[i][3*j+1] - mMove[variant][1];

        verts[pointer][2] = vertices[i][3*j+2] - mMove[variant][2];

        pointer++;

        }

      }

    return verts;

    }

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

  private int[][] getIndices(ArrayList<float[]> list)

    {

    int indicesSoFar=0;

    int length = list.size();

    int[][] indices = new int[length][];

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

      {

      float[] f = list.get(i);

      int len = f.length/3;

      int[] ind = new int[len];

      for(int j=0; j<len; j++) ind[j] = (indicesSoFar++);

      indices[i] = ind;

      }

    return indices;

    }

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

  private void markAllVertices(float[] vertex, float[][] vertices, int[][] indices, int pointer, int variant)

    {

    int lenI = indices.length;

    for(int index=0; index<lenI; index++)

      {

      int len = indices[index].length;

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

        {

        if( mIndices[variant][index][i] == -1 )

          {

          int ind = indices[index][i];

          float[] ver = vertices[ind];

          if( vertex[0]==ver[0] && vertex[1]==ver[1] && vertex[2]==ver[2] )

            {

            mIndices[variant][index][i] = pointer;

            }

          }

        }

      }

    }

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

// So far the 'vertices/indices' are stored inefficiently, with each vertex stored three times

// (each one normally is a corner of three faces) or even six times. Compress!

// Example of six times: the central vertex here:

//

// { 1.0f,  0.0f, -1.0f,

//   1.0f, -1.0f, -1.0f,

//   1.0f, -1.0f, +0.0f,

//   0.0f, -1.0f, -1.0f },

  private void compressVerticesAndIndices(int variant, float[][] vertices, int[][] indices)

    {

    if( mTmpArray==null ) mTmpArray = new ArrayList<>();

    int lenI = indices.length;

    int pointer=0;

    mIndices[variant] = new int[lenI][];

    for(int index=0; index<lenI; index++)

      {

      int len = indices[index].length;

      mIndices[variant][index] = new int[len];

      for(int i=0; i<len; i++) mIndices[variant][index][i] = -1;

      }

    for(int index=0; index<lenI; index++)

      {

      int len = indices[index].length;

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

        {

        if( mIndices[variant][index][i] == -1 )

          {

          int ind = indices[index][i];

          float[] ver = vertices[ind];

          mTmpArray.add(ver);

          markAllVertices(ver,vertices,indices,pointer,variant);

          pointer++;

          }

        }

      }

    int len = mTmpArray.size();

    mVertices[variant] = new float[len][];

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

      {

      mVertices[variant][i] = mTmpArray.remove(0);

      }

    }

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

  private boolean cubitExists(float[] pos, float x, float y, float z)

    {

    int len = pos.length/3;

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

      if( pos[3*i]==x && pos[3*i+1]==y && pos[3*i+2]==z ) return true;

    return false;

    }

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

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

    {

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

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

        {

        boolean b = (y<mY && z<mZ) && ( mTmp[x][mY-1-y][mZ-1-z] && (x+1>=mX || !mTmp[x+1][mY-1-y][mZ-1-z]) );

        mWall[z][y] = b ? WALL_MARKED : WALL_EMPTY;

        }

    createVertices(list,mWall,AXIS_XP,x);

    }

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

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

    {

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

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

        {

        boolean b = (y<mY && z<mZ) && ( mTmp[x][mY-1-y][z] && (x<1 || !mTmp[x-1][mY-1-y][z]) );

        mWall[z][y] = b ? WALL_MARKED : WALL_EMPTY;

        }

    createVertices(list,mWall,AXIS_XM,x);

    }

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

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

    {

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

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

        {

        boolean b = (x<mX && z<mZ) && ( mTmp[x][y][z] && (y+1>=mY || !mTmp[x][y+1][z]) );

        mWall[x][z] = b ? WALL_MARKED : WALL_EMPTY;

        }

    createVertices(list,mWall,AXIS_YP,y);

    }

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

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

    {

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

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

        {

        boolean b = (x<mX && z<mZ) && ( mTmp[x][y][mZ-1-z] && (y<1 || !mTmp[x][y-1][mZ-1-z]) );

        mWall[x][z] = b ? WALL_MARKED : WALL_EMPTY;

        }

    createVertices(list,mWall,AXIS_YM,y);

    }

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

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

    {

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

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

        {

        boolean b = (x<mX && y<mY) && ( mTmp[x][mY-1-y][z] && (z+1>=mZ || !mTmp[x][mY-1-y][z+1]) );

        mWall[x][y] = b ? WALL_MARKED : WALL_EMPTY;

        }

    createVertices(list,mWall,AXIS_ZP,z);

    }

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

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

    {

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

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

        {

        boolean b = (x<mX && y<mY) && ( mTmp[mX-1-x][mY-1-y][z] && (z<1 || !mTmp[mX-1-x][mY-1-y][z-1]) );

        mWall[x][y] = b ? WALL_MARKED : WALL_EMPTY;

        }

    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;

    }

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

// return true iff exactly three or exactly one of the four values (x1,x2,x3,x4) are equal to 'value'.

  private boolean threeOrOne(int x1, int x2, int x3, int x4, int value)

    {

    if( x1==value ) return x2==value ? (x3==value)^(x4==value) : (x3==value)^(x4!=value);

    else            return x2==value ? (x3==value)^(x4!=value) : (x3==value)^(x4==value);

    }

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

  private boolean isOddVertical(int x, int y)

    {

    int number = 0;

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

      if( mPoints[x][i]==0 ) number++;

    return (number%2)==0;

    }

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

  private boolean isOddHorizontal(int x, int y)

    {

    int number = 0;

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

      if( mPoints[i][y]==0 ) number++;

    return (number%2)==0;

    }

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

  private int moveUp(int x, int y)

    {

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

      if( mPoints[x][i]==0 ) return i;

    android.util.Log.e("D", "moveUp error!");

    return 0;

    }

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

  private int moveDown(int x, int y)

    {

    for(int i=y+1; i<=mMax; i++)

      if( mPoints[x][i]==0 ) return i;

    android.util.Log.e("D", "moveDown error!");

    return 0;

    }

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

  private int moveLeft(int x, int y)

    {

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

      if( mPoints[i][y]==0 ) return i;

    android.util.Log.e("D", "moveLeft error!");

    return 0;

    }

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

  private int moveRight(int x, int y)

    {

    for(int i=x+1; i<=mMax; i++)

      if( mPoints[i][y]==0 ) return i;

    android.util.Log.e("D", "moveRight error!");

    return 0;

    }

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

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

    {

    int numPoints = buildPoints(wall,section);

    int numSections = numPoints/2;

    float[] vertices = new float[3*numPoints];

    int x=0,y=0,pointer=0;

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

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

        if( mPoints[i][j]==0 )

          {

          x = i;

          y = j;

          i = j = mMax+1;

          }

    for(int s=0; s<numSections; s++)

      {

      vertices[6*pointer  ] = x-dx;

      vertices[6*pointer+1] = dy-y;

      vertices[6*pointer+2] = 0.0f;

      y = isOddVertical(x,y) ? moveDown(x,y) : moveUp(x,y);

      vertices[6*pointer+3] = x-dx;

      vertices[6*pointer+4] = dy-y;

      vertices[6*pointer+5] = 0.0f;

      x = isOddHorizontal(x,y) ? moveRight(x,y) : moveLeft(x,y);

      pointer++;

      }

    return vertices;

    }

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

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

    {

    int numPoints=0;

    boolean thereIsCorner;

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

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

        {

        if( y==0 )

          {

               if( x==   0 ) thereIsCorner = (wall[     0][0]==section);

          else if( x==mMax ) thereIsCorner = (wall[mMax-1][0]==section);

          else               thereIsCorner = (wall[x-1][0]==section)^(wall[x][0]==section);

          }

        else if( y==mMax )

          {

               if( x==   0 ) thereIsCorner = (wall[     0][mMax-1]==section);

          else if( x==mMax ) thereIsCorner = (wall[mMax-1][mMax-1]==section);

          else               thereIsCorner = (wall[x-1][mMax-1]==section)^(wall[x][mMax-1]==section);

          }

        else if( x==0 )

          {

          thereIsCorner = (wall[0][y-1]==section)^(wall[0][y]==section);

          }

        else if( x==mMax )

          {

          thereIsCorner = (wall[mMax-1][y-1]==section)^(wall[mMax-1][y]==section);

          }

        else

          {

          thereIsCorner = threeOrOne(wall[x-1][y-1],wall[x-1][y],wall[x][y-1],wall[x][y],section);

          }

        if( thereIsCorner )

          {

          mPoints[x][y] = 0;

          numPoints++;

          }

        else

          {

          mPoints[x][y] =-1;

          }

        }

    return numPoints;

    }

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

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

    {

    int i,len = vertices.length/3;

    switch(axis)

      {

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

                      {

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

                      vertices[3*i  ] = layer-(dX-1.0f);

                      }

                    break;

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

                      {

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

                      vertices[3*i  ] = layer-dX;

                      }

                    break;

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

                      {

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

                      vertices[3*i+1] = layer-(dY-1.0f);

                      }

                    break;

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

                      {

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

                      vertices[3*i+1] = layer-dY;

                      }

                    break;

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

                      {

                      vertices[3*i+2] = layer-(dZ-1.0f);

                      }

                    break;

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

                      {

                      vertices[3*i+2] = layer-dZ;

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

                      }

                    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) ? dZ : dX;

    float dy = (axis==AXIS_YP || axis==AXIS_YM) ? dZ : dY;

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

      {

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

      rotateAndMoveVertices(vertices,axis,layer);

      list.add(vertices);

/*

      int len = vertices.length/3;

      String w="";

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

        {

        w += ( "["+vertices[3*j]+" "+vertices[3*j+1]+" "+vertices[3*j+2]+"] ");

        }

      android.util.Log.e("D", "1 section: "+i+" axis: "+axis+" layer: "+layer+" vertices after: "+w);

*/

      }

    }

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

  private static boolean vertInFace(float[] vertex, float[] move, Static3D faceAxis, float dist)

    {

    final float MAX_ERROR = 0.01f;

    float x= faceAxis.get0();

    float y= faceAxis.get1();

    float z= faceAxis.get2();

    float a = (vertex[0]+move[0])*x + (vertex[1]+move[1])*y + (vertex[2]+move[2])*z;

    float diff = a - dist;

    return diff>-MAX_ERROR && diff<MAX_ERROR;

    }

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

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

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

  private int 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 index : indices)

      {

      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;

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

    return (int)max;

    }

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

// return array of:

// 0 if this is an inner face, 1 if its diameter is 1, 2 if diameter is 2, 3 if 3, etc

// but only up to 5 (because the number of bands is 6 - see createIrregularFaceShape() )

  private int[] generateBandIndices(float[][] vertices, int[][] indices, float[] move)

    {

    int numCubitFaces = indices.length;

    int[] bandIndices = new int[numCubitFaces];

    for(int cubitFace=0; cubitFace<numCubitFaces; cubitFace++)

      {

      bandIndices[cubitFace] = 0xffffffff;

      int numVertices = indices[cubitFace].length;

      for(int vertex=0; vertex<numVertices; vertex++)

        {

        int vertBelongsBitmap = 0x00000000;

        float[] vert = vertices[ indices[cubitFace][vertex] ];

        if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[0], dX) ) vertBelongsBitmap |= (1   );

        if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[1], dX) ) vertBelongsBitmap |= (1<<1);

        if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[2], dY) ) vertBelongsBitmap |= (1<<2);

        if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[3], dY) ) vertBelongsBitmap |= (1<<3);

        if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[4], dZ) ) vertBelongsBitmap |= (1<<4);

        if( vertInFace(vert, move, TouchControlHexahedron.FACE_AXIS[5], dZ) ) vertBelongsBitmap |= (1<<5);

        bandIndices[cubitFace] &= vertBelongsBitmap;

        }

      if( bandIndices[cubitFace]!=0 ) // outer face

        {

        int diameter = faceDiameter(vertices, indices[cubitFace]);

        bandIndices[cubitFace] = (diameter>=6 ? 5:diameter);

        }

      //android.util.Log.e("D", "cubit face "+cubitFace+" : "+bandIndices[cubitFace]);

      }

    return bandIndices;

    }

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

  private int computeVectorFace(float[] prev, float[] curr, float[] next)

    {

    float ax = prev[0]-curr[0];

    float ay = prev[1]-curr[1];

    float az = prev[2]-curr[2];

    float bx = next[0]-curr[0];

    float by = next[1]-curr[1];

    float bz = next[2]-curr[2];

    float lena = (float)Math.sqrt(ax*ax + ay*ay + az*az);

    float lenb = (float)Math.sqrt(bx*bx + by*by + bz*bz);

    ax /= lena;

    ay /= lena;

    az /= lena;

    bx /= lenb;

    by /= lenb;

    bz /= lenb;

    float cx = ax + bx + ay*bz-az*by;

    float cy = ay + by + az*bx-ax*bz;

    float cz = az + bz + ax*by-ay*bx;

    return (cx<0 ? 0:4) + (cy<0 ? 0:2) + (cz<0 ? 0:1);

    }

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

  private float[] computeVector(int index, float[][] vertices, int[][] indices, int[] bandIndices)

    {

    int band=0;

    int len = indices.length;

    int vector=-1;

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

      {

      int len2 = indices[i].length;

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

        {

        if( indices[i][j]==index )

          {

          int prev = j>0 ? j-1 : len2-1;

          int next = j<len2-1 ? j+1 : 0;

          int prevIndex = indices[i][prev];

          int currIndex = indices[i][j];

          int nextIndex = indices[i][next];

          int newVector = computeVectorFace(vertices[prevIndex],vertices[currIndex],vertices[nextIndex]);

          if( vector!=-1 && vector!=newVector ) return null;

          vector = newVector;

          band |= bandIndices[i];

          }

        }

      }

    return band==0 ? null : VECTOR[vector];

    }

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

  private float[][] generateVectors(float[][] vertices, int[][] indices, int[] bandIndices)

    {

    int len = vertices.length;

    float[][] vectors = new float[len][];

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

      {

      vectors[i] = computeVector(i,vertices,indices,bandIndices);

      }

    return vectors;

    }

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

  private void debug(float[][] vert, int[][] ind)

    {

    String vv="VERTICES: ";

    for (float[] floats : vert)

      {

      vv += "\n";

      int lenV2 = floats.length / 3;

      for (int v2 = 0; v2 < lenV2; v2++)

        {

        vv += " {";

        vv += (floats[3 * v2] + " ");

        vv += (floats[3 * v2 + 1] + " ");

        vv += (floats[3 * v2 + 2] + " ");

        vv += "}";

        }

      }

    android.util.Log.e("D", vv);

    String ii="INDICES: ";

    for (int[] ints : ind)

      {

      ii += "\n";

      int lenI2 = ints.length;

      for (int i2 = 0; i2 < lenI2; i2++)

        {

        ii += (ints[i2] + " ");

        }

      }

    android.util.Log.e("D", ii);

    }

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

// PUBLIC API

  public static FactoryBandagedCubit getInstance()

    {

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

    return mThis;

    }

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

  public void prepare(int numVariants, int x, int y, int z)

    {

    if( mVertexArray==null ) mVertexArray = new ArrayList<>();

    mVertices= new float[numVariants][][];

    mIndices = new int[numVariants][][];

    mMove = new float[numVariants][3];

    mBandIndices = new int[numVariants][];

    mX = x;

    mY = y;

    mZ = z;

    dX = mX/2.0f;

    dY = mY/2.0f;

    dZ = mZ/2.0f;

    mMax = mX>mY ? Math.max(mX,mZ) : Math.max(mY,mZ);

    mWall   = new int[mMax][mMax];

    mPoints = new int[mMax+1][mMax+1];

    mTmp    = new boolean[mX][mY][mZ];

    }

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

  public ObjectShape createIrregularShape(int variant, float[] pos)

    {

    mVertexArray.clear();

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

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

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

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

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

        for(int z=0; z<mZ; z++) mTmp[x][y][z] = cubitExists(pos,begX+x,begY+y,begZ+z);

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

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

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

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

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

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

    float[][] verts = getVertices(mVertexArray,pos,variant);

    int[][] inds    = getIndices(mVertexArray);

    compressVerticesAndIndices(variant,verts,inds);

    mBandIndices[variant] = generateBandIndices(mVertices[variant], mIndices[variant], mMove[variant]);

    return new ObjectShape(mVertices[variant], mIndices[variant]);

    }

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

  public ObjectVertexEffects createVertexEffects(int variant, boolean roundCorners)

    {

    float[][] vertVec= generateVectors(mVertices[variant], mIndices[variant], mBandIndices[variant]);

    int numEffects   = mVertices[variant].length;

    float S          = 0.04f;

    float[] region   = {0,0,0,0.15f};

    String[] names   = new String[numEffects];

    float[][] regions= new float[numEffects][];

    boolean[] uses   = new boolean[numEffects];

    float[][] vars   = new float[numEffects][];

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

      {

      float[] v = vertVec[i];

      if( v!=null )

        {

        names[i]  = FactoryCubit.NAME;

        regions[i]= region;

        uses[i]   = roundCorners;

        vars[i]   = new float[] { 0, S*v[0], S*v[1], S*v[2], 1 };

        }

      }

    return new ObjectVertexEffects(names,vars,mVertices[variant],regions,uses);

    }

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

  public ObjectFaceShape createIrregularFaceShape(int variant, boolean iconMode)

    {

    float height= iconMode ? 0.001f : 0.048f;

    int angle   = 60;

    float R     = 0.2f;

    float S     = 0.5f;

    int numVerts= 5;

    int extraI  = 0;

    int extraV  = 0;

    float[][] bands  = { {  0.001f,angle,R,S,numVerts,extraV,extraI},

                         {height/1,angle,R,S,numVerts,extraV,extraI},

                         {height/2,angle,R,S,numVerts,extraV,extraI},

                         {height/3,angle,R,S,numVerts,extraV,extraI},

                         {height/4,angle,R,S,numVerts,extraV,extraI},

                         {height/5,angle,R,S,numVerts,extraV,extraI} };

    return new ObjectFaceShape(bands,mBandIndices[variant],null);

    }

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

  public MeshBase createMesh(float[] pos, int x, int y, int z, boolean iconMode, boolean roundCorners)

    {

    prepare(1,x,y,z);

    ObjectShape shape           = createIrregularShape(0,pos);

    ObjectFaceShape face        = createIrregularFaceShape(0,iconMode);

    ObjectVertexEffects effects = createVertexEffects(0,roundCorners);

    int[][] indices             = shape.getVertIndices();

    int numComponents           = indices.length;

    FactoryCubit factory = FactoryCubit.getInstance();

    factory.clear();

    factory.createNewFaceTransform(shape,null);

    return factory.createRoundedSolid(shape,face,effects,MESH_NICE,numComponents);

    }

  }