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

import org.distorted.library.effect.MatrixEffectRotate;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static4D;

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

public class RubikPyraminx extends RubikObject

{

  private static final float SQ3 = (float)Math.sqrt(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   )

         };

         {

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

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

    }

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

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

      {

      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 )

      {

      }

    else

      {

      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)

    {

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

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

  float[] getLegalQuats()

    {

    return LEGALQUATS;

    }

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

  int getNumFaces()

    {

    return FACE_COLORS.length;

    }

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

  Static3D[] getRotationAxis()

    {

    return AXIS;

    }

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

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

    {

    float STROKE = 0.05f*TEXTURE_HEIGHT;

    float OFF = STROKE/2 -1;

    float RADIUS = TEXTURE_HEIGHT/12;

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

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

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

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

    if( mRotArray[cubit]>=0 )

      {

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

      }

    return result;

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

// PUBLIC API

  public int getBasicAngle()

    {

    return 3;

    }

}