// define FragmentLayer arguments
private var rectSize:int = 20;			// rectangle size
private var updateRate:int  = 30;		// update rate
private var dirVector:String  = "right";	// animation direction (from - to)
private var dispEvent:Boolean = true;		// dispatch event when animation has finished
private var startNow:Boolean = false;		// start immediately
 
private var overlay:FragmentLayer;
overlay = new FragmentLayer ( your_container, your_bitmap, rectSize, updateRate, dirVector, dispEvent, startNow);

// Constructor
public function FragmentLayer (container:DisplayObjectContainer, sourceBM:Bitmap,
				rectSize:uint, updateRate:uint = 30,
				dirVector:String = "right",
				dispEvent:Boolean = true, startNow = true)
{
	this.container = container;
	this.sourceBM = sourceBM;
	this.rectSize = rectSize;
	this.updateRate = updateRate;
	this.dirVector = dirVector;
	this.dispEvent = dispEvent;
	this.startNow = startNow;
 
	wLen = container.width / rectSize;
	hLen = container.height / rectSize;
	partArray = new Array();
 
	// if two times "true" then start immediately
	if ( initArea () && startNow ) 	startEffect();
}

// Init the rectangle area
public function initArea ():Boolean
{
	switch (dirVector)
	{
		case "left" :
				updateLeft();
				break;
		case "right" :
				updateRight();
				break;
		case "up" :
				updateUp();
				break;
		case "down" :
				updateDown();
				break;
		default :
				updateRight();	// call left as default
				break;
	}
	return true;
}

// particle movement right to left
private function updateRight ():void
{
	for (var i:uint = 0; i < wLen; i++)
	{
		for (var j:uint = 0; j < hLen; j++)
		{
			var xPos:int = (i * rectSize);
			var yPos:int = (j * rectSize);
 
			createRect (xPos, yPos);
		}
	}
}

// Fill the fragment pieces
private function createRect (xPos:Number, yPos:Number):void
{
	// count rectangles
	count++;
 
	// create rectangle with blue (default) Bitmap inside
	var cr:BitmapDataRectangle = new BitmapDataRectangle(rectSize);
 
	// target rectangle
	var rect:Rectangle = new Rectangle(0, 0, rectSize, rectSize);
 
	// target section of the source image
	var pt:Point = new Point(xPos, yPos);
	rect.x = pt.x;
	rect.y = pt.y;
 
	// copy BitmapData to Byte stream
	var bytes:ByteArray = sourceBM.bitmapData.getPixels(rect);
	bytes.position = 0;
 
	//destination rectangle
	var destRect:Rectangle = new Rectangle(0, 0, rectSize, rectSize);
 
	// write Byte stream to destination rectangle
	cr.getBmd.setPixels (destRect, bytes);
 
	// pass the CustomRectangle to the final create method
	createFragmentParticle (xPos, yPos, cr);
}

// Create a fragment particle an push it onto the array
private function createFragmentParticle (xPos:int, yPos:int, rect:BitmapDataRectangle):void
{
	// create the fragment rectangle
	particle = new ParticleObject( container, rect as Sprite, xPos, yPos);
// -> Play with these Parameters!
	// define velocity
	particle.setVel ( randRange(-20,20), randRange(-50,50) );
 
	// add drag
	particle.drag = 0.97;
 
	// set gravity
	particle.gravity = 0.3;
 
	// randomize particle size
	particle.clip.scaleX = particle.clip.scaleY = 1.0;
	// set shrink
	particle.shrink = randRange (0.5,1.03);
 
	// add fade
	particle.fade = 0.01;
 
	// particle clip starting alpha
	particle.clip.alpha = 1.0;
// -> ok stop
	// push particle onto Array
	partArray.push (particle);
}
 
// Calc a random range of particle movement
private function randRange (min:Number, max:Number):Number
{
	// e.g.: 5 - (-5) = 10;  10 + (-5)
	var randNum:Number = (Math.random() * (max - min )) + min;
	return randNum;
}

// Start the fragmentation effect
public function startEffect ():void
{
	this.addEventListener (Event.ENTER_FRAME, frameLoop);
}

// Effect has finished
private function effectEnd():void
{
	this.removeEventListener (Event.ENTER_FRAME, frameLoop);
	if (dispEvent)	dispatchEvent(new Event(EFFECT_DONE, true));
}

overlay.addEventListener (FragmentLayer.EFFECT_DONE, effectDoneHandler);
 
// FragmentLayer Effect Finished
private function effectDoneHandler (e:Event):void
{
	switch (e.currentTarget.name)
	{
		case "Overlay #1" :
			trace ("Effect done: " + e.currentTarget.name);
			// ...and again...
			init();
			break;
 
		case "Overlay #2" :
			trace ("Effect done: " + e.currentTarget.name);
			break;
	}
}

// Effect frame-loop
private function frameLoop (event:Event):void
{
	// increasing part of the array which has to be updated
	part2update += updateRate;
 
	// ...if this part is too long, correct it
	if (part2update > partArray.length)
	{
		part2update = partArray.length;
	}
 
	// loop through Array and update each one
	for (var i:uint = 0; i < part2update; i++)
	{
		partArray[i].update ();
 
		// remove invisible particle
		if (partArray[i].invisible == true)
		{
			removeParticle (i);
			part2update --;
			i--;
		}
	}
}

// Destroy a particle
private function removeParticle (val:uint):void
{
	var buffer:Array = partArray.splice (val, 1);
	particle = buffer.pop();
	particle.destroy ();
	if (partArray.length < 1)
	{
		effectEnd();
	}
}