Magic Cube

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.objects;

import android.graphics.Canvas;

import android.graphics.Paint;

import org.distorted.library.effect.VertexEffectDeform;

import org.distorted.library.effect.VertexEffectMove;

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.effect.VertexEffectScale;

import org.distorted.library.effect.VertexEffectSink;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshJoined;

import org.distorted.library.mesh.MeshRectangles;

import org.distorted.library.mesh.MeshTriangles;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

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

public class RubikPyraminx extends RubikObject

{

  private static final float SQ2 = (float)Math.sqrt(2);

  private static final float SQ3 = (float)Math.sqrt(3);

  static final Static3D[] AXIS = new Static3D[]

         {

           new Static3D(         0,        1,       0 ),

           new Static3D(         0,  -1.0f/3, 2*SQ2/3 ),

           new Static3D(-SQ2*SQ3/3,  -1.0f/3,  -SQ2/3 ),

           new Static3D( SQ2*SQ3/3,  -1.0f/3,  -SQ2/3 )

         };

  private static final int[] FACE_COLORS = new int[]

         {

           0xff00ff00, 0xffffff00,  // AXIS[0]right (GREEN ) AXIS[1]right (YELLOW )

           0xff0000ff, 0xffff0000   // AXIS[2]right (BLUE  ) AXIS[3]right (RED    )

         };

  // computed with res/raw/compute_quats.c

  private static final float[] LEGALQUATS = new float[]

         {

           0.0f, 1.0f, -1.0f, 0.5f, -0.5f, SQ2/2, -SQ2/2, SQ3/2, -SQ3/2,

           SQ3/3, -SQ3/3, SQ3/6, -SQ3/6, SQ2*SQ3/3, -SQ2*SQ3/3, SQ2*SQ3/6, -SQ2*SQ3/6

         };

  private int[] mRotArray;

  private static VertexEffectRotate[] ROTATION;

  private static MeshBase mMesh =null;

  private static MeshBase[] mMeshRotated = new MeshBase[AXIS.length];

  static

    {

    Static3D center = new Static3D(0,0,0);

    Static1D angle  = new Static1D(180.0f);

    ROTATION = new VertexEffectRotate[AXIS.length];

    for(int i=0; i<AXIS.length; i++)

      {

      ROTATION[i] = new VertexEffectRotate( angle, AXIS[i], center);

      mMeshRotated[i] = null;

      }

    }

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

  RubikPyraminx(int size, Static4D quatCur, Static4D quatAcc, DistortedTexture texture, MeshRectangles mesh, DistortedEffects effects, int[][] moves)

    {

    super(size, 30, quatCur,quatAcc,texture,mesh,effects,moves, RubikObjectList.PYRA);

    }

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

  private void emitRow(float x, float y, float z, float dx, float dy, float dz, int n, int rot, Static3D[] array, int index)

    {

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

      {

      mRotArray[i+index] = rot;

      array[i+index] = new Static3D(x+0.5f,y+SQ2*SQ3/12,z+SQ3/6);

      x += dx;

      y += dy;

      z += dz;

      }

    }

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

  private int emitLowermost(float x, float y, float z, int n, Static3D[] array)

    {

    int added = 0;

    emitRow( x      +0.5f, y+SQ3*SQ2/9, z+ SQ3/18,  1.0f, 0,     0, n-1, 1, array, added);

    added += (n-1);

    emitRow( x    +1.0f/3, y+SQ3*SQ2/9, z+2*SQ3/9,  0.5f, 0, SQ3/2, n-1, 3, array, added);

    added += (n-1);

    emitRow( x+n-1-1.0f/3, y+SQ3*SQ2/9, z+2*SQ3/9, -0.5f, 0, SQ3/2, n-1, 2, array, added);

    added += (n-1);

    for(int i=n; i>=1; i--)

      {

      emitRow(x     , y, z      , 1,0,0, i  , -1, array, added);

      added += i;

      emitRow(x+0.5f, y, z+SQ3/6, 1,0,0, i-1,  0, array, added);

      added += (i-1);

      x += 0.5f;

      y += 0.0f;

      z += SQ3/2;

      }

    return added;

    }

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

  private int emitUpper(float x, float y, float z, int n, Static3D[] array, int index)

