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

import android.graphics.Canvas;

import android.graphics.Paint;

import org.distorted.library.effect.MatrixEffect;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectRotate;

import org.distorted.library.effect.MatrixEffectScale;

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

  private 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[]

         {

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

           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 MatrixEffectRotate[][] ROTATION;

  static

    {

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

    Static1D angle  = new Static1D(180.0f);

    ROTATION = new MatrixEffectRotate[AXIS.length][1];

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

      {

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

      }

    }

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

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

    {

    super(size,quatCur,quatAcc,texture,mesh,effects);

    }

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

  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;

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

      {

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

      added += i;

      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, z+SQ3/2,  0.5f, 0, SQ3/2, n-1, -1, array, index);

      index += (n-1);

      emitRow( x+n-1 , y, z      , -0.5f, 0, SQ3/2, n-1, -1, 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 ? 2*size*size-4*size+4: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;

    }

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

  Static3D[] getRotationAxis()

    {

    return AXIS;

    }

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

  void createFaceTexture(Canvas canvas, Paint paint, int face)

    {

    int xoffset = face*TEXTURE_HEIGHT;

    float STROKE = 0.05f*TEXTURE_HEIGHT;

    float OFF = STROKE/2 -1;

    float OFF2 = 0.5f*TEXTURE_HEIGHT + OFF;

    float HEIGHT = TEXTURE_HEIGHT - OFF;

    float RADIUS = TEXTURE_HEIGHT/12;

    float ARC1_H = 0.2f*TEXTURE_HEIGHT;

    float ARC1_W = TEXTURE_HEIGHT*0.5f;

    float ARC2_W = 0.153f*TEXTURE_HEIGHT;

    float ARC2_H = 0.905f*TEXTURE_HEIGHT;

    float ARC3_W = TEXTURE_HEIGHT-ARC2_W;

    paint.setAntiAlias(true);

    paint.setStrokeWidth(STROKE);

    paint.setColor(FACE_COLORS[face]);

    paint.setStyle(Paint.Style.FILL);

    canvas.drawRect(xoffset,0,xoffset+TEXTURE_HEIGHT,TEXTURE_HEIGHT,paint);

    paint.setColor(0xff000000);

    paint.setStyle(Paint.Style.STROKE);

    canvas.drawLine(                     xoffset,         HEIGHT,  TEXTURE_HEIGHT       +xoffset, HEIGHT, paint);

    canvas.drawLine(                OFF +xoffset, TEXTURE_HEIGHT,                 OFF2  +xoffset,      0, paint);

    canvas.drawLine((TEXTURE_HEIGHT-OFF)+xoffset, TEXTURE_HEIGHT, (TEXTURE_HEIGHT-OFF2) +xoffset,      0, paint);

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

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

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

    }

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

  MeshBase createCubitMesh(int cubit, int vertices)

    {

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

    final int MESHES=4;

    MeshBase[] meshes = new MeshTriangles[MESHES];

    for(int i=0; i<MESHES; i++) meshes[i] = new MeshTriangles(5);

    MatrixEffect[] effects0 = new MatrixEffect[3];

    effects0[0] = new MatrixEffectScale( new Static3D(1,SQ3/2,1) );

    effects0[1] = new MatrixEffectRotate( new Static1D(90), new Static3D(1,0,0), new Static3D(0,0,0) );

    effects0[2] = new MatrixEffectMove( new Static3D(0,-SQ3/6,SQ3/12) );

    meshes[0].apply(effects0);

    Static1D angle = new Static1D(angleFaces);

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

    Static3D center= new Static3D(0,-SQ3/6,-SQ3/6);

    MatrixEffect[] effects1 = new MatrixEffect[5];

    effects1[0] = effects0[0];

    effects1[1] = effects0[1];

    effects1[2] = effects0[2];

    effects1[3] = new MatrixEffectRotate( new Static1D(180), new Static3D(0,0,1), center );

    effects1[4] = new MatrixEffectRotate( angle, axis, center );

    meshes[1].apply(effects1);

    axis.set(0.5f,0,-SQ3/2);

    center.set2(SQ3/3);

    meshes[2].apply(effects1);

    axis.set2(SQ3/2);

    meshes[3].apply(effects1);

    MeshJoined result = new MeshJoined(meshes);

    if( mRotArray[cubit]>=0 )

      {

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

      }

    return result;

    }

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

// PUBLIC API

  public int getBasicAngle()

    {

    return 3;

    }

}