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

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

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

import static org.distorted.objectlib.objects.TwistyBandagedCuboid.REGION_SIZE;

import static org.distorted.objectlib.objects.TwistyBandagedCuboid.STRENGTH;

import org.distorted.library.helpers.QuatHelper;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.FactoryCubit;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

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

abstract public class FactoryBandaged

  {

  private static class BandagedCubitFace

    {

    private static final float[] sortVect = new float[] { 1/(2*SQ2), SQ2/(2*SQ2), SQ5/(2*SQ2) };

    float[] vertices;

    float[] center;

    float[] normal;

    float centerCast;

    BandagedCubitFace(float[] verts)

      {

      vertices = verts;

      computeCenter();

      computeNormal();

      computeCenterCast();

      }

    private void computeCenter()

      {

      int num = vertices.length/3;

      center = new float[3];

      for(int v=0; v<num; v++)

        {

        center[0] += vertices[3*v  ];

        center[1] += vertices[3*v+1];

        center[2] += vertices[3*v+2];

        }

      center[0] /= num;

      center[1] /= num;

      center[2] /= num;

      }

    private void computeNormal()

      {

      normal = new float[3];

      float x1 = vertices[0];

      float y1 = vertices[1];

      float z1 = vertices[2];

      float x2 = vertices[3];

      float y2 = vertices[4];

      float z2 = vertices[5];

      float x3 = vertices[6];

      float y3 = vertices[7];

      float z3 = vertices[8];

      float v1x = x2-x1;

      float v1y = y2-y1;

      float v1z = z2-z1;

      float v2x = x3-x1;

      float v2y = y3-y1;

      float v2z = z3-z1;

      normal[0] = v1y*v2z - v2y*v1z;

      normal[1] = v1z*v2x - v2z*v1x;

      normal[2] = v1x*v2y - v2x*v1y;

      double len = normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2];

      len = Math.sqrt(len);

      normal[0] /= len;

      normal[1] /= len;

      normal[2] /= len;

      }

    private void computeCenterCast()

      {

      centerCast = center[0]*sortVect[0] + center[1]*sortVect[1] + center[2]*sortVect[2];

      }

    }

  static class SortByCenterCast implements Comparator<BandagedCubitFace>

    {

    public int compare(BandagedCubitFace a, BandagedCubitFace b)

      {

      float diff = a.centerCast - b.centerCast;

      return diff>0 ? 1: diff==0 ? 0: -1;

      }

    }

  public static Static4D QUAT = new Static4D(0,0,0,1);

  private ArrayList<float[]> mTmpArray;

  private ArrayList<float[][]> mVertexArray;

  private BandagedElement[] mElements;

  private Static3D[] mNormals;

  private float[] mDist3D;

  private int[][] mFaceBelongsBitmap;

  private float[][] mDiaAxis;

  private float[][] mMinMax;

  private int mNumFaces;

  private int mNumElements;

  private float[][] mMove;

  private int[][][][] mIndices;

  private float[][][] mVertices;

  private int[][] mBandIndices;

  private int[] mNumLayers;

  private float[] mTmp;

  private float[][][] mAllPositions;

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

  FactoryBandaged()

    {

    }

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

  abstract Static3D[] getNormals();

  abstract float[][][] getPositions(int[] numLayers);

  abstract Static4D getElementQuat(int[] numLayers, int cubitIndex);

  abstract float[][] getDiameterAxis();

  abstract float[] getDist3D(int[] numLayers);

  abstract float[][] getBands(boolean iconMode, int[] numLayers);

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

  abstract int diameterMap(float diameter);

  abstract float[][] getVertices(int[] numLayers, int variant);

  abstract int[][] getIndices(int[] numLayers, int variant);

  abstract int getNumVariants(int[] numLayers);

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

  private int[] computeFaceBelongsBitmap(float[][] vertices, float[] move)

    {

    int numVerts = vertices.length;

    int[] ret = new int[numVerts];

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

      {

      int vertBelongsBitmap=0x00000000;

      float[] vert=vertices[i];

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

        if( vertInFace(vert, move, mNormals[j], mDist3D[j]) ) vertBelongsBitmap |= (1<<j);

      ret[i]=vertBelongsBitmap;

      }

    return ret;

    }

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

  private int getCubitIndex(float[][][] allPositions, int variant, float x, float y, float z)

    {

    int total = 0;

    for(int v=0; v<variant; v++) total += allPositions[v].length;

    float[][] pos = allPositions[variant];

    float minerror = Float.MAX_VALUE;

    int addition = -1;

    int num = pos.length;

    for(int n=0; n<num; n++)

      {

      float[] point = pos[n];

      float dx = point[0]-x;

      float dy = point[1]-y;

      float dz = point[2]-z;

      float diff = dx*dx + dy*dy + dz*dz;

      if( diff<minerror )

        {

        addition = n;

        minerror = diff;

        }

      }

    return total + addition;

    }

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

// (vertices,indices) define a single face of a set of connected elements.

