альтеранатива TransitionManager

badun · 06.03.2008, 02:57

Классу Tween существует множество альтернатив, а вот альтернативы TransitionManager не нашел. Может кто-нибудь знает подобные в свободном доступе? Или дополнительные типы переходных эффектов, кроме стандартных Blinds, Fly и.т.д?

etc · 06.03.2008, 09:39

В чем проблема переписать на AS3 с AS2?

wvxvw · 06.03.2008, 09:52

Лучше тот, что есть в АС2 не переписывать... он дурацкий и неудобный...
Транзишенов у меня есть штук 5 + немного переделанных стандартных, но для АС2, есси надо выложу, но они не менее "кривые" %) так что прийдется "доработать напильником" %)

badun · 06.03.2008, 14:11

Цитата:

Сообщение от __etc

В чем проблема переписать на AS3 с AS2?

не понял мысль )), зачем переписывать если он там есть?

Цитата:

Сообщение от wvxvw

Лучше тот, что есть в АС2 не переписывать... он дурацкий и неудобный...
Транзишенов у меня есть штук 5 + немного переделанных стандартных, но для АС2, есси надо выложу, но они не менее "кривые" %) так что прийдется "доработать напильником" %)

было бы здорово, в любом случае пригодится ))

wvxvw · 06.03.2008, 15:22

Код:

import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Rectangle;
import mx.transitions.Transition;
import mx.transitions.TransitionManager;
import flash.display.BitmapData;
//
class mx.transitions.BitmapDissolve extends Transition {
	
	public var type:Object = BitmapDissolve;
	public var className:String = "BitmapDissolve";
	
	private var __tgt:MovieClip;
	private var __seed:Number = 0;
	private var __bmp:BitmapData;
	private var __msk:MovieClip;
	private var __dissolvedPixels:Number;
	
	function BitmapDissolve(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.__bmp = new BitmapData(content._width, content._height, true, 0x00ffffff);
		this.__bmp.draw(content);
		this.__seed = transParams.seed || 10;
		this.__dissolvedPixels = Math.floor(content._width * content._height);
		this.__msk = content._parent.createEmptyMovieClip('BitmapDissolve_mask', content._parent.getNextHighestDepth());
		var mtx:Matrix = content.transform.matrix.clone();
		this.__msk.transform.matrix = mtx;
		this.__msk.attachBitmap(this.__bmp, 0);
		content._visible = false;
	}
	private function _render(p:Number):Void {
		if(content._visible) content._visible = false;
		this.__bmp.pixelDissolve(this.__bmp, new Rectangle(0, 0, this.__bmp.width, this.__bmp.height), new Point(0, 0), 10, this.__dissolvedPixels*p, 0);
	}
	public function cleanUp():Void {
		content._visible = true;
		super.cleanUp();
		this.__msk.removeMovieClip();
		this.__bmp.dispose();
	}
	public function toString():String {
		return "[BitmapDissolve Transition]";
	}
}

Это сперто у Silin"а, ну, ноя доделка была только в том, чтобы можно было как и остальные транзишены запускать

Код:

import mx.transitions.Transition;
import mx.transitions.TransitionManager;

class mx.transitions.Iris extends Transition {


	public static var SQUARE:String = "SQUARE";
	public static var CIRCLE:String = "CIRCLE";
	public static var HEART:String = "HEART";
	public static var STAR:String = "STAR";

	public var type:Object = Iris;
	public var className:String = "Iris";
	
	private var _mask:MovieClip;
	private var _startPoint:Number = 5;
	private var _cornerMode:Boolean;
	private var _shape:String = "CIRCLE";
	private var _rays:Number = 5;
	private var _maxDimension:Number;
	private var _minDimension:Number;
	private var _renderShape:Function;

	function Iris (content:MovieClip, transParams:Object, manager:TransitionManager) {
		this.init (content, transParams, manager);
	};
	