    {

    if( n>1 )

      {

      emitRow( x           , y          , z        ,  1.0f, 0,     0, n-1, -1, array, index);

      index += (n-1);

      emitRow( x+0.5f      , y+SQ3*SQ2/9, z+SQ3/18 ,  1.0f, 0,     0, n-1,  1, array, index);

      index += (n-1);

      emitRow( x+0.5f      , y          , z+SQ3/2  ,  0.5f, 0, SQ3/2, n-1, -1, array, index);

      index += (n-1);

      emitRow( x    +1.0f/3, y+SQ3*SQ2/9, z+2*SQ3/9,  0.5f, 0, SQ3/2, n-1,  3, array, index);

      index += (n-1);

      emitRow( x+n-1       , y          , z        , -0.5f, 0, SQ3/2, n-1, -1, array, index);

      index += (n-1);

      emitRow( x+n-1-1.0f/3, y+SQ3*SQ2/9, z+2*SQ3/9, -0.5f, 0, SQ3/2, n-1,  2, array, index);

      index += (n-1);

      }

    else

      {

      mRotArray[index] = -1;

      array[index] = new Static3D(x+0.5f,y+SQ2*SQ3/12,z+SQ3/6);

      index++;

      }

    return index;

    }

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

// size^2 + 3*(size-1) in the lowermost layer, then 6*(size-2) in the next, 6*(size-3) in the next,

// ... 6 in the forelast, 1 in the last = 4size^2 - 6size +4 (if size>1)

  Static3D[] getCubitPositions(int size)

    {

    int numCubits = size>1 ? 4*size*size - 6*size +4 : 1;

    Static3D[] tmp = new Static3D[numCubits];

    mRotArray = new int[numCubits];

    int currentIndex = emitLowermost( -0.5f*size, -(SQ2*SQ3/12)*size, -(SQ3/6)*size, size, tmp);

    for(int i=size-1; i>=1; i--)

      {

      currentIndex = emitUpper( -0.5f*i, ((SQ2*SQ3)/12)*(3*size-4*i), -(SQ3/6)*i, i, tmp, currentIndex);

      }

    return tmp;

    }

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

  float[] getLegalQuats()

    {

    return LEGALQUATS;

    }

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

  int getNumFaces()

    {

    return FACE_COLORS.length;

    }

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

  float getScreenRatio()

    {

    return 0.82f;

    }

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

  private MeshBase createStaticMesh(int cubit)

    {

    final float SQ2 = (float)Math.sqrt(2);

    final float SQ3 = (float)Math.sqrt(3);

    final float angleFaces = (float)((180/Math.PI)*(2*Math.asin(SQ3/3))); // angle between two faces of a tetrahedron

    final int MESHES=4;

    int association = 1;

    MeshBase[] meshes = new MeshTriangles[MESHES];

    meshes[0] = new MeshTriangles(5);

    meshes[0].setEffectAssociation(0,association,0);

    for(int i=1; i<MESHES; i++)

      {

      association <<= 1;

      meshes[i] = meshes[0].copy(true);

      meshes[i].setEffectAssociation(0,association,0);

      }

    MeshBase result = new MeshJoined(meshes);

    Static3D a0 = new Static3D(         0,        1,       0 );

    Static3D a1 = new Static3D(         0,  -1.0f/3, 2*SQ2/3 );

    Static3D a2 = new Static3D(-SQ2*SQ3/3,  -1.0f/3,  -SQ2/3 );

    Static3D a3 = new Static3D( SQ2*SQ3/3,  -1.0f/3,  -SQ2/3 );

    float tetraHeight = SQ2*SQ3/3;

    float d1 = 0.75f*tetraHeight;

    float d2 =-0.10f*tetraHeight;

    float d3 = 0.20f*tetraHeight;

    Static3D dCen0 = new Static3D( d1*a0.get0(), d1*a0.get1(), d1*a0.get2() );

    Static3D dCen1 = new Static3D( d1*a1.get0(), d1*a1.get1(), d1*a1.get2() );

    Static3D dCen2 = new Static3D( d1*a2.get0(), d1*a2.get1(), d1*a2.get2() );

    Static3D dCen3 = new Static3D( d1*a3.get0(), d1*a3.get1(), d1*a3.get2() );

    Static3D dVec0 = new Static3D( d2*a0.get0(), d2*a0.get1(), d2*a0.get2() );

    Static3D dVec1 = new Static3D( d2*a1.get0(), d2*a1.get1(), d2*a1.get2() );

    Static3D dVec2 = new Static3D( d2*a2.get0(), d2*a2.get1(), d2*a2.get2() );

    Static3D dVec3 = new Static3D( d2*a3.get0(), d2*a3.get1(), d2*a3.get2() );

    Static4D dReg  = new Static4D(0,0,0,d3);

    Static1D dRad  = new Static1D(1);

    Static1D angle  = new Static1D(angleFaces);

    Static3D axis1  = new Static3D(  -1, 0,      0);

    Static3D axis2  = new Static3D(0.5f, 0, -SQ3/2);

    Static3D axis3  = new Static3D(0.5f, 0, +SQ3/2);

    Static3D center1= new Static3D(0,-SQ3*SQ2/12,-SQ3/6);

    Static3D center2= new Static3D(0,-SQ3*SQ2/12,+SQ3/3);

    Static3D center = new Static3D(0,0,0);

    Static4D region = new Static4D(0,0,0,0.6f);

    VertexEffectScale  effect1 = new VertexEffectScale ( new Static3D(1,SQ3/2,1) );

    VertexEffectRotate effect2 = new VertexEffectRotate( new Static1D(90), new Static3D(1,0,0), new Static3D(0,0,0) );

    VertexEffectMove   effect3 = new VertexEffectMove  ( new Static3D(0,-SQ3*SQ2/12,SQ3/12) );

    VertexEffectRotate effect4 = new VertexEffectRotate( new Static1D(180), new Static3D(0,0,1), center1 );

    VertexEffectRotate effect5 = new VertexEffectRotate( angle, axis1, center1 );

    VertexEffectRotate effect6 = new VertexEffectRotate( angle, axis2, center2 );

    VertexEffectRotate effect7 = new VertexEffectRotate( angle, axis3, center2 );

    VertexEffectDeform effect8 = new VertexEffectDeform(dVec0, dRad, dCen0, dReg);

    VertexEffectDeform effect9 = new VertexEffectDeform(dVec1, dRad, dCen1, dReg);

    VertexEffectDeform effect10= new VertexEffectDeform(dVec2, dRad, dCen2, dReg);

    VertexEffectDeform effect11= new VertexEffectDeform(dVec3, dRad, dCen3, dReg);

    VertexEffectSink   effect12= new VertexEffectSink( new Static1D(1.3f), center, region );

    effect4.setMeshAssociation(14,-1);  // apply to mesh[1], [2] and [3]

    effect5.setMeshAssociation( 2,-1);  // apply only to mesh[1]

    effect6.setMeshAssociation( 4,-1);  // apply only to mesh[2]

    effect7.setMeshAssociation( 8,-1);  // apply only to mesh[3]

    result.apply(effect1);

    result.apply(effect2);

    result.apply(effect3);

    result.apply(effect4);

    result.apply(effect5);

    result.apply(effect6);

    result.apply(effect7);

    result.apply(effect8);

    result.apply(effect9);

    result.apply(effect10);

    result.apply(effect11);

    result.apply(effect12);

    if( mRotArray[cubit]>=0 )

      {

      result.apply( ROTATION[mRotArray[cubit]] );

      }

    return result;

    }

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

