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

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

import org.distorted.library.type.Static3D;

public class BandagedElement

  {

  private final float mX, mY, mZ;

  private final float[][] mCuts;

  private final int[] mNumCuts;

  private final float[][] mNormal;

  private final int[] mRotationRow;

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

  BandagedElement(float[] pos, int index, Static3D[] normalVector, float[][] cuts)

    {

    mX = pos[index  ];

    mY = pos[index+1];

    mZ = pos[index+2];

    int numFaces = normalVector.length;

    mNormal = new float[numFaces][];

    mRotationRow = new int[numFaces];

    mNumCuts = new int[numFaces];

    mCuts = cuts;

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

      {

      Static3D n = normalVector[i];

      mNormal[i] = new float[] { n.get0(), n.get1(), n.get2() };

      mNumCuts[i] = (mCuts==null || mCuts[i]==null ? 0 : mCuts[i].length);

      mRotationRow[i] = computeRow(i);

      }

    }

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

  private int computeRow(int face)

    {

    float[] ax = mNormal[face];

    float casted = mX*ax[0] + mY*ax[1] + mZ*ax[2];

    int num = mNumCuts[face];

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

      {

      if( casted<mCuts[face][i] ) return i;

      }

    return num;

    }

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

  int[] getRotRow()

    {

    return mRotationRow;

    }

  }

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

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

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 java.util.ArrayList;

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

abstract public class FactoryBandaged

  {

  private ArrayList<float[]> mTmpArray;

  private float mNX, mNY, mNZ;

  private float[] mDist3D;

  private int[][] mFaceBelongsBitmap;

  private float[][] mCuts;

  BandagedElement[] mElements;

  ArrayList<float[][]> mVertexArray;

  int[][] mBandIndices;

  float[][][] mVertices;

  int[][][][] mIndices;

  float[][] mMove;

  int mNumElements;

  int mNumFaces;

  Static3D[] mNormals;

  int[] mNumLayers;

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

  FactoryBandaged()

    {

    }

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

  abstract void prepareSubclass(int numVariants, int[] numLayers);

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

  abstract Static3D[] getNormals();

  abstract float[] getDist3D();

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

  abstract void fillUpVertexArray();

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

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

  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 elementExists(int x, int y, int z)

    {

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

      {

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

      if( row[0]==x && row[2]==y && row[4]==z ) return true;

      }

    return false;

    }

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

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

    mNX = ax + bx + ay*bz-az*by;

    mNY = ay + by + az*bx-ax*bz;

    mNZ = az + bz + ax*by-ay*bx;

    }

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

  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;

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

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

            band|=bandIndices[f];

            v = numVertsInComponent;

            c = numComponentsInFace;

            numBordering++;

            x += mNX;

            y += mNY;

            z += mNZ;

            }

          }

        }

      }

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

    prepareSubclass(numVariants,numLayers);

    }

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

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

    {

    mVertexArray.clear();

    mNumElements = pos.length/3;

    mElements = new BandagedElement[mNumElements];

    for(int i=0; i<mNumElements; i++) mElements[i] = new BandagedElement(pos, 3*i, mNormals, mCuts);

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

    }

  }

public class FactoryBandagedCuboid extends FactoryBandaged

  private int mMax;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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;

  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;

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