//#ifndef (Fast)
//  #declare Fast = 1;
//#end

#include "common_pre.inc"

#declare zoomoutend = 0.75;
#if (clock < zoomoutend)
  #declare camerapos = (clock+0.1)/(zoomoutend+0.1)*camerapos;
#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 t02 = twiceclock - 2*shape;
  #declare t01 = clock - shape;
#end

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

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

#declare tsm = smooth_unit(t01).x;

//sphere {
//  0
//  1.0
//  pigment {color Blue}
//}

#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}
//  translate -RM_HalfSize*(3*x+z)
//  rotate 180*z
}

#declare tr2 = transform {
  transform {tr1}
  rotate 180*z
}

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

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

#declare tr5 = transform {
  transform {tr4}
  rotate 2*90*z
  translate 3*RM_HalfSize*x
}

#declare tr6 = transform {
  transform {tr5}
}

#declare tr7 = transform {
  transform {tr6}
  rotate 2*90*x
  translate RM_HalfSize*z
}

#declare tr8 = transform {
  transform {tr7}
}

#declare tr9 = transform {
  transform {tr8}
  rotate -90*0.5*2*z
  rotate 180*0.5*2*y
}

#declare tr10 = transform {
  transform {tr9}
  translate RM_HalfSize*(z-x)
}

#declare tr11 = transform {
  transform {tr10}
}

#declare tr12 = transform {
  transform {tr11}
}

#declare tr13 = transform {
  transform {tr12}
  translate RM_HalfSize*x
}

#declare tr14 = transform {
  transform {tr13}
  rotate -2*90*z
}

#declare tr15 = transform {
  transform {tr14}
  rotate -2*90*y
  translate -2*RM_HalfSize*z
}

#declare tr16 = transform {
  transform {tr15}
}

#declare tr17 = transform {
  transform {tr16}
  rotate -2*0.5*90*z
  translate -RM_HalfSize*x
}

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

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

  #case (1)  // rotate rectangle upside-down
    RM_RubiksMagic("RRRURRRU")
    transform {tr1}
    translate 2*RM_Size*x
    rotate 180*tsm*z
    translate -2*RM_Size*x
    translate 2*RM_Size*2*tsm*x
  #break

  #case (2)  // close right pair
  #declare RM_LiftAmount = tsm*RM_HalfThickness;
    RM_RubiksMagic("+RmpRRURRRmp+U")
    transform {tr2}

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

  #case (3)
  #declare RM_LiftAmounts[0] = (1-2*tsm)*RM_HalfThickness;
  #declare RM_LiftAmounts[1] = tsm*RM_HalfThickness;
  #declare RM_LiftAmounts[2] = tsm*RM_HalfThickness;
    RM_RubiksMagic("+0Rmm +++2R ++2R +1Ump +1R ++2R +++2Rmm +0Uvp")
    transform {tr3}
    rotate 180*tsm*x
    translate -RM_HalfSize*tsm*z
  #break

  #case (4)
//
// partenza: Rmm R   R   Lmm R   R   Rmm Rvv
// meta':    Rm  Rm  Rv  Lmm Rv  Rm  Rm  R
// fine:     R   Rmm Rvv Lmm Rvv Rmm R   Rmm
//
  #declare RM_LiftAmounts[0] = RM_HalfThickness*(1-2*tsm);
  #declare RM_LiftAmounts[1] = RM_HalfThickness - 8*tsm*(1-tsm)*RM_HalfThickness;
  #if (RM_LiftAmounts[1] < 0)
    #declare RM_LiftAmounts[1] = 0;
  #end
  #declare RM_LiftAmounts[2] = RM_HalfThickness*(1-2*tsm);
  #declare RM_LiftAmounts[3] = RM_HalfThickness;
  #declare RM_Partials[0] = 2*tsm;
  #declare RM_Partials[1] = 2*(2*tsm-1);
    RM_RubiksMagic("-0RmQ0 +++1Rmp0 ++2Rvp0 +3Lmm +3Rvp0 ++2Rmp0 +++1RmQ0 -0Rmp1")
    transform {tr4}
    rotate 180*tsm*z
    translate 3*RM_HalfSize*tsm*x
  #break

// start:    R   Rmm Rvv Lmm Rvv Rmm R   Rmm
// middle:   R   Rmm Rvv Lmm Rv Rmm Rv  Rmm
// end:      R   Rmm Rvv Lmm R  Rmm Rvv Rmm

  #case (5)
  #declare RM_LiftAmounts[0] = RM_HalfThickness*(1 + 2*tsm);
  #declare RM_LiftAmounts[1] = RM_HalfThickness;
  #declare RM_LiftAmounts[2] = RM_HalfThickness*(2 - tsm);
  #declare RM_LiftAmounts[3] = RM_HalfThickness*(1 - 2*tsm);
  #declare RM_LiftAmounts[4] = RM_HalfThickness*(1 + 2*tsm);
  #declare RM_LiftAmounts[5] = RM_HalfThickness*(-2 + 5*tsm);
  #declare RM_LiftAmounts[6] = RM_HalfThickness*(3 - 4*tsm);
  #declare RM_LiftAmounts[7] = RM_HalfThickness*(1 - 2*tsm);
  #declare RM_Partials[0] = 2*tsm;
    RM_RubiksMagic("+0R +++1Rmm -2Rvv +3Lmm +4RvQ0 +5Rmm +6Rvp0 +7Rmm")
    transform {tr5}
  #break

  #case (6)
