一个3D下雪 效果

http://2354919152419616925-a-1802744773732722657-s-sites.googlegroups.com/site/chinachenaa/3d/dandelion3d.swf?attredirects=0&auth=ANoY7co200-aTq4U_qMh7K4Ourbrw_Duga69cTNqXl0Y2zDArs8kd1YjuSIuYxM6BOCh6Ru0ZZZBIz011Ci-iPfKwFXWGcF4jFmBzyXcKo1gzedi6ZKSvdb2m30ntivWS3eXgLNvg0npBQUyHDP3X1nzMO6asJYlJnEWgcL9gHr50D3ERosGZEhnImrLzX2XH2v5nPSPBrnDEWQx1_QP30Da6fPBvBfxfg%3D%3D

 效果演示 下载

源码

 

 
package {  
 
    import flash.display.BitmapData;
    import flash.display.GradientType;
    import flash.display.Sprite;
    import flash.filters.BlurFilter;
    import flash.geom.Matrix;
    import flash.geom.Point;
    import org.papervision3d.cameras.FreeCamera3D;
    import org.papervision3d.materials.special.BitmapParticleMaterial;
    import org.papervision3d.view.BasicView;  
 
    import flash.events.Event;  
 
    import org.papervision3d.objects.DisplayObject3D;
    import org.papervision3d.core.geom.Particles;
    import org.papervision3d.core.geom.renderables.Particle;  
 [SWF(width="800", height="600",backgroundColor='0x000000', frameRate="30")]
    public class Snow3d extends BasicView  {  
 
        private var snowHolder:DisplayObject3D;
        private var flakes:Array;
        private const NUM_FLAKES:int = 300;
        private var cam:FreeCamera3D;  
 
        private var noBlurFlake:BitmapData;
        private var ltBlurFlake:BitmapData;
        private var medBlurFlake:BitmapData;
        private var heavyBlurFlake:BitmapData;  
 
        public function Snow3d() {
            super(stage.stageWidth, stage.stageHeight, true, false, FreeCamera3D.TYPE);
            init();
        }  
 
        private function init():void {
            cam = cameraAsFreeCamera3D;
            cam.zoom = 1;
            cam.focus = 400;
            cam.z = 10;  
 
            createBitmaps();  
 
            snowHolder = new DisplayObject3D("snow_holder");
            flakes = new Array();  
 
            for(var i:int = 0; i<NUM_FLAKES; i++) {  
 
                var mat:BitmapParticleMaterial = new BitmapParticleMaterial(noBlurFlake);
                mat.smooth = true;  
 
                var flakeHolder:Particles = new Particles("flake" + i);
                var flake:Particle = new Particle(mat, 10, 0, 0, 0);  
 
                flakeHolder.addParticle(flake);   
 
                flakeHolder.x = randRange(-2000, 2000);
                flakeHolder.y = randRange(-2000, 2000);
                flakeHolder.z = randRange( -2000, 2000);  
 
                flakeHolder.extra = { radians: 0, I:randRange(2, 8), K: (-Math.PI + Math.random() * Math.PI), noblur: new BitmapParticleMaterial(noBlurFlake), blur1: new BitmapParticleMaterial(ltBlurFlake),  blur2: new BitmapParticleMaterial(medBlurFlake), blur3: new BitmapParticleMaterial(heavyBlurFlake) };  
 
                snowHolder.addChild(flakeHolder);
                flakes.push(flakeHolder);
            }  
 
            scene.addChild(snowHolder);  
 
            singleRender();   
 
            addEventListener(Event.ENTER_FRAME, enterFrame);
        }  
 
        private function createBitmaps():void {
            var lightBlur:BlurFilter = new BlurFilter(4, 4, 1);
            var medBlur:BlurFilter = new BlurFilter (8, 8, 1);
            var heavyBlur:BlurFilter = new BlurFilter(16, 16, 1);  
 
            var type:String = GradientType.RADIAL;
            var colors:Array = [0xFFFFFF, 0xFFFFFF, 0xFFFFFF];
            var alphas:Array = [1, .1, 0];
            var ratios:Array = [0, 200, 255];
            var mat:Matrix = new Matrix();
            mat.createGradientBox(10, 10);  
 
            var baseFlake:Sprite = new Sprite();
            baseFlake.graphics.beginGradientFill(type, colors, alphas, ratios, mat);
            baseFlake.graphics.drawCircle(5, 5, 5);
            baseFlake.graphics.endFill();  
 
            noBlurFlake = new BitmapData(10, 10, true, 0x00000000);
            noBlurFlake.draw(baseFlake);  
 
            ltBlurFlake = new BitmapData(10, 10, true, 0x00000000);
            ltBlurFlake.draw(baseFlake);
            ltBlurFlake.applyFilter(ltBlurFlake, baseFlake.getBounds(baseFlake), new Point(), lightBlur);  
 
            medBlurFlake = new BitmapData(10, 10, true, 0x00000000);
            medBlurFlake.draw(baseFlake);
            medBlurFlake.applyFilter(medBlurFlake, baseFlake.getBounds(baseFlake), new Point(), medBlur);  
 
            heavyBlurFlake = new BitmapData(10, 10, true, 0x00000000);
            heavyBlurFlake.draw(baseFlake);
            heavyBlurFlake.applyFilter(heavyBlurFlake, baseFlake.getBounds(baseFlake), new Point(), heavyBlur);
        }  
 
        private function enterFrame(e:Event):void {  
 
            var pan:Number = cam.rotationY - 210 * stage.mouseX / (stage.stageWidth/2);
            pan = Math.max( -100, Math.min( pan, 100 ) );
            cam.rotationY -= pan / 12;  
 
            var len:int = flakes.length;  
 
            for(var i:int = 0; i<len; i++) {
                var p:Particles = flakes[i];  
 
                if (Math.abs(p.sceneZ) <= 100) {
                        p.particles[0].material = p.extra["noblur"]
                }
                if (Math.abs(p.sceneZ) >= 101 && Math.abs(p.z) <= 200) {
                    p.particles[0].material = p.extra["blur1"]
                }
                if (Math.abs(p.sceneZ) >= 201 &&Math.abs(p.z) <= 300) {
                    p.particles[0].material = p.extra["blur2"]
                }
                if (Math.abs(p.sceneZ) >= 301) {
                    p.particles[0].material = p.extra["blur3"]
                }  
 
                p.extra["radians"] += (p.extra["K"] / 180) * Math.PI;
                p.x -= 3 * (Math.cos(p.extra["radians"]));
                p.z -= 3 * (Math.sin(p.extra["radians"]));
                p.y -= p.extra["I"];
                if (p.y < -2000) {
                    p.y = 2000;
                    p.x = randRange(-2000, 2000);
                    p.z = randRange( -2000, 2000);  
 
                    p.extra["I"] = randRange(2, 8);
                }
            }  
 
            singleRender();
        }  
 
        private function randRange(min:Number, max:Number):Number {
            return Math.floor(Math.random() * (max - min + 1)) + min;
        }
    }
}