TwistyPuzzleLib

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

// 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.objectlib.effects.solve;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.MatrixEffectRotate;

import org.distorted.library.type.Dynamic;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

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

public class SolveEffectSpin extends SolveEffect

  {

  private static Static4D quatMultiply( Static4D quat1, Static4D quat2 )

    {

    float qx = quat1.get0();

    float qy = quat1.get1();

    float qz = quat1.get2();

    float qw = quat1.get3();

    float rx = quat2.get0();

    float ry = quat2.get1();

    float rz = quat2.get2();

    float rw = quat2.get3();

    float tx = rw*qx - rz*qy + ry*qz + rx*qw;

    float ty = rw*qy + rz*qx + ry*qw - rx*qz;

    float tz = rw*qz + rz*qw - ry*qx + rx*qy;

    float tw = rw*qw - rz*qz - ry*qy - rx*qx;

    return new Static4D(tx,ty,tz,tw);

    }

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

// rotate 'vector' by quat^(-1)  ( i.e. return (quat^-1)*vector*quat )

  private static Static4D rotateVectorByInvertedQuat(Static4D vector, Static4D quat)

    {

    float qx = quat.get0();

    float qy = quat.get1();

    float qz = quat.get2();

    float qw = quat.get3();

    Static4D quatInverted= new Static4D(-qx,-qy,-qz,qw);

    Static4D tmp = quatMultiply(quatInverted,vector);

    return quatMultiply(tmp,quat);

    }

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

  private void createEffects(int phase, int duration, int[] points)

    {

    mCubeEffectPosition[phase] = new int[] {0};

    mCubeEffects[phase]        = new Effect[mCubeEffectPosition[0].length];

    Static4D quaternion = mObject.getRotationQuat();                      // always rotate around

    Static4D tmpAxis    = new Static4D(0,1,0,0);                          // vert axis no matter

    Static4D rotated    = rotateVectorByInvertedQuat(tmpAxis,quaternion); // how cube is rotated

    Static3D axis  = new Static3D(rotated.get0(), rotated.get1(), rotated.get2());

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

    Dynamic1D d = new Dynamic1D(duration/2, 1.0f);

    d.setMode(Dynamic.MODE_JUMP);

    d.setConvexity(0.0f);   // otherwise speed of the rotation would be strangely uneven

    d.add( new Static1D(36*points[0]) );

    d.add( new Static1D(36*points[1]) );

    d.add( new Static1D(36*points[2]) );

    d.add( new Static1D(36*points[3]) );

    d.add( new Static1D(36*points[4]) );

    mCubeEffects[phase][0] = new MatrixEffectRotate(d,axis,center);

    }

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

// PUBLIC API

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

  public void createEffectsPhase0(int duration)

    {

    createEffects(0,duration,new int[] {0,1,3,6,10});

    }

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

  public void createEffectsPhase1(int duration)

    {

    createEffects(1,duration,new int[] {0,4,7,9,10});

    }

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

// Enable all effects used in this Effect. Called by reflection from the parent class.

  @SuppressWarnings("unused")

  static void enable()

    {

    }

  }