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( SQ2*SQ3/3,  -1.0f/3,  -SQ2/3 ),

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

           new Static3D(         0,  -1.0f/3, 2*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

         };

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

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

    {

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

    }

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

// TODO

  Static3D[] getCubitPositions(int size)

    {

    return null;

    }

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

  float[] getLegalQuats()

    {

    return LEGALQUATS;

    }

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

  int getNumFaces()

    {

    return FACE_COLORS.length;

    }

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

  Static3D[] getRotationAxis()

    {

    return AXIS;

    }

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

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

    {

    // TODO

    }

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

  MeshBase createCubitMesh(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);

    return new MeshJoined(meshes);

    }

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

// PUBLIC API

  public int getBasicAngle()

    {

    return 3;

    }

}