// Return its 'diameter', i.e. the max distance (along any of its 'diameterAxis') between any two

// vertices of the face.

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

    {

    int num = mDiaAxis.length;

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

      {

      mMinMax[i][0] = Float.MAX_VALUE;

      mMinMax[i][1] =-Float.MAX_VALUE;

      }

    for (int[] ind : indices)

      for(int index : ind)

        {

        float[] v = vertices[index];

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

          {

          float[] mm = mMinMax[i];

          float[] ax = mDiaAxis[i];

          float dist = v[0]*ax[0] + v[1]*ax[1] + v[2]*ax[2];

          if ( dist > mm[1] ) mm[1] = dist;

          if ( dist < mm[0] ) mm[0] = dist;

          }

        }

    float maxDiff = 0;

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

      {

      float[] mm = mMinMax[i];

      float diff = mm[1]-mm[0];

      if( diff>maxDiff ) maxDiff = diff;

      }

    return maxDiff+0.01f; // this will be rounded down to nearest int; we don't want 1.9999 here

    }

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

// 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, int[] belongs)

    {

    int numCubitFaces = indices.length;

    int[] bandIndices = new int[numCubitFaces];

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

      {

      bandIndices[f] = 0xffffffff;

      for( int index : indices[f][0] ) bandIndices[f] &= belongs[index];

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

        {

        float diameter = faceDiameter(vertices, indices[f]);

        bandIndices[f] = diameterMap(diameter);

        }

      }

    return bandIndices;

    }

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

  private void computeMove(float[] pos, int variant)

    {

    int numMoves = pos.length/3;

    float[] m = mMove[variant];

    m[0]=0.0f;

    m[1]=0.0f;

    m[2]=0.0f;

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

      {

      m[0] += pos[3*i  ];

      m[1] += pos[3*i+1];

      m[2] += pos[3*i+2];

      }

    m[0]/=numMoves;

    m[1]/=numMoves;

    m[2]/=numMoves;

    }

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

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

    {

    int total  = 0;

    int length = list.size();

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

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

      {

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

      int len = vertices[i].length;

      for(int j=0; j<len; j++) total += vertices[i][j].length/3;

      }

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

    int pointer = 0;

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

      {

      int len = vertices[i].length;

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

        {

        float[] v = vertices[i][j];

        int l = v.length/3;

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

          {

          verts[pointer][0] = v[3*k  ] - mMove[variant][0];

          verts[pointer][1] = v[3*k+1] - mMove[variant][1];

          verts[pointer][2] = v[3*k+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[][] face = list.get(i);

      int len = face.length;

      int[][] ind = new int[len][];

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

        {

        int l = face[j].length/3;

        ind[j] = new int[l];

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

        }

      indices[i] = ind;

      }

    return indices;

    }

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

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

    {

    int numFaces = indices.length;

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

      {

      int len = indices[face].length;

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

        {

        int l = indices[face][comp].length;

        int[] in = mIndices[variant][face][comp];

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

          if( in[v]==-1 )

            {

            int ind=indices[face][comp][v];

            float[] ver=vertices[ind];

            if(vertex[0]==ver[0] && vertex[1]==ver[1] && vertex[2]==ver[2]) in[v]=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 numFaces = indices.length;

    int pointer=0;

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

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

      {

      int len = indices[face].length;

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

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

        {

        int l = indices[face][comp].length;

        mIndices[variant][face][comp] = new int[l];

        for(int v=0; v<l; v++) mIndices[variant][face][comp][v] = -1;

        }

      }

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

      {

      int len = indices[face].length;

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

        {

        int l = indices[face][comp].length;

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

          {

          if( mIndices[variant][face][comp][v]==-1 )

            {

            int ind=indices[face][comp][v];

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

      }

    }

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

  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;

    }

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

  private void computeVectorFace(float[] prev, float[] curr, float[] next, float[] output)

    {

    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;

    output[0] = ay*bz - az*by;

    output[1] = az*bx - ax*bz;

    output[2] = ax*by - ay*bx;

    output[3] = ax;

    output[4] = ay;

    output[5] = az;

    output[6] = bx;

    output[7] = by;

    output[8] = bz;

    }

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

// 'concave' vertices do not get pushed!

  private boolean vertexIsConcave(float[][] vecs, int numVecs)

    {

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

      {

      float[] v1 = vecs[i];

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

        {

        if( i==j ) continue;

        float[] v2 = vecs[j];

        float scalar1 = v1[0]*v2[3] + v1[1]*v2[4] + v1[2]*v2[5];

        float scalar2 = v1[0]*v2[6] + v1[1]*v2[7] + v1[2]*v2[8];

        if( scalar1<0 || scalar2<0 ) return true;

        }

      }

    return false;

    }

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

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

    {

    int band=0;

    int numFaces = indices.length;

    int numBordering = 0;

    float x=0, y=0, z=0;

    float[][] vecs = new float[numFaces][9];

    int vecIndex = 0;

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

      {

      int numComponentsInFace = indices[f].length;

      for(int c=0; c<numComponentsInFace; c++)

        {

        int[] ind = indices[f][c];

        int numVertsInComponent = ind.length;

        for(int v=0; v<numVertsInComponent; v++)

          {

          if(ind[v]==index)

            {

            int prev=v>0 ? v-1 : numVertsInComponent-1;

            int next=v<numVertsInComponent-1 ? v+1 : 0;

            int prevIndex=ind[prev];

            int currIndex=ind[v];

            int nextIndex=ind[next];

            float[] vec = vecs[vecIndex++];

            computeVectorFace(vertices[prevIndex], vertices[currIndex], vertices[nextIndex], vec);

            band|=bandIndices[f];

            v = numVertsInComponent;

            c = numComponentsInFace;

            numBordering++;

            x += vec[0];

            y += vec[1];

            z += vec[2];

            }

          }

        }

      }

    boolean concave = vertexIsConcave(vecs,vecIndex);

    return ( concave || band==0 || numBordering<3 ) ? null : new float[] { x/numBordering, y/numBordering, z/numBordering};

    }

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

  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 float[] buildFaceVertices(float[][] vertices, int[] indices, float[] pos, Static4D quat)

    {

    int num = indices.length;

    float[] ret = new float[3*num];

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

      {

      float[] v = vertices[indices[i]];

      QuatHelper.rotateVectorByQuat(mTmp,v[0],v[1],v[2],1,quat);

      ret[3*i  ] = mTmp[0] + pos[0];

      ret[3*i+1] = mTmp[1] + pos[1];

      ret[3*i+2] = mTmp[2] + pos[2];

      }

    return ret;

    }

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

  private void removeInternalWalls(ArrayList<BandagedCubitFace> list)

    {

    Collections.sort(list,new SortByCenterCast());

    int numElements = list.size();

    final float MAXDIFF = 0.01f;

    for(int e=0; e<numElements; e++)

      {

      int ne = e+1;

      BandagedCubitFace f1 = list.get(e);

      float[] center = f1.center;

      while( ne<numElements )

        {

        BandagedCubitFace f2 = list.get(ne);

        float diff = f2.centerCast-f1.centerCast;

        if( diff>-MAXDIFF && diff<MAXDIFF )

          {

          float[] c = f2.center;

          float dx = c[0]-center[0];

          float dy = c[1]-center[1];

          float dz = c[2]-center[2];

          float d = dx*dx + dy*dy + dz*dz;

          if( d>-MAXDIFF && d<MAXDIFF )

            {

            list.remove(ne);

            list.remove(e);

            numElements -= 2;

            e--;

            break;

            }

          }

        else break;

        ne++;

        }

      }

    }

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

  private float[][] getNextSection(ArrayList<BandagedCubitFace> list)

    {

    int numElements = list.size();

    if( numElements==0 ) return null;

    final float MAXDIFF = 0.01f;

    float[][] ret = new float[numElements][];

    BandagedCubitFace bcf = list.remove(0);

    float[] normal = bcf.normal;

    int removed = 1;

    ret[0] = bcf.vertices;

    for(int e=0; e<numElements-1; e++)

      {

      BandagedCubitFace f = list.get(e);

      float[] n = f.normal;

      float dx = n[0]-normal[0];

      float dy = n[1]-normal[1];

      float dz = n[2]-normal[2];

      float diff = dx*dx + dy*dy + dz*dz;

      if( diff>-MAXDIFF && diff<MAXDIFF )

        {

        list.remove(e);

        e--;

        numElements--;

        ret[removed++] = f.vertices;

        }

      }

    float[][] ret2 = new float[removed][];

    for(int i=0; i<removed; i++) ret2[i] = ret[i];

    return ret2;

    }

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

  private boolean isConnected(float[] face1, float[] face2)

    {

    float MAXDIFF = 0.01f;

    int l1 = face1.length/3;

    int l2 = face2.length/3;

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

      {

      float x = face1[3*i  ];

      float y = face1[3*i+1];

      float z = face1[3*i+2];

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

        {

        float dx = x-face2[3*j  ];

        float dy = y-face2[3*j+1];

        float dz = z-face2[3*j+2];

        if( dx*dx + dy*dy + dz*dz < MAXDIFF )

          {

          int inext = i==l1-1 ? 0 : i+1;

          int jprev = j==0 ? l2-1 : j-1;

          dx = face1[3*inext  ] - face2[3*jprev  ];

          dy = face1[3*inext+1] - face2[3*jprev+1];

          dz = face1[3*inext+2] - face2[3*jprev+2];

          if( dx*dx + dy*dy + dz*dz < MAXDIFF ) return true;

          int iprev = i==0 ? l1-1 : i-1;

          int jnext = j==l2-1 ? 0 : j+1;

          dx = face1[3*iprev  ] - face2[3*jnext  ];

          dy = face1[3*iprev+1] - face2[3*jnext+1];

          dz = face1[3*iprev+2] - face2[3*jnext+2];