[wvxvw]

import flash.geom.Matrix;
import mx.transitions.Transition;
import mx.transitions.TransitionManager;
import flash.display.BitmapData;
//
class mx.transitions.PixelRotate extends Transition {

	public var type:Object = PixelRotate;
	public var className:String = "PixelRotate";

	private var _cellW:Number = 5;
	private var _cellH:Number = 5;
	private var __w:Number;
	private var __h:Number;
	private var __x:Number;
	private var __y:Number;
	private var __d:Number;
	private var __mtx:Matrix;
	private var __betha:Number;
	private var _mask:MovieClip;
	private var _bmp_arr:Array = [];
	private var _flt_arr:Array = [];
	
	function PixelRotate (content:MovieClip, transParams:Object, manager:TransitionManager) {
		this.init (content, transParams, manager);
	};

	function init (content:MovieClip, transParams:Object, manager:TransitionManager):Void {
		super.init (content, transParams, manager);
		this._cellW = transParams.xSections || 5;
		this._cellH = transParams.ySections || 5;
		this.__mtx = content.transform.matrix.clone();
		var last_rot:Number = content._rotation;
		content._rotation = 0;
		this._flt_arr = content.filters;
		this.__w = Math.ceil(content._width*100/content._xscale);
		this.__h = Math.ceil(content._height * 100 / content._yscale);
		content._rotation = last_rot;
		this.__x = Math.floor(this.__w / this._cellW);
		this.__y = Math.floor(this.__h / this._cellH);
		this.__d = Math.sqrt(this.__x*this.__x + this.__y*this.__y) / 2;
		this.__betha = Math.atan(this.__x / this.__y);
		_bmp_arr = [];
		for (var i:Number = Math.floor(this.__x/2); i <= this.__w; i += this.__x) {
			this._bmp_arr.push([]);
			for (var j:Number = Math.floor(this.__y / 2); j <= this.__h; j += this.__y) {
				var bmpd:BitmapData = new BitmapData(this.__x, this.__y);
				var mtx:Matrix = new Matrix(); 
				mtx.translate(this.__x / 2 - i, this.__y / 2 - j);
				bmpd.draw(content, mtx);
				this._bmp_arr[this._bmp_arr.length-1].push(bmpd);
			}
		}
	};
	
	private function _render (p:Number):Void {
		if (!this._mask) {
			this._mask = content._parent.createEmptyMovieClip('_PixelRotateMask', content._parent.getNextHighestDepth());
			var mtx:Matrix = this.__mtx.clone();
			_mask.transform.matrix = mtx;
			_mask.filters = this._flt_arr;
			content._visible = false;
			//content._alpha = 50;
		}
		//
		this._mask.clear();
		var ii:Number = 0;
		var jj:Number = 0;
		for (var i:Number = Math.floor(this.__x / 2); i <= this.__w; i += this.__x, ii++) {
			jj = 0;
			for (var j:Number = Math.floor(this.__y / 2); j <= this.__h; j += this.__y, jj++) {
				var mtx:Matrix = new Matrix(); 
				mtx.translate(this.__x / 2 - i, this.__y / 2 - j);
				this._bmp_arr[ii][jj].draw(content, mtx);
				this._drawRotatedRectangle(this._mask, i, j, this.__d*p, Math.PI*2*p, ii, jj, p);
			}
		}
	};
	
	private function _drawRotatedRectangle(mc:MovieClip, x:Number, y:Number, d:Number, r:Number, i:Number, j:Number, p:Number):Void {
		var mtx:Matrix = new Matrix();
		mtx.rotate(Math.PI * 2 - r);
		mtx.scale(p, p);
		mtx.translate(x - d * Math.sin(r - this.__betha), y - d * Math.cos(r - this.__betha));
		//mc.lineStyle(1, 0xff, 100);
		mc.beginBitmapFill(this._bmp_arr[i][j], mtx);
		mc.moveTo(x - d * Math.sin(r - this.__betha), y - d * Math.cos(r - this.__betha));
		mc.lineTo(x - d * Math.sin(r + this.__betha), y - d * Math.cos(r + this.__betha));
		mc.lineTo(x - d * Math.sin(r + Math.PI - this.__betha), y - d * Math.cos(r + Math.PI - this.__betha));
		mc.lineTo(x - d * Math.sin(r + Math.PI + this.__betha), y - d * Math.cos(r + Math.PI + this.__betha));
		mc.endFill();
	}
	
	function cleanUp ():Void {
		super.cleanUp();
		for (var i:Number = 0; i < this._bmp_arr.length; i++) {
			for (var j:Number = 0; j < this._bmp_arr[i].length; j++) {
				this._bmp_arr[i][j].dispose();
			}
		}
		_bmp_arr = [];
		this._mask.removeMovieClip();
		content._visible = true;
	};
}

Тут вроде картинка режется на клеточки и они потом крутятся...

