TwistyPuzzleLib

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

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

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.main.TwistyObject;

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

public class ObjectShape

  {

  private static final float[] mTmp1 = new float[4];

  private static final float[] mTmp2 = new float[4];

  private final float[][] mVertices;

  private final int[][] mVertIndices;

  private final boolean mFacesMultigon;

  private final int mNumFaces;

  private final int[][][] mMultigonIndices;

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

  public ObjectShape(float[][] vertices, int[][] vertIndices)

    {

    mVertices        = vertices;

    mVertIndices     = vertIndices;

    mMultigonIndices = null;

    mFacesMultigon   = false;

    mNumFaces        = vertIndices.length;

    }

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

  public ObjectShape(float[][] vertices, int[][][] vertIndices)

    {

    mVertices       = vertices;

    mVertIndices    = null;

    mMultigonIndices= vertIndices;

    mFacesMultigon  = true;

    mNumFaces       = vertIndices.length;

    }

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

  public void debug()

    {

    StringBuilder str = new StringBuilder();

    str.append("isMultigon: ");

    str.append(mFacesMultigon);

    str.append("\n");

    str.append("numVertices: ");

    int numV =mVertices.length;

    str.append(numV);

    str.append("\n");

    for(float[] v : mVertices)

      {

      str.append(" {");

      str.append(v[0]);

      str.append("f, ");

      str.append(v[1]);

      str.append("f, ");

      str.append(v[2]);

      str.append("f },\n");

      }

    if( mFacesMultigon )

      {

      int numFaces =mMultigonIndices.length;

      str.append("numFaces: ");

      str.append(numFaces);

      str.append("\n");

      for(int[][] mMultigonIndex : mMultigonIndices)

        {

        for(int[] multigonIndex : mMultigonIndex)

          {

          int len = multigonIndex.length;

          str.append(" {");

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

            {

            str.append( i==0 ? " " : ", ");

            str.append(multigonIndex[i]);

            }

          str.append("},");

          }

        str.append("\n");

        }

      }

    else

      {

      int numFaces =mVertIndices.length;

      str.append("\nnumFaces: ");

      str.append(numFaces);

      str.append("\n   ");

      for(int[] vertIndex : mVertIndices)

        {

        for(int index : vertIndex)

          {

          str.append(" ");

          str.append(index);

          }

        str.append("\n   ");

        }

      }

    android.util.Log.e("D", "ObjectShape: \n"+str);

    }

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

  public int getNumFaces()

    {

    return mNumFaces;

    }

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

  public boolean isMultigon()

    {

    return mFacesMultigon;

    }

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

  public float[][] getVertices()

    {

    return mVertices;

    }

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

  public int[][] getVertIndices()

    {

    return mVertIndices;

    }

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

  public int[][][] getMultigonIndices()

    {

    return mMultigonIndices;

    }

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

  public float[] getFirstVertexInFace(int face)

    {

    if( mFacesMultigon )

      {

      int[][][] indices=getMultigonIndices();

      int vertIndex=indices[face][0][0];

      return getVertices()[vertIndex];

      }

    else

      {

      int[][] indices=getVertIndices();

      int vertIndex=indices[face][0];

      return getVertices()[vertIndex];

      }

    }

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

  private void computeNormalVector(float[] v0, float[] v1, float[] v2, float[] output)

    {

    float x1 = v0[0];

    float y1 = v0[1];

    float z1 = v0[2];

    float x2 = v1[0];

    float y2 = v1[1];

    float z2 = v1[2];

    float x3 = v2[0];

    float y3 = v2[1];

    float z3 = v2[2];

    float v1x = x2-x1;

    float v1y = y2-y1;

    float v1z = z2-z1;

    float v2x = x3-x1;

    float v2y = y3-y1;

    float v2z = z3-z1;

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

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

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

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

    len = Math.sqrt(len);

    output[0] /= len;

    output[1] /= len;

    output[2] /= len;

    }

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

// return surface defined by the face, i.e. a 4-tuple [ (nx,ny,nz), d ]

  public void getFaceNormal(int face, float[] output)

    {

    int[] loopI = mFacesMultigon ? getMultigonIndices()[face][0] : getVertIndices()[face];

    float[] v0 = mVertices[loopI[0]];

    float[] v1 = mVertices[loopI[1]];

    float[] v2 = mVertices[loopI[2]];

    computeNormalVector(v0,v1,v2,output);

    }

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

// return any point laying inside the face

  public void getFacePoint(int face, float[] output)

    {

    int[] loopI = mFacesMultigon ? getMultigonIndices()[face][0] : getVertIndices()[face];

    float[] v0 = mVertices[loopI[0]];

    float[] v1 = mVertices[loopI[1]];

    float[] v2 = mVertices[loopI[2]];

    output[0] = (v0[0] + v1[0] + v2[0]) / 3;

    output[1] = (v0[1] + v1[1] + v2[1]) / 3;

    output[2] = (v0[2] + v1[2] + v2[2]) / 3;

    }

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

  public static int computeNumComponents(ObjectShape[] shapes)

    {

    int ret = 0;

    for( ObjectShape shape : shapes )

      {

      int numShape = shape.mNumFaces;

      if( numShape>ret ) ret = numShape;

      }

    return ret;

    }

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

// take vertex, apply quat, apply move, write to output

  private static void computeVertex(float[] output, float[] vertex, float[] move, Static4D quat)

    {

    QuatHelper.rotateVectorByQuat(mTmp2,vertex[0],vertex[1],vertex[2],1.0f,quat);

    int numMoves = move.length/3;

    float moveX=0.0f, moveY=0.0f, moveZ=0.0f;

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

      {

      moveX += move[3*m  ];

      moveY += move[3*m+1];

      moveZ += move[3*m+2];

      }

    output[0] = mTmp2[0] + moveX/numMoves;

    output[1] = mTmp2[1] + moveY/numMoves;

    output[2] = mTmp2[2] + moveZ/numMoves;

    }

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

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

    {

    final float MAX_ERROR = 0.04f;  // Rex Cube requires this

    float x= faceAxis.get0();

    float y= faceAxis.get1();

    float z= faceAxis.get2();

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

    float diff = a - dist;

    return diff>-MAX_ERROR && diff<MAX_ERROR;

    }

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

  private static boolean indicesContain(int[][] indices, int index)

    {

    for( int[] ind : indices )

      for( int i : ind )

        if( i==index ) return true;

    return false;

    }

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

  private static boolean indicesContain(int[] indices, int index)

    {

    for( int j : indices )

      if( j==index ) return true;

    return false;

    }

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

  private static int[] computeCubitFaceColors(ObjectShape shape, float[] move, Static4D quat, Static3D[] faceAxis, float[] dist3D, float size)

    {

    float[][] vertices = shape.getVertices();

    int numVert = vertices.length;

    int numPuzzleFaces = faceAxis.length;

    int numCubitFaces = shape.mNumFaces;

    int[] cubitFaceColor = new int[numCubitFaces];

    for(int face=0; face<numCubitFaces; face++) cubitFaceColor[face] = 0xffffffff;

    for(int vert=0; vert<numVert; vert++)

      {

      computeVertex(mTmp1,vertices[vert],move,quat);

      int vertBelongsBitmap = 0x00000000;

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

        if( vertInFace(mTmp1,faceAxis[face],dist3D[face]*size) ) vertBelongsBitmap |= (1<<face);

      if( shape.mFacesMultigon )

        {

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

          if( cubitFaceColor[index]!=0 && indicesContain(shape.mMultigonIndices[index],vert) ) cubitFaceColor[index] &= vertBelongsBitmap;

        }

      else

        {

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

          if( cubitFaceColor[index]!=0 && indicesContain(shape.mVertIndices[index],vert) ) cubitFaceColor[index] &= vertBelongsBitmap;

        }

      }

    return cubitFaceColor;

    }

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

  private static void translateFromBitmap(int cubit, int[] colorsBitmap)

    {

    int len = colorsBitmap.length;

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

      {

      if( colorsBitmap[face]==0 ) colorsBitmap[face] = -1;

      else

        {

        int shift=0;

        while( (colorsBitmap[face]&0x1) != 1 )

          {

          colorsBitmap[face]>>=1;

          shift++;

          }

        if( colorsBitmap[face]!=1 )

          {

          android.util.Log.e("ObjectShape", "ERROR, cubit= "+cubit+" face "+face+" seems to belong to "+shift+" and still "+colorsBitmap[face]);

          }

        colorsBitmap[face] = shift;

        }

      }

    }

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

  public static int[][] computeColors(ObjectShape[] shapes, float[][] moves, Static4D[] quats, TwistyObject object)

    {

    int numCubits = moves.length;

    int[][] colors = new int[numCubits][];

    int[] numLayers = object.getNumLayers();

    Static3D[] faceAxis = object.getFaceAxis();

    float[] dist3D = object.getDist3D(numLayers);

    float size = object.getSize();

    for(int cubit=0; cubit<numCubits; cubit++)

      {

      int variant = object.getCubitVariant(cubit,numLayers);

      colors[cubit] = computeCubitFaceColors(shapes[variant],moves[cubit],quats[cubit],faceAxis,dist3D,size);

      translateFromBitmap(cubit,colors[cubit]);

      }

    return colors;

    }

  }