Brisure Miroir + Animation

Le script de fonctions d'animation ANIM.JSX doit présent pour pouvoir exécuter ce script. 
 
/************************************************************************
                        ANIMATION
   Brisure
 ************************************************************************
 L'image de reference est brisee en morceaux a partir d'un centre.
 Chaque morceau est ensuite deplace vers l'exterieur (explosion lente).
 ************************************************************************
 L'image de reference doit etre dans le calque selectionn‚.
 La couleur de 1er plan est utilisee pour l'ombre des morceaux.
 La fenetre d'animation doit etre ouverte (et ne contenir normalement
 qu'une image qq).
 Le calque de reference sera deplace en premiere position, et les images
 seront creees devant.
 Pour sauver l'animation faire : Fichier > Sauver pour le Web
 ************************************************************************
 20/08/09 Habaki V1r01 : Creation
 ************************************************************************/
#include "anim.jsx" // Fonctions d'animation

var RulerUnits = app.preferences.rulerUnits;
app.preferences.rulerUnits = Units.PIXELS;

try{
  var PI = 3.14159;
  var PI2 = PI*2;
 
  var Doc = app.activeDocument;
  var Sel = Doc.selection;
  var docH = app.activeDocument.width.value;
  var docV = app.activeDocument.height.value;
 
  //------------------------------
  // Parametres
  //------------------------------
  var Layer0 = Doc.activeLayer; // Image de reference
  var INbMax = 10;  // Nombre d'images a creer
  var ImgTime0 = 1;  // Duree de l'image de reference (s)
  var ImgTime = 0.2;  // Duree des autres images (s)
  var Speed = 40;  // Vitesse de deplacement (pixels)
  var SpeedD = 8;  // Delta de vitesse
  var Rot = 0;  // Rotation (dgs)
  var AMax = 50;  // Angle max d'un morceau (dg)
  var AMin = 5 ;  // Angle min d'un morceau (dg)
  var Cx = docH/2; // Centre de brisure X
  var Cy = docV/2; // Centre de brisure Y
  //------------------------------
 
  var R  = Math.sqrt(docH*docH + docV*docV); // Rayon
  var Layer, Layer1, LayerNb, Nb;
  var Rand;
  var A, A0;   // Angles
  var Angles    = Array();
  var selRegion = Array(Array(Cx,Cy),
                        Array(1, 0),
                        Array(1, 1)
                        );
 
  // Deplace calque de reference au debut
  Layer0.move(Doc.artLayers[0], ElementPlacement.PLACEBEFORE);
 
  // Creation des morceaux
  A0 = 0.0;
  LayerNb = 0;
  while (A0 < PI2) {
    Rand = Math.random(); //1.0..0.0
    A = Rand * AMax;
    if (A < AMin) {A = AMin;}
    A *= PI / 180;
    if (A + A0 > PI2) {A = PI2 - A0;}
    Angles[LayerNb] = A0 + A/2;
   
    // Zone de selection d'un morceau
    selRegion[1][0] = Cx + R*Math.cos(A0);
    selRegion[1][1] = Cy -R*Math.sin(A0);
    selRegion[2][0] = Cx + R*Math.cos(A0+A);
    selRegion[2][1] = Cy -R*Math.sin(A0+A);
   
    // Layer : Morceau
    Layer = Layer0.duplicate();
    LayerNb++;
   
    // Layer1 : Ombre
    Layer1 = Doc.artLayers.add();
    Layer1.move(Layer, ElementPlacement.PLACEAFTER);
    app.activeDocument.activeLayer = Layer1;
    Sel.select(selRegion);
    Sel.fill(app.foregroundColor); // Couleur ombre
    Layer1.translate(25,25);  // Deplace ombre
    Layer1.opacity = 75;
   
    // Decoupe un morceau
    app.activeDocument.activeLayer = Layer;
    Sel.invert();
    Sel.clear();
    Sel.deselect();
   
    // Ombre floue
    Layer1.applyGaussianBlur(10.0); // after deselect
   
    // Fusionne Morceau et son ombre
    // REMARQUE: Certaines ombres vont se retrouver devant
    // d'autres morceaux au debut du deplacement, mais cela
    // donne un effet de choc initial a la brisure.
    // Sinon il faudrait deplacer separement morceaux et ombres.
    Layer.merge();
    A0 += A;
 
  } // while
 
  // Vitesse de deplacement
  Speed = (R/2.05 - SpeedD*INbMax*(INbMax-1)/2)/INbMax;
  //alert(LayerNb + " Pieces" + ", Speed = " + Speed);
 
  // Creation des images de l'animation
  for (INb=1;INb <= INbMax; INb++) {
    // Deplace morceaux
    for (i=0;i < LayerNb;i++) {
      Doc.artLayers[i].translate( Speed*Math.cos(Angles[i]),
                                 -Speed*Math.sin(Angles[i])
                                 );
      if (Rot)
        Doc.artLayers[i].rotate( Rot*(1.0 - Math.random()));
    } // for
    // Augmente vitesse : meilleur effet
    Speed += SpeedD;
   
    // Fusionne les copies des morceaux d'une image
    Layer = Doc.artLayers[LayerNb-1];
    Layer1 = Layer.duplicate();
    Layer1.move(Layer, ElementPlacement.PLACEAFTER);
    Layer1.name = "Image" + INb;
    for (i=LayerNb-2;i >= 0;i--) {
      Layer = Doc.artLayers[i].duplicate();
      Layer.move(Layer1, ElementPlacement.PLACEBEFORE);
      Layer.merge();
    } // for
  } // for
 
  // Destruction des morceaux
  for (i=LayerNb-1; i>=0; i--) {
    Doc.artLayers[i].remove();
  } // for
 
  // Creation animation
  // Chaque image: Image de reference + Image de deplacement
  for (INb=1;INb <= INbMax; INb++) {
   
    if (INb==1) {
      animation_ImageSelect(1); // Deja presente
    } else {
      animation_ImageNew(0);
    }
    animation_ImageTimeSet(0, ImgTime);
    for (i=1;i <= INbMax; i++) {
      animation_LayerShow(0, Layer0.name, true);
      animation_LayerShow(0, "Image" + i, (i==INb ? true : false));
    } // for
  } // for
 
  // En dernier l'image de reference seule
  animation_ImageNew(0);
  animation_ImageTimeSet(0, ImgTime0);
  for (i=1;i <= INbMax; i++) {
    animation_LayerShow(0, Layer0.name, true);
    animation_LayerShow(0, "Image" + i, false);
  } // for
 
} catch(ex) {
 alert(ex.message);
}
app.preferences.rulerUnits = RulerUnits;