import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.geom.ColorTransform;
import mx.transitions.Transition;
import mx.transitions.TransitionManager;
import flash.display.BitmapData;
import flash.filters.DisplacementMapFilter;
import flash.filters.BitmapFilter;
import flash.filters.ConvolutionFilter;
//
class mx.transitions.Ripple extends Transition {
	
	public var type:Object = Ripple;
	public var className:String = "Ripple";
	
	private var __tgt:MovieClip;
	private var __msk:MovieClip;
	
	private var __bmp:BitmapData;
	private var __obmp:BitmapData;
	private var __rbmp1:BitmapData;
	private var __rbmp2:BitmapData;
	private var __map:BitmapData;
	private var __buf:BitmapData;
	
	private var __water:DisplacementMapFilter;
	private var __wave:BitmapFilter;
	private var __damp:ColorTransform;
	
	private var __double:Matrix;
	private var __identity:Matrix;
	private var __origin:Point;
	private var __full:Rectangle;
	private var __quarter:Rectangle;
	
	private var __h:Number = Number.NaN;
	private var __w:Number = Number.NaN;
	private var __h2:Number = Number.NaN;
	private var __w2:Number = Number.NaN;
	
	function Ripple (content:MovieClip, transParams:Object, manager:TransitionManager) {
		this.init(content, transParams, manager);
	}
	function init(content:MovieClip, transParams:Object, manager:TransitionManager):Void {
		super.init(content, transParams, manager);
		this.__tgt = content;
		this.__w = content._width;
		this.__h = content._height;
		this.__w2 = this.__w/2;
		this.__h2 = this.__h/2;
		this.__bmp = new BitmapData(this.__w, this.__h);
		this.__bmp.draw(content);
		this.__obmp = new BitmapData(this.__w, this.__h, false, 128);
		this.__rbmp1 = new BitmapData (this.__w2, this.__h2, false, 128);
		this.__rbmp2 = new BitmapData (this.__w, this.__h, false, 128);
		this.__map = new BitmapData (this.__w2, this.__h2, false, 128);
		this.__buf = new BitmapData (this.__w2, this.__h2, false, 128);
		
		this.__wave = BitmapFilter(new ConvolutionFilter (3, 3, [1,1,1,1,1,1,1,1,1], 9, 0));
		this.__damp = new ColorTransform (0, 0, 0.99609374, 1, 0, 0, 2, 0);
		this.__origin = new Point ();
		this.__water = new DisplacementMapFilter (this.__rbmp2, this.__origin, 4, 4, 32, 32, "ignore");
		this.__quarter = new Rectangle (0, 0, this.__w2, this.__h2);
		this.__full = new Rectangle (0, 0, this.__w, this.__h);
		this.__identity = new Matrix ();
		this.__double = new Matrix ();
		this.__double.a = this.__double.d = 2;
		
		this.__msk = content._parent.createEmptyMovieClip('Ripple_mask', content._parent.getNextHighestDepth());
		this.__msk.attachBitmap(this.__obmp, 0);
		this.__msk.transform.matrix = content.transform.matrix.clone();
		content._visible = false;
	}
	private function _render(p:Number):Void {
		this.__rbmp1.applyFilter(this.__map, this.__quarter, this.__origin, this.__wave);
		this.__rbmp1.draw (this.__rbmp1, this.__identity, null, "add");
		this.__rbmp1.draw (this.__buf, this.__identity, null, "difference");
		this.__rbmp1.draw (this.__rbmp1, this.__identity, this.__damp);
		this.__rbmp2.draw (this.__rbmp1, this.__double, null, null, null, true);
		this.__obmp.applyFilter(this.__bmp, this.__full, this.__origin, BitmapFilter(this.__water));
		this.__buf = this.__map;
		this.__map = this.__rbmp1.clone ();
		
		for (var i = 0; i < p; i += .02) {
			this.__wobbleXY(1 + Math.floor(Math.random()*(this.__w - 1)), 1 + Math.floor(Math.random()*(this.__h - 1)));
		}
	}
	private function __wobbleXY(x:Number, y:Number):Void {
		x /= 2;
		y /= 2;
		this.__map.setPixel (x + 1, y, 0xFFFFFF);
		this.__map.setPixel (x - 1, y, 0xFFFFFF);
		this.__map.setPixel (x, y + 1, 0xFFFFFF);
		this.__map.setPixel (x, y - 1, 0xFFFFFF);
		this.__map.setPixel (x, y, 0xFFFFFF);
	}
	public function cleanUp():Void {
		super.cleanUp();
		__msk.removeMovieClip();
		__bmp.dispose();
		__obmp.dispose();
		__rbmp1.dispose();
		__rbmp2.dispose();
		__map.dispose();
		__buf.dispose();
	}
	public function toString():String {
		return "[Ripple Transition]";
	}
}

Опять же, сперто у Silin"а