	function init (content:MovieClip, transParams:Object, manager:TransitionManager):Void {
		//trace ("Iris.init()");
		super.init (content, transParams, manager);
		if (transParams.startPoint) {this._startPoint = transParams.startPoint};
		if(transParams.shape.length) this._shape = transParams.shape;
		if(!isNaN(transParams.rays)) this._rays = transParams.rays;
		this._maxDimension = Math.max (this._width, this._height);
		this._minDimension = Math.min (this._width, this._height);
		
		
		// if _startPoint is an odd number, it's a corner
		if (this._startPoint % 2) {
			this._cornerMode = true;
		}
		// assign the render function dynamically based on shape choice
		if (this._shape == "SQUARE") {
			if (this._cornerMode) {
				this._render = this._renderSquareCorner;
			} else {
				this._render = this._renderSquareEdge;
			}
		} else if (this._shape == "CIRCLE") {
			this._render = this._renderCircle;
		} else if (this._shape == "HEART"){
			this._render = this._renderHeart;
		} else if (this._shape == "STAR"){
			this._render = this._renderStar;
		}

		this._initMask();
	};

	function start ():Void {
		this._content.setMask (this._mask);
		super.start();
	}
	
	function cleanUp ():Void {
		this._mask.removeMovieClip();
		super.cleanUp();
	}

	
	private function _initMask ():Void {
		var container:MovieClip = this._content;
		var depth:Number = this.getNextHighestDepthMC (container);
		
		var mask:MovieClip = this._mask = container.createEmptyMovieClip ("__mask_Iris_"+this.direction, depth);
		//mask._alpha = 30;
		mask._visible = false;
		var ib:Object = this._innerBounds;
		
		switch (this._startPoint) {
			case 1:
			// top left
				mask._x = ib.xMin;
				mask._y = ib.yMin;
				break;
			case 4: 
			// left
				mask._x = ib.xMin;
				mask._y = (ib.yMin + ib.yMax) * .5;
				break;
			case 3:
			// top right
				mask._rotation = 90;
				mask._x = ib.xMax;
				mask._y = ib.yMin;
				break;
			case 2:
			// top center
				mask._rotation = 90;
				mask._x = (ib.xMin + ib.xMax) * .5;
				mask._y = ib.yMin;
				break;
			case 9:
			// bottom right
				mask._rotation = 180;
				mask._x = ib.xMax;
				mask._y = ib.yMax;
				break;
			case 6: 
			// right
				mask._rotation = 180;
				mask._x = ib.xMax;
				mask._y = (ib.yMin + ib.yMax) * .5;
				break;
			case 7:
			// bottom left
				mask._rotation = -90;
				mask._x = ib.xMin;
				mask._y = ib.yMax;
				break;
			case 8: 
			// bottom center
				mask._rotation = -90;
				mask._x = (ib.xMin + ib.xMax) * .5;
				mask._y = ib.yMax;
				break;
			case 5:
			// center
				mask._x = (ib.xMin + ib.xMax) * .5;
				mask._y = (ib.yMin + ib.yMax) * .5;
				break;
			default:
				break;
		}
	}

	// stub--dynamically overwritten by one of the other render methods 
	private function _render (p:Number):Void {}
	

	private function _renderCircle (p:Number):Void {
		var mask:MovieClip = this._mask;
		var maxRadius:Number;
		mask.clear();
		mask.beginFill (0xFF0000);
		
		if (this._startPoint == 5) {
			// iris from center
			maxRadius = .5 * Math.sqrt (this._width*this._width + this._height*this._height);
			this.drawCircle (mask, 0, 0, p*maxRadius);
		} else {
			if (this._cornerMode) {
				// iris from corner
				maxRadius = Math.sqrt (this._width*this._width + this._height*this._height);
				this._drawQuarterCircle (mask, p*maxRadius);
			} else {
				// iris from edge
				if (this._startPoint == 4 || this._startPoint == 6) {
					// half-circle from left or right edge
					maxRadius = Math.sqrt (this._width*this._width + .25*this._height*this._height);
				} else if (this._startPoint == 2 || this._startPoint == 8) {
					// half-circle from top or bottom edge
					maxRadius = Math.sqrt (.25*this._width*this._width + this._height*this._height);
				}
				this._drawHalfCircle (mask, p*maxRadius);  
			}
		}
		mask.endFill();
	}

	private function _drawQuarterCircle (mc:MovieClip, r:Number):Void {
		var x=0, y=0;
		mc.lineTo (r, 0);
		mc.curveTo (r+x, Math.tan(Math.PI/8)*r+y, Math.sin(Math.PI/4)*r+x, Math.sin(Math.PI/4)*r+y);
		mc.curveTo (Math.tan(Math.PI/8)*r+x, r+y, x, r+y);
	}
	
