AS3 倒影效果(反射效果)

private function getReflection(target:DisplayObject,height:Number = -1):BitmapData{
         if(height<0)height = target.height;
	 var bit:BitmapData = new BitmapData(target.width,height,true,0);
         bit.draw(target,new Matrix(1,0,0,-1,0,target.height));
         var mtx:Matrix = new Matrix();
         mtx.createGradientBox(target.width,height,0.5 * Math.PI);
         var shape:Shape = new Shape();
         shape.graphics.beginGradientFill(GradientType.LINEAR,[0,0],[0.5,0],[0,255],mtx);
	 shape.graphics.drawRect(0,0,target.width,height);
         shape.graphics.endFill();
         var alpha:BitmapData = new BitmapData(target.width,height,true,0);
         alpha.draw(shape);
         bit.copyPixels(bit,bit.rect,new Point(0,0),alpha,new Point(0,0),false);
         return bit.clone()
}

//应用一例 
var reflection:Bitmap = new Bitmap(getReflection(target,100));
 reflection.x = target.x;
 reflection.y = target.y + target.height;
 addChild(reflection);


还有个更好的:

package com.flashdev.bitmap {
        
        /*
                        
        Written by:
        Dustin Andrew
        dustin@flash-dev.com
        www.flash-dev.com
        
        LAST UPDATED:
        01/24/06
        
        Reflection.as
        
        Create a bitmap reflection of a displayobject        
                        
        */
        
        import flash.display.*;
        import flash.geom.*;
        import flash.events.*;

        public class Reflection extends Sprite {
                
                private var _disTarget:DisplayObject;
                private var _numStartFade:Number = .3;
                private var _numMidLoc:Number = .5;
                private var _numEndFade:Number = 0;
                private var _numSkewX:Number = 0;
                private var _numScale:Number = 1;                
                private var _bmpReflect:Bitmap;
                
                // Constructor
                public function Reflection(set_disTarget:DisplayObject, set_numStartFade:Number, set_numMidLoc:Number, set_numEndFade:Number, set_numSkewX:Number, set_numScale:Number) {
                        super()
                        _disTarget = set_disTarget;
                        _numStartFade = set_numStartFade;
                        _numMidLoc = set_numMidLoc;
                        _numEndFade = set_numEndFade;
                        _numSkewX = set_numSkewX;
                        _numScale = set_numScale;
                        
                        _bmpReflect = new Bitmap(new BitmapData(1, 1, true, 0));
                        this.addChild(_bmpReflect);
                        createReflection();
                }
                
                // Create reflection
                private function createReflection(event:Event = null):void {
                        
                        // Reflection
            var bmpDraw:BitmapData = new BitmapData(_disTarget.width, _disTarget.height, true, 0);
            var matSkew:Matrix = new Matrix(1, 0, _numSkewX, -1 * _numScale, 0, _disTarget.height);
            var recDraw:Rectangle = new Rectangle(0, 0, _disTarget.width, _disTarget.height * (2 - _numScale));
            var potSkew:Point = matSkew.transformPoint(new Point(0, _disTarget.height));
            matSkew.tx = potSkew.x * -1;
            matSkew.ty = (potSkew.y - _disTarget.height) * -1;
            bmpDraw.draw(_disTarget, matSkew, null, null, recDraw, true);
            
            // Fade
            var shpDraw:Shape = new Shape();
            var matGrad:Matrix = new Matrix();
            var arrAlpha:Array = new Array(_numStartFade, (_numStartFade - _numEndFade) / 2, _numEndFade);
            var arrMatrix:Array = new Array(0, 0xFF * _numMidLoc, 0xFF);
            matGrad.createGradientBox(_disTarget.width, _disTarget.height, 0.5 * Math.PI);
            shpDraw.graphics.beginGradientFill(GradientType.LINEAR, new Array(0,0,0), arrAlpha, arrMatrix, matGrad)
            shpDraw.graphics.drawRect(0, 0, _disTarget.width, _disTarget.height);
            shpDraw.graphics.endFill();
            bmpDraw.draw(shpDraw, null, null, BlendMode.ALPHA);
            
            _bmpReflect.bitmapData.dispose();
            _bmpReflect.bitmapData = bmpDraw;
            
            _bmpReflect.filters = _disTarget.filters;
            
            this.x = _disTarget.x;
            this.y = (_disTarget.y + _disTarget.height) - 1;          
                }
        }
}