//
// partenza: R   Rmm Dvv Lmm R  Rmm Dvv Rmm
// meta':    R   Rmm Dv  Lmm R  Rmm Dv  Rmm
// arrivo:   R   Rmm D   Lmm R  Rmm D   Rmm
//
  #declare RM_LiftAmounts[0] = 0.5*RM_Thickness*(3-2*tsm);
  #declare RM_LiftAmounts[1] = 0.5*RM_Thickness*(2*tsm-1);
  #declare RM_Partials[0] = 2*tsm;
    RM_RubiksMagic("+0R +0Rmm +1DvQ0 +1Lmm +0R +0Rmm +1DvQ0 +1Rmm")
    transform {tr6}
    rotate 180*tsm*x
    translate 0.5*2*tsm*RM_Size*(x+2*z)
    translate 2*tsm*(2-2*tsm)*y*RM_Size
    translate -RM_HalfSize*tsm*(2*x+3*z)
  #break

//
// partenza: R   Rmm D   Lmm R  Rmm D   Rmm
// meta':    R   Rmm D   Lmm R  R   D   R  
// arrivo:   R   Rmm D   Lmm R  Rvv D   Rvv
//
  #case (7)
  #declare RM_LiftAmounts[0] = 0.5*RM_Thickness*(1-tsm);
  #declare RM_LiftAmounts[1] = 0.5*RM_Thickness*(1+tsm);
  #declare RM_LiftAmounts[2] = 0.5*RM_Thickness*(1-3*tsm);
  #declare RM_Partials[0] = 2*tsm-1;
    RM_RubiksMagic("+0R +0Rmm +1D +1Lmm +0R +0Rvvp0 +2D +2Rvvp0")
    transform {tr7}
  #break

//
// partenza: R   Dmm D   Lmm R  Uvv D   Rvv
// arrivo:   R   Dm  D   Lm  Rv Uv  Dv  Uv
//
  #case (8)
  #declare RM_LiftAmounts[0] = 2*RM_HalfThickness;
  #declare RM_Partials[0] = 0;
    RM_RubiksMagic("R Dmm +0D +0Lmm R Uvv -0D -0Uvv")
    transform {tr8}
    rotate -90*tsm*z
    rotate 180*tsm*y
    translate tsm*RM_Size*z
    translate -2*RM_HalfSize*tsm*z
  #break

//
// partenza: R   Dmm D   Lmm R  Uvv D   Rvv
// arrivo:   R   Dm  D   Lmm  R Uv  Dv  Uv
//
  #case (9)
  #declare RM_LiftAmounts[0] = RM_HalfThickness*(2-2*tsm);
  #declare RM_LiftAmounts[1] = RM_HalfThickness*(2-tsm);
  #declare RM_LiftAmounts[2] = RM_HalfThickness*tsm;
  #declare RM_Partials[0] = tsm;
    RM_RubiksMagic("R DmQ0 +1D +1Lmm +2R +2UvQ0 -0Dvp0 -0UvQ0")
    transform {tr9}
    translate RM_HalfSize*tsm*(z-x)
  #break

//
// partenza: R   Dm  D   Lmm  R Uv  Dv  Uv
// arrivo:   R   Dm  D   Lm  Rv Uv  Dv  Uv
//
  #case (10)
  #declare RM_LiftAmounts[0] = RM_HalfThickness*(1-tsm);
  #declare RM_Partials[0] = tsm;
    RM_RubiksMagic("R Dm +0D +0LmQ0 +0Rvp0 +0Uv Dv Uv")
    transform {tr10}
  #break

//
// partenza: R   Dm  D   Lm  Rv  Uv  Dv  Uv
// arrivo:   R   Dm  D   L   Rvv Uv  Dv  Uv
//
  #case (11)
  #declare RM_LiftAmounts[0] = 0.5*RM_Thickness*0.5*2*tsm;
  #declare RM_Partials[0] = 1 - 0.5*2*tsm;
    RM_RubiksMagic("R Dm D -0Lmp0 -0RvQ0 -0Uv Dv Uv")
    transform {tr11}
  #break

