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

import static org.distorted.objectlib.touchcontrol.TouchControl.TC_TETRAHEDRON;

import static org.distorted.objectlib.touchcontrol.TouchControl.TYPE_SPLIT_EDGE_COIN;

import org.distorted.library.main.QuatHelper;

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

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.ObjectSignatures;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;

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

public class TwistyCoinTetrahedron extends ShapeHexahedron

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(     0,-SQ3/3,-SQ6/3),

           new Static3D(     0,-SQ3/3, SQ6/3),

           new Static3D( SQ6/3, SQ3/3,     0),

           new Static3D(-SQ6/3, SQ3/3,     0),

         };

  private static final int N = 5;

  private static final float D = 0.9f;

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private float[][] mPosition;

  private int[] mQuatIndex;

  private float[][] V,M,L;

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

  public TwistyCoinTetrahedron(int meshState, int iconMode, Static4D quat, Static3D move, float scale, InitData data, InitAssets asset)

    {

    super(meshState, iconMode, data.getNumLayers()[0], quat, move, scale, data, asset);

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null ) mEdges = ScrambleEdgeGenerator.getScrambleEdgesSingle(mBasicAngle);

    return mEdges;

    }

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

  public float[][] getCuts(int[] numLayers)

    {

    if( mCuts==null )

      {

      float[] cut = new float[] {-0.95f*(SQ6/4),0};

      mCuts = new float[][] { cut,cut,cut,cut };

      }

    return mCuts;

    }

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

  public boolean[][] getLayerRotatable(int[] numLayers)

    {

    boolean[] tmp = new boolean[] {true,false,true};

    return new boolean[][] { tmp,tmp,tmp,tmp };

    }

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

  public int getTouchControlType()

    {

    return TC_TETRAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_SPLIT_EDGE_COIN;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

         {{0},{0},{0},{1},{3},{2}},

         {{1},{1},{1},{0},{2},{3}},

         {{2},{2},{2},{3},{1},{0}},

         {{3},{3},{3},{2},{0},{1}}

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlTetrahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlTetrahedron.FACE_AXIS;

    }

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

  private void initVertices()

    {

    V = new float[][]

        {

            { 0.0f,-0.75f*SQ2,-1.5f},

            { 0.0f,-0.75f*SQ2, 1.5f},

            { 1.5f, 0.75f*SQ2, 0.0f},

            {-1.5f, 0.75f*SQ2, 0.0f},

        };

    float A = 1.04f;

    M = new float[4][3];

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

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

        M[i][j] = A*(V[0][j]+V[1][j]+V[2][j]+V[3][j]-V[i][j])/3;

    L = new float[12][3];

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

      {

      L[ 0][i] = 0.5f*V[1][i] + 0.25f*V[2][i] + 0.25f*V[3][i];

      L[ 1][i] = 0.5f*V[3][i] + 0.25f*V[1][i] + 0.25f*V[2][i];

      L[ 2][i] = 0.5f*V[2][i] + 0.25f*V[1][i] + 0.25f*V[3][i];

      L[ 3][i] = 0.5f*V[0][i] + 0.25f*V[2][i] + 0.25f*V[3][i];

      L[ 4][i] = 0.5f*V[2][i] + 0.25f*V[0][i] + 0.25f*V[3][i];

      L[ 5][i] = 0.5f*V[3][i] + 0.25f*V[0][i] + 0.25f*V[2][i];

      L[ 6][i] = 0.5f*V[3][i] + 0.25f*V[1][i] + 0.25f*V[0][i];

      L[ 7][i] = 0.5f*V[0][i] + 0.25f*V[1][i] + 0.25f*V[3][i];

      L[ 8][i] = 0.5f*V[1][i] + 0.25f*V[0][i] + 0.25f*V[3][i];

      L[ 9][i] = 0.5f*V[2][i] + 0.25f*V[1][i] + 0.25f*V[0][i];

      L[10][i] = 0.5f*V[0][i] + 0.25f*V[1][i] + 0.25f*V[2][i];

      L[11][i] = 0.5f*V[1][i] + 0.25f*V[0][i] + 0.25f*V[2][i];

      }

    }

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

  public float[][] getCubitPositions(int[] numLayers)

    {

    if( mPosition==null )

      {

      if( V==null ) initVertices();

      float A = -0.015f;

      float[] r0 = new float[] { A*(V[0][0]-M[0][0]), A*(V[0][1]-M[0][1]), A*(V[0][2]-M[0][2]) };

      float[] r1 = new float[] { A*(V[1][0]-M[1][0]), A*(V[1][1]-M[1][1]), A*(V[1][2]-M[1][2]) };

      float[] r2 = new float[] { A*(V[2][0]-M[2][0]), A*(V[2][1]-M[2][1]), A*(V[2][2]-M[2][2]) };

      float[] r3 = new float[] { A*(V[3][0]-M[3][0]), A*(V[3][1]-M[3][1]), A*(V[3][2]-M[3][2]) };

      mPosition = new float[][]

         {

             {V[1][0],V[1][1],V[1][2]},

             {V[0][0],V[0][1],V[0][2]},

             {V[2][0],V[2][1],V[2][2]},

             {V[3][0],V[3][1],V[3][2]},

             {M[0][0],M[0][1],M[0][2]},

             {M[1][0],M[1][1],M[1][2]},

             {M[2][0],M[2][1],M[2][2]},

             {M[3][0],M[3][1],M[3][2]},

             {L[ 0][0] +r0[0],L[ 0][1] +r0[1],L[ 0][2] +r0[2]},

             {L[ 1][0] +r0[0],L[ 1][1] +r0[1],L[ 1][2] +r0[2]},

             {L[ 2][0] +r0[0],L[ 2][1] +r0[1],L[ 2][2] +r0[2]},

             {L[ 3][0] +r1[0],L[ 3][1] +r1[1],L[ 3][2] +r1[2]},

             {L[ 4][0] +r1[0],L[ 4][1] +r1[1],L[ 4][2] +r1[2]},

             {L[ 5][0] +r1[0],L[ 5][1] +r1[1],L[ 5][2] +r1[2]},

             {L[ 6][0] +r2[0],L[ 6][1] +r2[1],L[ 6][2] +r2[2]},

             {L[ 7][0] +r2[0],L[ 7][1] +r2[1],L[ 7][2] +r2[2]},

             {L[ 8][0] +r2[0],L[ 8][1] +r2[1],L[ 8][2] +r2[2]},

             {L[ 9][0] +r3[0],L[ 9][1] +r3[1],L[ 9][2] +r3[2]},

             {L[10][0] +r3[0],L[10][1] +r3[1],L[10][2] +r3[2]},

             {L[11][0] +r3[0],L[11][1] +r3[1],L[11][2] +r3[2]},

         };

      }

    return mPosition;

    }

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

  public Static4D getCubitQuats(int cubit, int[] numLayers)

    {

    if( mQuatIndex==null ) mQuatIndex = new int[] {0,6,1,2,

                                                   0,5,4,3,

                                                   0,2,1,10,8,5,11,7,4,9,6,3 };

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[] rotateVertices(float angle, float[] vector, float[] center, float[] rotAxis)

    {

    float[] ret = new float[4];

    float sin = (float)Math.sin(angle/2);

    float cos = (float)Math.cos(angle/2);

    float[] quat= new float[] { sin*rotAxis[0], sin*rotAxis[1], sin*rotAxis[2], cos};

    QuatHelper.rotateVectorByQuat(ret,vector,quat);

    ret[0] += center[0];

    ret[1] += center[1];

    ret[2] += center[2];

    return ret;

    }

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

  private void normalize(float[] v)

    {

    float len = (float)Math.sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);

    v[0] /= len;

    v[1] /= len;

    v[2] /= len;

    }

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

  private float[][] produceCorner()

    {

    float[][] ret = new float[5 + 3*(N+1) +3][];

    ret[0] = new float[] { 0.00f, 0.0f     , 0.00f };

    ret[1] = new float[] { 0.00f, 0.0f     ,-1.50f };

    ret[2] = new float[] { 0.75f, 0.75f*SQ2,-0.75f };

    ret[3] = new float[] {-0.75f, 0.75f*SQ2,-0.75f };

    ret[4] = new float[] { 0.00f, 0.75f*SQ2,-1.50f };

    float[] vect1 = new float[4];

    float[] vect2 = new float[4];

    float[] vect3 = new float[4];

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

      {

      vect1[i] = -D*M[0][i] + D*(V[1][i]+V[3][i])/2;

      vect2[i] = -D*M[3][i] + D*(V[1][i]+V[2][i])/2;

      vect3[i] = -D*M[2][i] + D*(V[0][i]+V[1][i])/2;

      }

    float[] rot1 = new float[] { V[0][0]-M[0][0], V[0][1]-M[0][1], V[0][2]-M[0][2] };

    float[] rot2 = new float[] { V[3][0]-M[3][0], V[3][1]-M[3][1], V[3][2]-M[3][2] };

    float[] rot3 = new float[] { V[2][0]-M[2][0], V[2][1]-M[2][1], V[2][2]-M[2][2] };

    normalize(rot1);

    normalize(rot2);

    normalize(rot3);

    float[] center1 = { M[0][0]-V[1][0], M[0][1]-V[1][1], M[0][2]-V[1][2] };

    float[] center2 = { M[3][0]-V[1][0], M[3][1]-V[1][1], M[3][2]-V[1][2] };

    float[] center3 = { M[2][0]-V[1][0], M[2][1]-V[1][1], M[2][2]-V[1][2] };

    for(int i=0; i<N+1; i++)

      {

      float angle = (float)(2*Math.PI/3)*i/N;

      ret[5        +i] = rotateVertices(angle,vect1,center1,rot1);

      ret[5+   N+1 +i] = rotateVertices(angle,vect2,center2,rot2);

      ret[5+2*(N+1)+i] = rotateVertices(angle,vect3,center3,rot3);

      }

    float B = 0.85f;

    ret[ 5 + 3*(N+1)  ] = new float[] { ret[0][0]*B + ret[1][0]*(1-B), ret[0][1]*B + ret[1][1]*(1-B), ret[0][2]*B + ret[1][2]*(1-B) };

    ret[ 5 + 3*(N+1)+1] = new float[] { ret[0][0]*B + ret[2][0]*(1-B), ret[0][1]*B + ret[2][1]*(1-B), ret[0][2]*B + ret[2][2]*(1-B) };

    ret[ 5 + 3*(N+1)+2] = new float[] { ret[0][0]*B + ret[3][0]*(1-B), ret[0][1]*B + ret[3][1]*(1-B), ret[0][2]*B + ret[3][2]*(1-B) };

    return ret;

    }

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

  private float[][] produceCenter()

    {

    float[][] ret = new float[3*N+1][];

    float[] rot = new float[] { V[0][0]-M[0][0], V[0][1]-M[0][1], V[0][2]-M[0][2] };

    normalize(rot);

    float[] center1 = {   0.0f,-D*SQ2  , D  };

    float[] center2 = { D*1.5f, D*SQ2/2,-D/2};

    float[] center3 = {-D*1.5f, D*SQ2/2,-D/2};

    float[] vect1 = {  D*0.75f, D*0.75f*SQ2, -D*0.75f, 0.0f };

    float[] vect2 = { -D*1.50f,   0.00f    ,    0.00f, 0.0f };

    float[] vect3 = {  D*0.75f,-D*0.75f*SQ2,  D*0.75f, 0.0f };

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

      {

      float angle = (float)(Math.PI/3)*i/N;

      ret[  N-1-i] = rotateVertices(angle, vect1, center1, rot);

      ret[2*N-1-i] = rotateVertices(angle, vect2, center2, rot);

      ret[3*N-1-i] = rotateVertices(angle, vect3, center3, rot);

      }

    ret[3*N] = new float[] { 0.0f, -SQ2/4, -0.5f };

    return ret;

    }

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

  private float[][] produceLeaf()

    {

    float[][] ret = new float[2*N+1][];

    float[] rot = new float[] { V[0][0]-M[0][0], V[0][1]-M[0][1], V[0][2]-M[0][2] };

    normalize(rot);

    float[] center1 = { 0.0f, -D*0.75f*SQ2, D*0.75f };

    float[] center2 = { 0.0f,    0.25f*SQ2,  -0.25f };

    float[] vect1 = {  D*0.75f, D*0.75f*SQ2, -D*0.75f, 0.0f };

    float[] vect2 = new float[4];

    for(int i=0; i<3; i++) vect2[i] = -D*M[0][i] + D*(V[1][i]+V[3][i])/2;

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

      {

      float angle1 = (float)(  Math.PI/3)*i/N;

      float angle2 = (float)(2*Math.PI/3)*i/N;

      ret[  N-1-i] = rotateVertices(angle1, vect1, center1, rot);

      ret[2*N-1-i] = rotateVertices(angle2, vect2, center2, rot);

      }

    ret[2*N] = new float[] { 0.0f, -0.75f*SQ2/10, -1.5f/10 };

    return ret;

    }

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

  private float[][] getVertices(int variant)

    {

         if( variant==0 ) return produceCorner();

    else if( variant==1 ) return produceCenter();

    else                  return produceLeaf();

    }

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

  private int[][] produceCornerShape()

    {

    int[][] ret = new int[9+3*N+3][];

    ret[0] = new int[N+4];

    ret[0][0] = 3;

    ret[0][1] = 0;

    ret[0][2] = 2;

    for(int i=0; i<N+1; i++) ret[0][3+i] = 5+N-i;

    ret[1] = new int[N+4];

    ret[1][0] = 2;

    ret[1][1] = 0;

    ret[1][2] = 1;

    for(int i=0; i<N+1; i++) ret[1][3+i] = 6+2*N-i;

    ret[2] = new int[N+4];

    ret[2][0] = 1;

    ret[2][1] = 0;

    ret[2][2] = 3;

    for(int i=0; i<N+1; i++) ret[2][3+i] = 7+3*N-i;

    ret[3] = new int[] {5+  N,2    , 4 };

    ret[4] = new int[] {2    ,6+  N, 4 };

    ret[5] = new int[] {6+2*N,1    , 4 };

    ret[6] = new int[] {1    ,7+2*N, 4 };

    ret[7] = new int[] {7+3*N,3    , 4 };

    ret[8] = new int[] {3    ,5    , 4 };

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

      {

      ret[9+    i] = new int[] {5    +i, 6    +i, 4};

      ret[9+  N+i] = new int[] {6+  N+i, 7+  N+i, 4};

      ret[9+2*N+i] = new int[] {7+2*N+i, 8+2*N+i, 4};

      }

    ret[3*N+ 9] = new int[] { 3*N+8, 3*N+ 9, 3 };

    ret[3*N+10] = new int[] { 3*N+9, 3*N+10, 1 };

    ret[3*N+11] = new int[] { 3*N+8, 3*N+10, 2 };

    return ret;

    }

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

  private int[][] produceCenterShape()

    {

    int[][] ret = new int[3+3*(N-1)+1][];

    ret[0] = new int[3*N];

    for(int i=0; i<3*N; i++) ret[0][i] = 3*N-1-i;

    for(int i=1; i<=N-1; i++)

      {

      ret[i] = new int[3];

      ret[i][0] = i;

      ret[i][1] = i-1;

      ret[i][2] = 3*N;

      ret[N-1+i] = new int[3];

      ret[N-1+i][0] = N+i;

      ret[N-1+i][1] = N+i-1;

      ret[N-1+i][2] = 3*N;

      ret[2*N-2+i] = new int[3];

      ret[2*N-2+i][0] = 2*N+i;

      ret[2*N-2+i][1] = 2*N+i-1;

      ret[2*N-2+i][2] = 3*N;

      }

    ret[3*N-2] = new int[] {   N-1,   N, 3*N };

    ret[3*N-1] = new int[] { 2*N-1, 2*N, 3*N };

    ret[3*N  ] = new int[] { 3*N-1,   0, 3*N };

    return ret;

    }

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

  private int[][] produceLeafShape()

    {

    int[][] ret = new int[2+2*(N-1)+1][];

    ret[0] = new int[2*N];

    for(int i=0; i<2*N; i++) ret[0][i] = 2*N-1-i;

    for(int i=1; i<=N-1; i++)

      {

      ret[i] = new int[3];

      ret[i][0] = i;

      ret[i][1] = i-1;

      ret[i][2] = 2*N;

      ret[N-1+i] = new int[3];

      ret[N-1+i][0] = N+i;

      ret[N-1+i][1] = N+i-1;

      ret[N-1+i][2] = 2*N;

      }

    ret[2*N-1] = new int[] { N,  N-1, 2*N };

    ret[2*N  ] = new int[] { 0,2*N-1, 2*N };

    return ret;

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      int[][] indices = produceCornerShape();

      return new ObjectShape(getVertices(variant), indices);

      }

    else if( variant==1 )

      {

      int[][] indices = produceCenterShape();

      return new ObjectShape(getVertices(variant), indices);

      }

    else

      {

      int[][] indices = produceLeafShape();

      return new ObjectShape(getVertices(variant), indices);

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

      float h1 = isInIconMode() ? 0.001f : 0.02f;

      float h2 = isInIconMode() ? 0.001f : 0.01f;

      float[][] bands = { {h1,35,0.2f,0.4f,5,1,0}, {h2,35,0.2f,0.4f,2,0,0} };

      int num = 9+3*N+3;

      int[] indices   = new int[num];

      for(int i=3; i<num; i++) indices[i] = 1;

      float A = 0.5f;

      float[] convexCenter = { 0.0f*A, 0.75f*SQ2*A, -1.50f*A};

      return new ObjectFaceShape(bands,indices,convexCenter);

      }

    else if( variant==1 )

      {

      float h1 = isInIconMode() ? 0.001f : 0.00f;

      float h2 = isInIconMode() ? 0.001f : 0.00f;

      float[][] bands = { {h1,15,0.1f,0.2f,5,0,0}, {h2,15,0.1f,0.2f,2,0,0} };

      int num = 3+3*(N-1)+1;

      int[] indices   = new int[num];

      for(int i=1; i<num; i++) indices[i] = 1;

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

      float h1 = isInIconMode() ? 0.001f : 0.02f;

      float h2 = isInIconMode() ? 0.001f : 0.00f;

      float[][] bands = { {h1,15,0.250f,0.7f,5,0,0}, {h2,15,0.125f,0.2f,2,0,0} };

      int num = 2+2*(N-1)+1;

      int[] indices   = new int[num];

      for(int i=1; i<num; i++) indices[i] = 1;

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

      float[][] corners = { {0.04f,0.10f} };

      int num = 5 + 3*(N+1) + 3;

      int[] indices     = new int[num];