#include "common_pre.inc"

#declare zoomoutend = 0.75;
#declare endtime = 14;
#if (clock < zoomoutend)
  #declare camerapos = (clock+0.1)/(zoomoutend+0.1)*camerapos;
#end
#if (clock > endtime - zoomoutend)
  #declare timetoend = endtime - clock;
  #if (timetoend < 0)
    #declare timetoend = 0;
  #end
  //#declare camerapos = (timetoend+0.1)/(zoomoutend+0.1)*camerapos;
  #declare camerapos = timetoend/zoomoutend*camerapos + (1-timetoend/zoomoutend)*camerapos_above;
#end

#include "common.inc"
#include "colors.inc"

#ifdef (customfile)
  loadcustom (customfile)
  #declare RM_Decoration = RM_DecCustom;
#end

#if (clock > 0)
  #declare twiceclock = 2*clock;
  #declare shape = int (clock);
  #declare t01 = clock - shape;

  //#declare stadio = int (clock);
  //#declare shape = int (clock/2);
  //#declare parametro = clock - 2*shape;
#end

#ifndef (shape)
  #declare shape=0;
#end

#ifndef (t01)
  #declare t01 = 0;
#end

#declare tsm = smooth_unit(t01).x;

#declare RM_Partial = 2*tsm;
#declare RM_secondfold = 90;

#declare trfin = transform {
  translate RM_Thickness*y
}

#declare tr0 = transform {
  translate -3*RM_HalfSize*x
  translate -RM_HalfSize*z
}

#declare tr1 = transform {
  transform {tr0}
}

#declare tr2 = transform {
  transform {tr0}
  rotate 180*x
}

#declare tr3 = transform {
  transform {tr2}
  translate RM_HalfSize*x
  rotate 180*z
  translate -RM_HalfSize*x
  rotate -180*z
}

#declare tr4 = transform {
  transform {tr3}
  translate -RM_Size*z
  rotate 2*90*x
}

#declare tr5 = transform {
  transform {tr4}
  translate -RM_Size*z
  rotate -90*2*x
  translate RM_Size*z
}

#declare tr6 = transform {
  transform {tr5}
  translate -RM_HalfSize*(x + z)
  rotate 108*y
}

/*
sphere {
  0
  1.0
  pigment {color Red}
  transform {trfin}
}
sphere {
  RM_Size*x
  1.0
  pigment {color Green}
  transform {trfin}
}
 */

/* ============================================================= */

object {
#switch (shape)
  #case (0)
    RM_RubiksMagic("RRRURRRU")
    transform {tr0}
  #break

  #case (1)
    #declare RM_LiftAmount = tsm*RM_HalfThickness;

    RM_RubiksMagic("-R -R -R -Uvp -R -R -R -UvP")
    transform {tr1}
    rotate 180*tsm*x
  #break

  #case (2)
    #declare RM_LiftAmount = RM_HalfThickness;

    RM_RubiksMagic("-R -R -Rvp -RvQ -R -R -Rvp -RvQ")
    transform {tr2}

    translate RM_HalfSize*x
    rotate 180*tsm*z
    translate -RM_HalfSize*x
    rotate -180*tsm*z
  #break

  #case (3)
    #declare RM_LiftAmount = (1-tsm)*RM_HalfThickness;

    RM_RubiksMagic("-R -R -DvQ -R -R -R -DvQ -R")
    transform {tr3}
    translate -RM_Size*z
    rotate 180*tsm*x
    translate (1 - 0.5*RM_Partial)*RM_Size*z
  #break

  #case (4)
    #declare RM_LiftAmount = tsm*RM_HalfThickness;

    RM_RubiksMagic("-R -Rvp -D -Rvp -R -Rvp -D -Rvp")
    transform {tr4}
  #break

  #case (5)
    #declare RM_LiftAmount = (1-tsm)*RM_HalfThickness;

    RM_RubiksMagic("-R -UvQ -D -UvQ -R -UvQ -D -UvQ")
    transform {tr4}
    translate -RM_Size*z
    rotate -180*tsm*x
    translate RM_Size*z
  #break

  #case (6)
    #declare RM_LiftAmount = tsm*RM_HalfThickness;
    RM_RubiksMagic("+R +U +D +Ump +R +Ump +D +U")
    transform {tr5}
  #break