//
// partenza: R   Dm  D   L   Rvv Uv  Dv  Uv
// arrivo:   R   D   D   L   Rvv U   Dvv U
//
  #case (12)
  #declare RM_LiftAmounts[0] = 0.5*RM_Thickness*0.5*2*tsm;
  #declare RM_LiftAmounts[1] = 0.5*RM_Thickness*0.5*(2-2*tsm);
  #declare RM_LiftAmounts[2] = 0.5*RM_Thickness*0.5*(2+2*tsm);
  #declare RM_Partials[0] = 1 - 0.5*2*tsm;
    RM_RubiksMagic("--0R --0Dmp0 -0D -1L -1Rvv -2Uvp0 -0DvQ0 -0Uvp0")
    transform {tr12}
    translate RM_HalfSize*tsm*x
  #break

//
// partenza: R   D   D   L   Rvv U   Rvv U
// meta':    Rm  D   D   L   Rv  U   R   U
// arrivo:   Rmm D   D   L   R   U   Rmm U
//

  #case (13)
  #declare RM_LiftAmounts[0] = 0.5*RM_Thickness*0.5*(-4+6*2*tsm);
  #declare RM_LiftAmounts[1] = 0.5*RM_Thickness;
  #declare RM_LiftAmounts[2] = 0.5*RM_Thickness*0.5*(-2+2*2*tsm);
  #declare RM_LiftAmounts[3] = 0.5*RM_Thickness*0.5*(-2+4*2*tsm);
  #declare RM_Partials[0] = 2*tsm;
  #declare RM_Partials[1] = 2*(2*tsm - 1);
    RM_RubiksMagic("+0Rmp0 --1D -1D L RvQ0 ++2U +2Rmp1 +3U")
    transform {tr13}
    rotate -2*tsm*90*z
  #break

//
// partenza: Umm D   D   L   R   U   Rmm U
// meta':    Um  D   D   L   R   U   Rmm Uv
// arrivo:   U   D   D   L   R   U   Rmm Uvv
//

  #case (14)
  #declare RM_LiftAmounts[0] = RM_HalfThickness*(4 - 6*tsm); // ++++ -> --
  #declare RM_LiftAmounts[1] = RM_HalfThickness;             // +    -> +
  #declare RM_LiftAmounts[2] = RM_HalfThickness;             // +    -> +
  #declare RM_LiftAmounts[3] = RM_HalfThickness*(1 + tsm);   // +    -> ++
  #declare RM_LiftAmounts[4] = RM_HalfThickness*3*(1-tsm);   // +++  -> .
  #declare RM_Partials[0] = 2*tsm;
    RM_RubiksMagic("+0UmQ0 --1D -1D L R ++2U +3Rmm +4Uvp0")
    transform {tr14}
    rotate -2*tsm*90*y
    translate -2*RM_HalfSize*tsm*z
  #break

//
// partenza: U   D   D   L   R   U   Umm Uvv
// meta':    U   D   D   L   R   Uv  Um  Uvv
// arrivo:   U   D   D   L   R   Uvv U   Uvv
//

  #case (15)
  #declare RM_LiftAmounts[0] = RM_HalfThickness*(2 - tsm);         // ++ -> +
  #declare RM_LiftAmounts[1] = RM_HalfThickness;                   // +  -> +
  #declare RM_LiftAmounts[2] = RM_HalfThickness;                   // +  -> +
  #declare RM_LiftAmounts[3] = RM_HalfThickness*(2 - 3*2*tsm);     // ++ -> ----
  #declare RM_LiftAmounts[4] = RM_HalfThickness*(3*tsm);           // .  -> +++
  #declare RM_Partials[0] = 2*tsm;
    RM_RubiksMagic("-0U --1D -1D L R ++2Uvp0 +3UmQ0 -4Uvv")
    transform {tr15}
  #break

//
// partenza: U   D   D   L   R   Rvv U   Rvv
// meta':    U   D   D   L   R   Rv  U   Rv
// arrivo:   U   D   D   L   R   R   U   R 
//

  #case (16)
  #declare RM_LiftAmounts[0] = RM_HalfThickness;              // +   ->
  #declare RM_LiftAmounts[1] = RM_HalfThickness*(1 - tsm);    // +   -> .
  #declare RM_LiftAmounts[2] = RM_HalfThickness*tsm;          // .
  #declare RM_LiftAmounts[3] = RM_HalfThickness*(-4 + 5*tsm); // ----
  #declare RM_LiftAmounts[4] = RM_HalfThickness*(3 - 3*tsm);  // +++
  #declare RM_Partials[0] = 2*tsm;
    // RM_RubiksMagic("-0U --0D -0D +1L +2R ++0RvQ0 +3U -4RvQ0")
    RM_RubiksMagic("-0U --0D -0D L +2R ++0RvQ0 +3U -4RvQ0")
    transform {tr16}
    rotate -2*tsm*0.5*90*z
    translate -RM_HalfSize*tsm*x
  #break

  #case (17)
    RM_RubiksMagic("-U --D -D L +R ++R +U R")
    transform {tr17}
  #break

  #case (18)
    RM_RubiksMagic("-U --D -D L +R ++R +U R")
    transform {tr17}
  #break
#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
}
 */