TwistyPuzzleLib

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

// Copyright 2022 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.touchcontrol;

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

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

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.main.TwistyObject;

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

// Icosahedral objects: map the 2D swipes of user's fingers to 3D rotations

public class TouchControlIcosahedron extends TouchControlShapeConstant

{

  public  static final float DIST3D = (3+SQ5)*SQ3/12;

  private static final float DIST2D = SQ3/6;

  public static final float[] D3D   = { DIST3D,DIST3D,DIST3D,DIST3D,DIST3D,

                                        DIST3D,DIST3D,DIST3D,DIST3D,DIST3D,

                                        DIST3D,DIST3D,DIST3D,DIST3D,DIST3D,

                                        DIST3D,DIST3D,DIST3D,DIST3D,DIST3D };

  // topmost vertex (0,A,0) and 3 vertices from the second-topmost-layer, front one and two ones

  // to the right: (0,B,C) , (D,B,E) , (F,B,H)

  private static final float Z = (float)Math.sqrt(5+SQ5);

  private static final float A = Z*(SQ2/4);

  private static final float B = Z*(SQ2*SQ5/20);

  private static final float C = Z*(SQ2*SQ5/10);

  private static final float D = (SQ5+1)/4;

  private static final float E = Z*(SQ5-1)/(4*SQ2*SQ5);

  private static final float F = 0.5f;

  private static final float H =-Z*(SQ5+1)/(4*SQ2*SQ5);

  private static final float X1 = D/3;

  private static final float X2 = (D+F)/3;

  private static final float X3 = (2*D+F)/3;

  private static final float X4 = (D+F)/2;

  private static final float Y1 = (A+2*B)/3;

  private static final float Y2 = B/3;

  private static final float Z1 = (C+E)/3;

  private static final float Z2 = (E+H)/3;

  private static final float Z3 = 2*H/3;

  private static final float Z4 = (C-2*H)/3;

  private static final float Z5 = -H/3;

  private static final float Z6 = (H-C-E)/3;

  private static final float LEN = (float)Math.sqrt(X1*X1 + Y1*Y1 + Z1*Z1);

  public static final Static3D[] FACE_AXIS = new Static3D[]

         {

           new Static3D(    X1/LEN, Y1/LEN, Z1/LEN   ),

           new Static3D(    X2/LEN, Y1/LEN, Z2/LEN   ),

           new Static3D(  0.0f/LEN, Y1/LEN, Z3/LEN   ),

           new Static3D(   -X2/LEN, Y1/LEN, Z2/LEN   ),

           new Static3D(   -X1/LEN, Y1/LEN, Z1/LEN   ),

           new Static3D(  0.0f/LEN,-Y2/LEN, Z4/LEN   ),

           new Static3D(    X3/LEN,-Y2/LEN, Z5/LEN   ),

           new Static3D(    X4/LEN,-Y2/LEN, Z6/LEN   ),

           new Static3D(   -X4/LEN,-Y2/LEN, Z6/LEN   ),

           new Static3D(   -X3/LEN,-Y2/LEN, Z5/LEN   ),

           new Static3D(  0.0f/LEN, Y2/LEN,-Z4/LEN   ),

           new Static3D(   -X3/LEN, Y2/LEN,-Z5/LEN   ),

           new Static3D(   -X4/LEN, Y2/LEN,-Z6/LEN   ),

           new Static3D(    X4/LEN, Y2/LEN,-Z6/LEN   ),

           new Static3D(    X3/LEN, Y2/LEN,-Z5/LEN   ),

           new Static3D(   -X1/LEN,-Y1/LEN,-Z1/LEN   ),

           new Static3D(   -X2/LEN,-Y1/LEN,-Z2/LEN   ),

           new Static3D(  0.0f/LEN,-Y1/LEN,-Z3/LEN   ),

           new Static3D(    X2/LEN,-Y1/LEN,-Z2/LEN   ),

           new Static3D(    X1/LEN,-Y1/LEN,-Z1/LEN   ),

         };

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

  public TouchControlIcosahedron(TwistyObject object)

    {

    super(object,D3D,FACE_AXIS);

    }

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

  public float returnRotationFactor(int[] numLayers, int row)

    {

    return 1.0f;

    }

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

  private boolean isFaceInverted(int face)

    {

    return face<10;

    }

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

// corner    edge

//   |       \ 0 /

// 2 | 0      \ /

//  / \      2 | 1

// / 1 \       |

  int returnPart(int type, int face, float[] touchPoint)

    {

    switch(type)

      {

      case TYPE_NOT_SPLIT   : return 0;

      case TYPE_SPLIT_EDGE  : float y1 = (isFaceInverted(face) ? touchPoint[1] : -touchPoint[1]);

                              float x1 = touchPoint[0];

                              boolean e0 = x1>0;

                              boolean e1 = y1>( SQ3/3)*x1;

                              boolean e2 = y1>(-SQ3/3)*x1;

                              if(  e1 && e2 ) return 0;

                              if( !e1 && e0 ) return 1;

                              if( !e0 &&!e2 ) return 2;

      case TYPE_SPLIT_CORNER: float y2 = (isFaceInverted(face) ? touchPoint[1] : -touchPoint[1]);

                              float x2 = touchPoint[0];

                              boolean c0 = x2>0;

                              boolean c1 = y2>( SQ3/3)*x2;

                              boolean c2 = y2>(-SQ3/3)*x2;

                              if(  c0 && c2 ) return 0;

                              if( !c1 &&!c2 ) return 1;

                              if( !c0 && c1 ) return 2;

      }

    return 0;

    }

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

  boolean isInsideFace(int face, float[] p)

    {

    float y = (isFaceInverted(face) ? p[1] : -p[1]);

    float x = p[0];

    return (y >= -DIST2D) && (y <= DIST2D*(2-6*x)) && (y <= DIST2D*(2+6*x));

    }

}