  MeshBase createCubitMesh(int cubit)

    {

    int kind = mRotArray[cubit];

    if( kind>=0 )

      {

      if( mMeshRotated[kind]==null ) mMeshRotated[kind] = createStaticMesh(cubit);

      return mMeshRotated[kind].copy(false);

      }

    else

      {

      if( mMesh==null ) mMesh = createStaticMesh(cubit);

      return mMesh.copy(false);

      }

    }

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

  void createFaceTexture(Canvas canvas, Paint paint, int face, int left, int top, int side)

    {

    float STROKE = 0.06f*side;

    float OFF = STROKE/2 -1;

    float OFF2 = 0.5f*side + OFF;

    float HEIGHT = side - OFF;

    float RADIUS = side/12.0f;

    float ARC1_H = 0.2f*side;

    float ARC1_W = side*0.5f;

    float ARC2_W = 0.153f*side;

    float ARC2_H = 0.905f*side;

    float ARC3_W = side-ARC2_W;

    paint.setAntiAlias(true);

    paint.setStrokeWidth(STROKE);

    paint.setColor(FACE_COLORS[face]);

    paint.setStyle(Paint.Style.FILL);

    canvas.drawRect(left,top,left+side,top+side,paint);

    paint.setColor(INTERIOR_COLOR);

    paint.setStyle(Paint.Style.STROKE);

    canvas.drawLine(           left, HEIGHT,  side       +left, HEIGHT, paint);

    canvas.drawLine(      OFF +left, side  ,       OFF2  +left,      0, paint);

    canvas.drawLine((side-OFF)+left, side  , (side-OFF2) +left,      0, paint);

    canvas.drawArc( ARC1_W-RADIUS+left, ARC1_H-RADIUS, ARC1_W+RADIUS+left, ARC1_H+RADIUS, 225, 90, false, paint);

    canvas.drawArc( ARC2_W-RADIUS+left, ARC2_H-RADIUS, ARC2_W+RADIUS+left, ARC2_H+RADIUS, 105, 90, false, paint);

    canvas.drawArc( ARC3_W-RADIUS+left, ARC2_H-RADIUS, ARC3_W+RADIUS+left, ARC2_H+RADIUS, 345, 90, false, paint);

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return AXIS;

    }

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

  public int getBasicAngle()

    {

    return 3;

    }

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

  public float returnMultiplier()

    {

    return getSize()/(SQ3/2);

    }

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

  public float[] getRowChances()

    {

    int size = getSize();

    int total = size*(size+1)/2;

    float running=0.0f;

    float[] chances = new float[size];

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

      {

      running += (size-i);

      chances[i] = running / total;

      }

    return chances;

    }

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

  public float returnRotationFactor(float offset)

    {

    int size = getSize();

    int row  = (int)(size*offset/(SQ3/2));

    return ((float)size)/(size-row);

    }

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

// TODO

  public String retObjectString()

    {

    return "";

    }

}