package {
        import flash.display.*;
        import flash.geom.Matrix;
        import flash.geom.Rectangle;
        /**
             * 用于倒影一个图像的类. 
             * @author user
             * 
             */
        public class UpendImage extends Sprite {
                /**
                         * 构造函数 
                         * @param bitmapData 可以是显示对象或bitmapdata
                         * @param length 想要倒影的长度
                         * 
                         */
                public function UpendImage(bitmapData:*=null,length:Number=-1) {
                        super();
                        init();
                        if (bitmapData) {
                                this.length=length;
                                this.bitmapData=bitmapData;
                        }
                }
                private var _mask:Shape;
                private function init():void {
                        _mask=new Shape  ;
                        _mask.cacheAsBitmap=true;
                        addChild(_mask);
                        _mask.visible=false;
                        draw();
                }
                private var _distance:Number=-1;
                /**
                         * 因为length被用于动态使用了,所以,
                         * 这个是偷偷设置倒影长度的,用于在一张图片要抛弃换另一张时的时间使用,先设置distance,然后bitmapData=xxx. 
                         * @return 
                         * 
                         */
                public function get distance():Number {
                        return _distance;
                }
                public function set distance(value:Number):void {
                        _distance=value;
                        _length=value;
                        if (_bitmapData) {
                                bitmapData=_bitmapData.clone();
                        }
                }
                private var _length:Number=-1;
                /**
                         * 想要倒影的长度. 这个是给一个图片已经倒影了,然后可以动态拖放倒影长度的.
                         * @return 
                         * 
                         */
                public function get length():Number {
                        return _length;
                }
                public function set length(value:Number):void {
                        _length=value;
                        if (_bitmapData) {
                                _length=value > _bitmapData.height || _length < 0?_bitmapData.height:value;
                                _mask.height=value;
                        }
                }
                private var _bitmapData:BitmapData;

                private var _bm:Bitmap;
                public function get bm():Bitmap {
                        return _bm;
                }
                /**
                         * 设置倒影的图片,如果输入的是显示对象会被draw成图片的 
                         * @param bmd
                         * 
                         */
                public function set bitmapData(bmd:*):void {
                        if (_bitmapData) {
                                removeChild(_bm);
                                _bitmapData.dispose();
                                _bitmapData=null;
                        }
                        if (bmd is DisplayObject) {
                                var dis:DisplayObject=DisplayObject(bmd);
                                _bitmapData=new BitmapData(dis.width,dis.height,true,0);
                                _bitmapData.draw(dis);

                        } else if (bmd is BitmapData) {
                                _bitmapData=bmd;
                        } else {
                                throw new Error("UpendImage的source里您输入的什么都不是");
                        }
                        _bm=new Bitmap(_bitmapData);
                        _bm.scaleY=-1;
                        _bm.y=_bm.height;

                        addChild(_bm);
                        addChild(_mask);
                        _mask.visible=true;
                        _bm.cacheAsBitmap=true;
                        _bm.mask=_mask;
                        var width:Number=_bitmapData.width;

                        length=length;

                        _mask.width=width;
                        _mask.height=length;

                        draw();
                }
                private var _effectHeader:Number=1;
                public function get effectHeader():Number {
                        return _effectHeader;
                }
                public function set effectHeader(value:Number):void {
                        _effectHeader=value;
                        if (_bitmapData) {
                                draw();
                        }
                }
                private var _effectMiddle:Number=0.5;
                public function get effectMiddle():Number {
                        return _effectMiddle;
                }
                public function set effectMiddle(value:Number):void {
                        _effectMiddle=value;
                        if (_bitmapData) {
                                draw();
                        }
                }
                private var _effectEnd:Number=0;
                public function get effectEnd():Number {
                        return _effectEnd;
                }
                public function set effectEnd(value:Number):void {
                        _effectEnd=value;
                        if (_bitmapData) {
                                draw();
                        }
                }
                private function draw():void {
                        var g:Graphics=_mask.graphics;
                        g.clear();

                        var matrix:Matrix=new Matrix  ;
                        matrix.createGradientBox(300,300,Math.PI / 2);
                        g.beginGradientFill(GradientType.LINEAR,[0,0xAAAAAA,0xFFFFFF],[_effectHeader,_effectMiddle,_effectEnd],[0,125,255],matrix);

                        g.drawRect(0,0,300,300);



                }
        }
}

另一个倒影类:

package gs
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.display.GradientType;
	import flash.geom.Matrix;
	import flash.display.SpreadMethod;
	import flash.display.BlendMode;

	/**
	* ...
	* @author DN
	*/
	public class Reflection extends Sprite
	{
		private var _img:Bitmap;
		private var _distance:Number;
		private var _offset:Number;
		private var _reflectionImgData:BitmapData;
		private var _reflectionImg:Bitmap;

		private var _reflectionContainer:Sprite;
		private var _reflectionLight:Sprite;
		/**
		* 构造函数
		* @param newImg   倒影图片对象
		* @param distance 倒影与图片距离
		* @param offset   倒影偏移量
		*/
		public function Reflection(newImg:Bitmap,distance:Number,offset:Number=100)
		{
			_img = newImg;
			_distance = distance;
			_offset = offset;

			addChild(_img);
			initReflection();
		}

		private function initReflection()
		{
			var imgData:BitmapData = _img.bitmapData;
			_reflectionImgData = imgData.clone();
			_reflectionImg = new Bitmap(_reflectionImgData);

			_reflectionContainer = new Sprite();
			_reflectionImg.scaleY *=  -1;
			_reflectionImg.y = _img.y + (_img.height*2) + _distance;
			_reflectionContainer.addChild(_reflectionImg);
			_reflectionContainer.blendMode = BlendMode.LAYER;

			_reflectionLight = new Sprite();
			var fillType:String = GradientType.LINEAR;
			var colors:Array = [0x000000,0xFFFFFF];
			var alphas:Array = [1,0];
			var ratios:Array = [0,0xFF];
			var matr:Matrix = new Matrix();
			matr.createGradientBox(_img.width,_img.height , Math.PI / 2, 0, _offset+_distance);
			var spreadMethod:String = SpreadMethod.PAD;
			_reflectionLight.graphics.beginGradientFill(fillType, colors, alphas, ratios, matr, spreadMethod);
			_reflectionLight.graphics.drawRect(0, _img.y+_img.height+_distance, _img.width, _img.height);
			_reflectionLight.graphics.endFill();
			_reflectionLight.blendMode = BlendMode.ALPHA;
			_reflectionContainer.addChild(_reflectionLight);
			this.addChild(_reflectionContainer);
		}

	}

}


你可能感兴趣的:(function,null,import,Constructor,Matrix,distance)