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.objects.TwistyBandagedCuboid.REGION_SIZE;

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

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.type.Static3D;

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;

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

abstract public class FactoryBandaged

  {

  private ArrayList<float[]> mTmpArray;

  private float[] mDist3D;

  private int[][] mFaceBelongsBitmap;

  private float[][] mCuts;

  private float[][] mRotAxis;

  BandagedElement[] mElements;

  ArrayList<float[][]> mVertexArray;

  int[][] mBandIndices;

  float[][][] mVertices;

  int[][][][] mIndices;

  float[][] mMove;

  int mNumElements;

  int mNumFaces;

  int mNumAxis;

  Static3D[] mNormals;

  int[] mNumLayers;

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

  FactoryBandaged()

    {

    }

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

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

  abstract Static3D[] getNormals();

  abstract float[] getDist3D();

  abstract float[][] getBands(boolean iconMode);

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

  abstract float[][] getRotAxis();

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

  abstract int getElementVariant(int index);

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

  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;

    }

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

// 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() )

  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] = (diameter>=6 ? 5: (int)diameter);

        }

      }

    return bandIndices;

    }

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

  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;

    }

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

  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;

    }

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

  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;

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

          {

          if( mIndices[variant][face][comp][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])

              {

              mIndices[variant][face][comp][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 },

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

      }

    }

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

  boolean elementDoesntExist(int[] p)

    {

    boolean res;

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

      {

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

      res = true;

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

        if( row[j]!=p[j] )

          {

          res = false;

          break;

          }

      if( res ) return false;

      }

    return true;

    }

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

  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 boolean elementsFormSection(int e1, int e2, int ax)

    {

    int[] r1 = mElements[e1].getRotRow();

    int[] r2 = mElements[e2].getRotRow();

    if( r1[ax]==r2[ax] )

      {

      int dist=0;

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

        {

        int d=r1[i]-r2[i];

        dist+=d*d;

        }

      return dist==1;

      }

    return false;

    }

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

  private int computeConnectedSection(int element, int ax, boolean[] walls, int[] output, int index)

    {

    int found = index;

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

      if( walls[e] && elementsFormSection(element,e,ax) )

        {

        walls[e] = false;

        output[found++] = e;

        found = computeConnectedSection(e,ax,walls,output,found);

        }

    return found;

    }

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

  private void buildAllSections(int ax, boolean left, boolean[] walls, ArrayList<float[][]> list)

    {

    int numElements = 0;

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

      if( walls[i] ) numElements++;

    int[] tmp = new int[numElements];

    while( numElements>0 )

      {

      int element  = 0;

      for( ; element<mNumElements; element++)

        if( walls[element] )

          {

          walls[element] = false;

          tmp[0] = element;

          break;

          }

      int elementsInSection = computeConnectedSection(element,ax,walls,tmp,1);

      float[][] newSection = new float[elementsInSection][];

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

        newSection[i] = elementVertices(ax,left,tmp[i]);

      list.add(newSection);

      numElements -= elementsInSection;

      }

    }

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

  private void fillUpVertexArray()

    {

    boolean[][][] walls = new boolean[mNumAxis][2][mNumElements];

    int[] tmp = new int[mNumAxis];

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

      {

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

      for(int t=0; t<mNumAxis; t++) tmp[t]=row[t];

      for(int a=0; a<mNumAxis; a++)

        {

        if( a>0 ) tmp[a-1]=row[a-1];

        tmp[a] = row[a]-1;

        walls[a][0][e] = elementDoesntExist(tmp);

        tmp[a] = row[a]+1;

        walls[a][1][e] = elementDoesntExist(tmp);

        }

      }

    for(int a=0; a<mNumAxis; a++)

      {

      buildAllSections(a, true,  walls[a][0], mVertexArray );

      buildAllSections(a, false, walls[a][1], mVertexArray );

      }

    }

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

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

      for(int anInt : ints) ii+=(anInt+" ");

      }

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

    }

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

  private int debugArray(int start, String str)

    {

    StringBuilder s = new StringBuilder();

    int n = mVertexArray.size();

    for(int i=start; i<n; i++)

      {

      float[][] v = mVertexArray.get(i);

      int numC = v.length;

      s.append("numComp: ");

      s.append(numC);

      for(float[] floats : v)

        {

        int l=floats.length/3;

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

          {

          s.append(" (");

          s.append(floats[3*k  ]);

          s.append(" ");

          s.append(floats[3*k+1]);

          s.append(" ");

          s.append(floats[3*k+2]);

          s.append(") ");

          }

        }

      }

    android.util.Log.e("D", str+" : "+s);

    return n;

    }

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

// PUBLIC API

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

    {

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

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

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

    mMove = new float[numVariants][3];

    mBandIndices = new int[numVariants][];

    mFaceBelongsBitmap= new int[numVariants][];

    mNumLayers = numLayers;

    mNormals   = getNormals();

    mNumFaces  = mNormals.length;

    mDist3D    = getDist3D();

    mCuts      = getCuts(numLayers);

    mRotAxis   = getRotAxis();

    mNumAxis   = mRotAxis.length;

    }

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

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

    {

    mVertexArray.clear();

    mNumElements = pos.length/3;

    mElements = new BandagedElement[mNumElements];

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

      {

      int elementVariant = getElementVariant(i);

      mElements[i] = new BandagedElement(pos, 3*i, mRotAxis, mCuts,elementVariant);

      }

    fillUpVertexArray();

    computeMove(pos,variant);

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

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

    compressVerticesAndIndices(variant,verts,inds);

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

    }

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

  public ObjectFaceShape createIrregularFaceShape(int variant, boolean iconMode)

    {

    float[][] bands = getBands(iconMode);

    if( mBandIndices[variant]==null )

      {

      mFaceBelongsBitmap[variant] = computeFaceBelongsBitmap(mVertices[variant], mMove[variant]);

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

      }

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

    }

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

  public ObjectVertexEffects createVertexEffects(int variant, boolean roundCorners)

    {

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

    int numEffects   = mVertices[variant].length;

    float S          = STRENGTH;

    float[] region   = {0,0,0,REGION_SIZE};

    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 MeshBase createMesh(float[] pos, int[] numLayers, boolean iconMode, boolean roundCorners)

    {

    prepare(1,numLayers);

    ObjectShape shape           = createIrregularShape(0,pos);

    ObjectFaceShape face        = createIrregularFaceShape(0,iconMode);

    ObjectVertexEffects effects = createVertexEffects(0,roundCorners);

    int numFaces                = shape.getNumFaces();

    FactoryCubit factory = FactoryCubit.getInstance();

    factory.clear();

    factory.createNewFaceTransform(shape,null);

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

    }

  }