  #case (7)
    /*
     * interpolate between
     *   RM_RubiksMagic("+R +U +D +LmQ +Rvp +Umm +D +U")
     * and
     *   RM_RubiksMagic("R U -D --LmQ --Rvp Umm ++D +U")
     */
    #declare RM_LiftAmounts[0] = (1-tsm)*RM_HalfThickness;   // +  .
    #declare RM_LiftAmounts[1] = (1-2*tsm)*RM_HalfThickness; // +  -
    #declare RM_LiftAmounts[2] = (1-3*tsm)*RM_HalfThickness; // +  --
    #declare RM_LiftAmounts[3] = (1+tsm)*RM_HalfThickness;   // +  ++
    #declare RM_LiftAmounts[4] = RM_HalfThickness;           // +  +

    RM_RubiksMagic("+0R +0U +1D +2LmQ +2Rvp +0Umm +3D +4U")
    transform {tr5}
  #break

  #case (8)
    /*
     * interpolate between
     *   RM_RubiksMagic("R U -Dmp --L --DvQ Lmm ++D +U")
     * and
     *   RM_RubiksMagic("+R +U +Dmp +L +DvQ +Lmm +D +U")
     */
    #declare RM_LiftAmounts[0] = tsm*RM_HalfThickness;             // .  +
    #declare RM_LiftAmounts[1] = (-1 + 2*tsm)*RM_HalfThickness;    // -  +
    #declare RM_LiftAmounts[2] = (-2 + 3*tsm)*RM_HalfThickness;    // -- +
    #declare RM_LiftAmounts[3] = (2 - tsm)*RM_HalfThickness;       // ++ +
    #declare RM_LiftAmounts[4] = RM_HalfThickness;                 // +  +

    RM_RubiksMagic("+0R +0U +1Dmp +2L +2DvQ +0Lmm +3D +4U")
    transform {tr5}
  #break

  #case (9)
    /*
     * interpolate between
     *   RM_RubiksMagic("+R +U +Dmm +Lvp +D +LmQ +D +U")
     * and
     *   RM_RubiksMagic("+R ++U ++Dmm Lvp --D --LmQ -D U")
     */
    #declare RM_LiftAmounts[0] = RM_HalfThickness;                 // +  +
    #declare RM_LiftAmounts[1] = (1 + tsm)*RM_HalfThickness;       // +  ++
    #declare RM_LiftAmounts[2] = (1 - tsm)*RM_HalfThickness;       // +  .
    #declare RM_LiftAmounts[3] = (1 - 3*tsm)*RM_HalfThickness;     // +  --
    #declare RM_LiftAmounts[4] = (1 - 2*tsm)*RM_HalfThickness;     // +  -

    RM_RubiksMagic("+0R +1U +1Dmm +2Lvp +3D +3LmQ +4D +2U")
    transform {tr5}
  #break

  #case (10)
    /*
     * interpolate between
     *   RM_RubiksMagic("+R ++U ++Dmm DvQ --Dmp --L -D U")
     * and
     *   RM_RubiksMagic("+R +U +Dmm +DvQ +Dmp +L +D +U")
     */
    #declare RM_LiftAmounts[0] = RM_HalfThickness;                 // +  +
    #declare RM_LiftAmounts[1] = (2 - tsm)*RM_HalfThickness;       // ++ +
    #declare RM_LiftAmounts[2] = (0 + tsm)*RM_HalfThickness;       // .  +
    #declare RM_LiftAmounts[3] = (-2 + 3*tsm)*RM_HalfThickness;    // -- +
    #declare RM_LiftAmounts[4] = (-1 + 2*tsm)*RM_HalfThickness;    // -  +

    RM_RubiksMagic("+0R +1U +1Dmm +2DvQ +3Dmp +3L +4D +2U")
    transform {tr5}
  #break

  #case (11)
    /*
     * interpolate between
     *   RM_RubiksMagic("+R +U +LmQ +D +LmQ +L +D +U")
     * and
     *   RM_RubiksMagic("R U LmQ D LmQ L D U")
     */
    #declare RM_LiftAmount = (1 - tsm)*RM_HalfThickness;

    RM_RubiksMagic("+R +U +LmQ +D +LmQ +L +D +U")
    transform {tr5}
  #break

  #case (12)
    RM_RubiksMagic("RULDLLDU")
    transform {tr5}
    translate -tsm*RM_HalfSize*(x + z)
    rotate 108*tsm*y
  #break

  #case (13)
  #case (14)
    RM_RubiksMagic("RULDLLDU")
    transform {tr6}
  #break

  #else
    RM_RubiksMagic("RULDLLDU")
    transform {tr6}

#end
    transform {trfin}
  }

/*
object
{ RM_RubiksMagic("RRmDmLmURmUmLm")
  rotate -90*z
  rotate 180*y
  translate RM_Size*x
  translate 3*RM_HalfSize*y
  translate RM_HalfThickness*y
}
 */