	private function _drawHalfCircle (mc:MovieClip, r:Number):Void {
		var x=0, y=0;
		mc.lineTo (0, -r);
		mc.curveTo (Math.tan(Math.PI/8)*r+x, -r+y, Math.sin(Math.PI/4)*r+x, -Math.sin(Math.PI/4)*r+y);
		mc.curveTo (r+x, -Math.tan(Math.PI/8)*r+y, r+x, y);
		mc.curveTo (r+x, Math.tan(Math.PI/8)*r+y, Math.sin(Math.PI/4)*r+x, Math.sin(Math.PI/4)*r+y);
		mc.curveTo (Math.tan(Math.PI/8)*r+x, r+y, x, r+y);
		mc.lineTo (0, 0);
	}
	
	//this._maxDimension = Math.max (this._width, this._height);
	
	private function _renderSquareEdge (p:Number):Void {
		var mask = this._mask;
		mask.clear();
		mask.beginFill (0xFF0000);
		var s = this._startPoint;
		var w = p*this._width;
		var h = p*this._height;
		var z = p*this._maxDimension;
		if(s == 4 || s == 6){
			this.drawBox (mask, 0, -.5*h, w, h);
		}else if(this._height < this._width){
		  	this.drawBox (mask, 0, -.5*z, h, w); 
		}else{
		  	this.drawBox (mask, 0, -.5*z, z, z);
		}
		mask.endFill();
	}
	
	private function _renderHeart(p:Number):Void {
		var d:Number = Math.min(this._width,this._height)*p;
		var k:Number = -d/2;
		var mask = this._mask;
		mask.clear();
		mask.beginFill (0xFF0000);
		mask.moveTo(k,k+d/4);
		mask.curveTo(k,k,k+d/4,k);
		mask.curveTo(k+d/2,k,k+d/2,k+d/4);
		mask.curveTo(k+d/2,k,k+d*3/4,k);
		mask.curveTo(k+d,k,k+d,k+d/4);
		mask.curveTo(k+d,k+d/2,k+d*3/4,k+d*3/4);
		mask.lineTo(k+d/2,k+d);
		mask.lineTo(k+d/4,k+d*3/4);
		mask.curveTo(k,k+d/2,k,k+d/4);
		mask.endFill();
	}
	
	private function _renderStar(p:Number):Void {
		var d:Number = Math.min(this._width,this._height)*p;
		var s:Number = Math.PI*2/this._rays;
		var mask = this._mask;
		mask.clear();
		mask.beginFill(0xFF0000);
		mask.moveTo(0,d/2);
		for(var i:Number=0; i<this._rays; i++){
			mask.lineTo(d*.5*Math.sin(s*i),d*.5*Math.cos(s*i));
			mask.lineTo(d*Math.sin(s*(i+.5)),d*Math.cos(s*(i+.5)));
		}
		mask.endFill();
	}
	
	private function _renderSquareCorner (p:Number):Void {
		var mask = this._mask;
		mask.clear();
		mask.beginFill (0xFF0000);
		var s = this._startPoint;
		var w = p*this._width;
		var h = p*this._height;
		if (s == 5) {
			this.drawBox (mask, -.5*w, -.5*h, w, h);
		}else if(s == 3 || s == 7){
			this.drawBox (mask, 0, 0, h, w);
		} else {
			this.drawBox (mask, 0, 0, w, h);
		}
		mask.endFill();
	}
}

Это переделка стандартной (+ форма сердечка и звездочки с задаваемым кол-вом лучей)

wvxvw · 06.03.2008, 15:26

Код:

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"а

wvxvw · 06.03.2008, 15:34

Код:

import mx.transitions.Transition;
import mx.transitions.TransitionManager;
import flash.filters.ColorMatrixFilter;
class mx.transitions.Sepia extends Transition {
	public var type:Object = Sepia;
	public var className:String = "Sepia";
	private var myColorMatrix_filter:ColorMatrixFilter;
	private var __tgt:MovieClip;
	private var __tint:Number = 0x000000;
	private var __to:Object = {};
	function Sepia(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.myColorMatrix_filter = new ColorMatrixFilter();
		this.__tgt = content;
		this.__tint = transParams.tint;
		this.__to = toRGB(this.__tint);
	}
	private function _render(p:Number):Void {
		var rc:Number = 0.3086;
		var gc:Number = 0.6094;
		var bc:Number = 0.0820;
		var myElements_array:Array = [1-p*(1-rc)+this.__to._r*p, p*gc, p*bc, 0, 0, 
									   p*rc, 1-p*(1-gc)+this.__to._g*p, p*bc, 0, 0, 
									   p*rc, p*gc, 1-p*(1-bc)+this.__to._b*p, 0, 0, 
									   0, 0, 0, 1, 0];
		this.myColorMatrix_filter = new ColorMatrixFilter(myElements_array);
		this.__tgt.filters = [myColorMatrix_filter];
	}
	private function toRGB(_num:Number):Object {
		var c_obj:Object = {_r:((_num >> 16) & 0xff)/255, _g:((_num >> 8) & 0xff)/255, _b:(_num & 0xff)/255};
		return c_obj;
	}
	public function toString():String {
		return "[Sepia Transition]";
	}
}

Древность какая-то, ну так, для коллекции

Код:

import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Rectangle;
import mx.transitions.Transition;
import mx.transitions.TransitionManager;
import flash.display.BitmapData;
import flash.filters.DisplacementMapFilter;
//
class mx.transitions.Wobble extends Transition {
	
	public var type:Object = Wobble;
	public var className:String = "Wobble";
	
	private var __tgt:MovieClip;
	private var __seed:Number = 0;
	private var __bmp:BitmapData;
	private var __acceleration:Number = 10;
	private var __msk:MovieClip;
	private var __flt:DisplacementMapFilter;
	
	function Wobble (content:MovieClip, transParams:Object, manager:TransitionManager) {
		this.init(content, transParams, manager);
	}
	function init(content:MovieClip, transParams:Object, manager:TransitionManager):Void {
		trace('started');
		super.init(content, transParams, manager);
		this.__tgt = content;
		this.__bmp = new BitmapData(content._width, content._height, true, 0x00ffffff);
		this.__bmp.perlinNoise(0, 10, 1, Math.floor(Math.random()*100), false, true, 1, true, null);
	}
	private function _render(p:Number):Void {
		this.__seed += this.__acceleration;
		if (this.__seed > this.__bmp.width/4 || this.__seed < -this.__bmp.width/4) {
			this.__acceleration*=-1;
		}
		var p0:Point = new Point(Math.floor((content._width - this.__bmp.width) / 2), -p);
		var scale:Number=this.__seed*p;
		var displMap = new DisplacementMapFilter(this.__bmp, p0, 1, 0, scale, 0, "wrap");
		content.filters=[displMap];
	}
	public function toString():String {
		return "[Wobble Transition]";
	}
}

И снова Silin %)

Код:

import mx.transitions.Transition;
import mx.transitions.TransitionManager;
import mx.transitions.rendering.*;
import mx.transitions.easing.Strong;

class mx.transitions.StainedGlass extends Transition {
	public var type:Object = StainedGlass;
	public var className:String = "StainedGlass";
	
	private var __map:Map;
	
	function StainedGlass(content:MovieClip, transParams:Object, manager:TransitionManager) {
		this.init(content, transParams, manager);
	}
	function init(content:MovieClip, transParams:Object, manager:TransitionManager):Void {
		transParams.easing = Strong.easeIn;
		super.init(content, transParams, manager);
		super.TWN.FPS = 12;
		this.__map = new Map(content, content._width, content._height);
	}
	private function _render(p:Number):Void {
		this.__map.__draw(p);
		if (content._visible) {
			content._visible = false;
		}
	}
	public function cleanUp():Void {
		this.content._visible = true;
		super.cleanUp();
		this.__map.__remove();
	}
	
	public function toString():String {
		return "[StainedGlass Transition]";
	}
}

Это безумная попытка сделать анимированый фильтр типа stained glass... дико тормозная, так и оставил недоделав =( Но мало ли... мож какие идеи будут
rendering.zip В аттаче нужные ей классы

wvxvw · 06.03.2008, 15:38

ЗЫ. Сорри за вынужденный мультипостинг, просто есть ограничение на количество знаков %)

ЗЫЫ.

Код:

super.TWN.FPS = 12;

Это небольшая модификация которую я сделал в классе Transition, чтобы можно было из наследника управлять свойствами твина, который будет играть анимацию.

ЗЫЫЫ. Есть жеж пакет fl.transitions, там вроде и менеджер ест...

badun · 06.03.2008, 16:10

Большое спасибо!