package
{
        import com.greensock.TweenMax;
        import com.greensock.easing.Sine;
        import flash.geom.Point;

        public class WaveData
        {
                public var controlPoints:int = 7
                public var minRadius:Number = 0.1;
                public var maxRadius:Number= 1;
                public var waveAlpha:Number = 0.08
                public var lineWidth:Number = 0;
                public var minSpeed:Number = 5;
                public var maxSpeed:Number = 8;
                public var color:int = 0;
                public var aPoints:Array       
               
                // no constructor needed. Best practise?? Naah, maybe not but hey, I get to write a comment instead of a constructor.
               
               
                // resets the wavedata and starts the animation of the controlpoints and the wavecolour.
                public function reset()
                {
                        var y:Number
                        var p:Point;
                        aPoints = [];
                       
                        // create all controlpoints and place them within the radius. They all starts at x:0
                        for (var i:int = 0;i<controlPoints;i++)
                        {      
                                y = 2*(Math.random()*(maxRadius-minRadius)+minRadius)-maxRadius;
                                p = new Point(0,y);
                                aPoints.push(p);
                                startAnim(p);
                        }
                        animColour();
                }
               
                private function animColour()
                {
                        var newColor = Math.random()*0xffffff;
                        TweenMax.to(this, 9, {hexColors:{color:newColor},onComplete:animColour});
                }
               
                private function startAnim(p:Point)
                {
                        // no, it’s not an optimized way to find the point but it’s a lab, remember? ;)
                        var ip:int = aPoints.indexOf(p);
                        var newY:Number = Math.random()*(maxRadius-minRadius)+minRadius
                        // x is being set "somewhat" around the section where it should be.
                        var newX:Number =  (ip==0)?0:((ip/(controlPoints-1)+(Math.random()*(1/(controlPoints-1))*4))-(2*(1/(controlPoints-1))));
                        // is the direction of the controlpoint going UP or DOWN?
                        if (p.y > 0) newY=-newY;
                        //animate!
                        TweenMax.to(p,(Math.random()*(maxSpeed-minSpeed))+minSpeed,{ease:Sine.easeInOut,y:newY,x:newX,onComplete:startAnim,onCompleteParams:[p]});
                }
        }
}

package
{
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.geom.Point;
       
        public class Wave extends Sprite
        {
                public var waveWidth:Number = 650;
                public var waveHeight:Number = 150;
                public var data:WaveData
               
                public function Wave()
                {
                        super();
                        // creates data and starts the animation
                        data = new WaveData();
                        data.reset();
                }
               
               
               
                public function update()
                {
                        // creating real coordinates from Wave-data controlpoints
                        var counter:int = 0;
                        var coord:Array = [];
                        for each(var p:Point in data.aPoints)
                        {
                                coord.push (new Point(p.x*waveWidth,p.y*waveHeight));;
                        }
                       
                        // draw curve
                        graphics.clear();
                        graphics.lineStyle(data.lineWidth,data.color,data.waveAlpha);
                        CubicBezier.curveThroughPoints(graphics,coord);
                }
        }
}

package
{
        import flash.display.Bitmap;
        import flash.display.BitmapData;
        import flash.display.BlendMode;
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.filters.BitmapFilter;
        import flash.filters.BlurFilter;
        import flash.geom.Matrix;
        import flash.geom.Point;
        import flash.geom.Rectangle;
       
        public class Canvas extends Sprite
        {
                private var bmpd:BitmapData
                private var aWaves:Array
                private var w:int
                private var h:int
               
                public function Canvas(w:int = 900,h:int = 450)
                {
                        super();
                       
                        // set the width and height of the canvas
                        this.w = w;
                        this.h = h;
                       
                        aWaves=[];
                       
                        // adding a bitmap to stage
                        bmpd = new BitmapData(w,h,false,0);
                        var bmp:Bitmap = new Bitmap(bmpd);
                        addChild(bmp);
                       
                }
               
                public function addWave(wave:Wave)
                {
                        // adding a wave to the canvas
                        aWaves.push(wave);
                }
               
                public function startDraw()
                {
                        addEventListener(Event.ENTER_FRAME,onTick)
                }
               
                private function onTick(e:Event)
                {
                        // each wave is now drawn onto the canvas using the ADD Blendmode.
                        for each ( var wave:Wave in aWaves)
                        {
                                wave.update();
                                var m:Matrix = new Matrix(1,0,0,1,26,bmpd.height*.5);
                                bmpd.draw(wave,m,null,BlendMode.ADD);
                        }
                       
                        // the canvas is now blurred out giving a blurred AND transitionout effect.
                        var filter:BlurFilter = new BlurFilter(3,3);
                        bmpd.applyFilter(bmpd, new Rectangle(0,0,w,h),new Point(0,0), filter);
                       
                        // the bitmapdata is now scrolled to the right giving a "moving feeling" to the effect.
                        bmpd.scroll(5,0)       
                }
        }
}

package
{
        import flash.display.Sprite;
       
        public class Main extends Sprite
        {
                public function Main()
                {
                        var c:Canvas = new Canvas();
                       
                        // adding a few waves
                        for (var i:int = 0;i < 3;i++)
                        {
                                var w:Wave = new Wave();
                                c.addWave(w);
                        }
                       
                        addChild(c);
                        c.startDraw();
                }
        }
}

package {
        import com.greensock.TweenLite;
        import se.xcom.math.Degrees;
       
        public class Branch
        {
                public var rotZ:Number;
                public var rotZSpeed:Number = 0;
                public var x:Number;
                public var y:Number;
                public var thickness:Number;
                public var speed:Number = 3;
                public var rotationSpeedSpan:Number;
                public var rotationSpeedFragility:Number = 0.2;
               
                public function Branch(x:Number,y:Number,rotZ:Number,thickness:Number,rotationSpeedSpan:Number)
                {
                        this.x = x;
                        this.y = y;
                        this.rotZ = rotZ;
                        this.thickness = thickness;
                        this.rotationSpeedSpan = rotationSpeedSpan;
                        setRotationSpeed();
                }

                public function update()
                {
                        x += Degrees.dSin(rotZ)*speed;
                        y += Degrees.dCos(rotZ)*speed;
                        rotZ += rotZSpeed;
                        thickness-= 0.04;
                }
               
                public function destroy()
                {
                        // kill the endless loop
                        TweenLite.killTweensOf(this);
                }
               
                private function setRotationSpeed()
                {
                        // To make sure that the rotation of the branch moves smoothly I decide not to tween the actual rotation but the speed of the rotation.
                        // This is an endless loop, calling itself when the tween has ended.
                        var newSpeed:Number = Math.random()*rotationSpeedSpan-rotationSpeedSpan*.5;
                        var delay:Number = Math.random()*rotationSpeedFragility+rotationSpeedFragility*.5;
                        TweenLite.to(this,delay,{rotZSpeed:newSpeed,onComplete:setRotationSpeed});
                }
        }
}

package
{
        import com.greensock.TweenLite;
        import flash.display.Sprite;
        import flash.events.Event;

        public class Tree extends Sprite
        {
                private var color:Number
                private var aBranches:Array = [];
               
                public function Tree(color:Number)
                {
                        this.color = color;
                        reset();
                        super();
                }
               
                public function start(delay:int)
                {
                        // Just starts drawing the tree. Implanted only so the trees doesnt start drawing at the same time.
                        TweenLite.delayedCall(delay,function(){addEventListener(Event.ENTER_FRAME,onTick)});
                }
               
                private function onTick(e:Event)
                {
                        // Goes through every branch in the tree.
                        for each(var br:Branch in aBranches)
                        {
                               
                                // Updates the branch and draws a new line between the old position and the new one.
                                with (this.graphics)
                                {
                                        lineStyle(br.thickness,color,1);
                                        moveTo(br.x,br.y);
                                        br.update();
                                        lineTo(br.x,br.y);
                                }
                               
                                // Randomly decides wether to create a new branch origin from the current branch.
                                if (Math.random() < 0.1-(br.thickness*0.01))
                                {
                                        var th:int = (br.thickness>0.7)?(br.thickness-1):br.thickness;
                                        var tbr:Branch = new Branch(br.x,br.y,br.rotZ,th,br.rotationSpeedSpan+14);
                                        aBranches.push(tbr);
                                }
                        }
                       
                        // Goes through every branch in the tree (again!) just to destroy the branches that are too small.
                        for (var i:int= aBranches.length-1;i > -1;i–)
                        {
                                var tbr:Branch = aBranches[i]
                                if (tbr.thickness < 0.4)
                                {
                                        tbr.destroy();
                                        aBranches.splice(i,1)
                                       
                                        // Checks if there are no "alive" branches left.
                                        if (aBranches.length == 0)
                                        {
                                                TweenLite.to(this,2,{alpha:0,onComplete:reset});
                                        }
                                }
                        }
                }
               
                private function reset()
                {
                        this.graphics.clear();
                        alpha = 1;
                        var tbr:Branch = new Branch(0,0,180,8,5)
                        aBranches.push(tbr);
                }
               
        }
}

package {
        import flash.display.Sprite;

        public class Main extends Sprite
        {
                private var aTrees:Array;
                private var aColors:Array=[0xffbb88,0xaaffaa,0xaabbff];
                private var aBranches:Array    
                public function Main()
                {      
                        for (var i:int = 0;i<3;i++)
                        {
                                var tree:Tree = new Tree(aColors[i]);
                                tree.x = 250*i+200;
                                tree.y = 370;
                                tree.start(i*3.5);
                                addChild(tree);
                        }
                }
        }
}

package {
        import flash.display.Sprite;

        public class ViewportLayerTest extends Sprite
        {
                public function ViewportLayerTest()
                {
                        var tView:View3d = new View3d();
                        addChild(tView);
                }
        }
}

package
{
    import org.papervision3d.materials.WireframeMaterial;
    import org.papervision3d.objects.primitives.Cube;
    import org.papervision3d.objects.primitives.Plane;
    import org.papervision3d.objects.primitives.Sphere;
    import org.papervision3d.view.BasicView;

    public class View3d extends BasicView
    {
        private var sphere:Sphere;
        private var cube:Cube;
        private var ground:Plane;
        private var wall:Plane;

        public function View3d()
        {
            super();
            setupScene();
            startRendering();
        }

        private function setupScene()
        {
            camera.x = 660;
            camera.y =  400;
            camera.z = -700;

            ground = new Plane(new WireframeMaterial(0×224422),1000,1000,1,1);
            ground.rotationX = 90;

            wall = new Plane(new WireframeMaterial(0×556655),1000,400,1,1);
            wall.y = 200;

            sphere = new Sphere(new WireframeMaterial(0xff2222));
            sphere.x = -100;
            sphere.y = 100;

            scene.addChild(ground);
            scene.addChild(wall);
            scene.addChild(sphere);
        }
    }
}

package
{
        import org.papervision3d.lights.PointLight3D;
        import org.papervision3d.materials.ColorMaterial;
        import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
        import org.papervision3d.objects.primitives.Cube;
        import org.papervision3d.objects.primitives.Plane;
        import org.papervision3d.objects.primitives.Sphere;
        import org.papervision3d.view.BasicView;

        public class View3d extends BasicView
        {
                private var light:PointLight3D;
                private var sphere:Sphere;
                private var cube:Cube;
                private var ground:Plane;
                private var wall:Plane;

                public function View3d()
                {
                        super();
                        setupScene();
                        startRendering();
                }

                private function setupScene()
                {
                        camera.x = 660;
                        camera.y =  400;
                        camera.z = -700;

                        light = new PointLight3D();
                        light.x = -400;
                        light.z = -1000;
                        light.y = 200;

                        ground = new Plane(new ColorMaterial(0×224422),1000,1000,1,1);
                        ground.rotationX = 90;

                        wall = new Plane(new ColorMaterial(0×446644),800,400,1,1);
                        wall.y = 200;

                        sphere = new Sphere(new FlatShadeMaterial(light,0xff2222),100,10,10);
                        sphere.x = -100;
                        sphere.y = 100;

                        scene.addChild(ground);
                        scene.addChild(wall);
                        scene.addChild(sphere);
                }
        }
}

// create 3 new layers, null says that it will be empty initially.
var sphereLayer:ViewportLayer = new ViewportLayer(viewport,null);
var wallLayer:ViewportLayer = new ViewportLayer(viewport,null);
var groundLayer:ViewportLayer = new ViewportLayer(viewport,null);

// add the layers as childs to the "root"-layer
viewport.containerSprite.addLayer(sphereLayer);
viewport.containerSprite.addLayer(wallLayer);
viewport.containerSprite.addLayer(groundLayer);

// set the sorting of all childlayers to sort by index
viewport.containerSprite.sortMode = ViewportLayerSortMode.INDEX_SORT;

// set the sort index of the new layer
groundLayer.layerIndex = 1;
wallLayer.layerIndex = 2;
sphereLayer.layerIndex = 3;

// add our objects to the new layers
groundLayer.addDisplayObject3D(ground);
wallLayer.addDisplayObject3D(wall);
sphereLayer.addDisplayObject3D(sphere);

// this time, let’s use the viewport to create layers, through objects.
// true means that if ’sphere’ does not belong to a layer, create one for it and put it there.
var sphereLayer:ViewportLayer = viewport.getChildLayer(sphere, true);
var groundLayer:ViewportLayer = viewport.getChildLayer(sphere, true);
var wallLayer:ViewportLayer = viewport.getChildLayer(sphere, true);
viewport.containerSprite.sortMode = ViewportLayerSortMode.INDEX_SORT;

// set the sort index of the new layer
groundLayer.layerIndex = 2;
wallLayer.layerIndex = 1;
sphereLayer.layerIndex = 3;

package
{
        import flash.display.Sprite;
        import se.xcom.effects.particle.NovaEmitter;
        import se.xcom.effects.particle.StarEmitter;

        public class LiteTest extends Sprite
        {
                public function LiteTest()
                {
                        super();
                       
                        // create the emitters and adding it to the middle of scene.
                        var nova:NovaEmitter = new NovaEmitter();
                        nova.x = stage.stageWidth*.5;
                        nova.y = stage.stageHeight*.5;
                        nova.scaleX = 2;
                        nova.scaleY = 2;
               
                        var stars:StarEmitter = new StarEmitter()
                        stars.x = stage.stageWidth*.5;
                        stars.y = stage.stageHeight*.5;
                       
                        addChild(nova);
                        addChild(stars);
                }
        }
}

package se.xcom.effects.particle
{
        import flash.display.BlendMode;
        import flash.display.Sprite;
        import flash.events.TimerEvent;
        import flash.utils.Timer;
       
        import gs.TweenMax;
        import gs.easing.Linear;

        public class NovaEmitter extends Sprite
        {
                private var emitTimer:Timer
               
                // Time until next particle is emitted (ms).
                private static const EMIT_TIME:Number = 1500
               
                public function NovaEmitter()
                {
                        super();
                        emitTimer = new Timer(EMIT_TIME)
                        emitTimer.addEventListener(TimerEvent.TIMER,onTimer)
                        emitTimer.start()
                       
                        // creating a few particles to begin with.
                        for (var i:uint=0;i < 5;i++)
                        {
                                createParticle()
                        }
                }
               
                public function onTimer(e:TimerEvent)
                {
                        createParticle()
                }
               
                private function createParticle(prog:Number = 0)
                {
                        var part:Sprite = new Particle()  // is a simple bitmap in flash library converted as a Sprite.
                       
                        // modifying particle.
                        part.rotation = Math.random()*360
                        part.scaleX = part.scaleY = 0.3+Math.random()*0.3
                        part.blendMode = BlendMode.ADD
                        part.alpha = 0
                        var time:Number = Math.random()*7+5
                        var rot:Number = Math.random()*180-90
                        var scale:Number = Math.random()*1.6+0.6
                        var posX:Number = Math.random()*50-25
                        var posY:Number = Math.random()*50-25
                               
                        addChild(part)
                       
                        TweenMax.to(part,time,{x:posX,y:posY,rotation:String(rot),scaleX:scale,scaleY:scale,ease:Linear.easeOut, onComplete:killParticle,onCompleteParams:[part]})
                        TweenMax.to(part,time/4,{alpha:1,overwrite:false})
                        TweenMax.to(part,time*2/3,{delay:time/3,alpha:0,overwrite:false})
                }
               
                private function killParticle(obj:Sprite)
                {
                        this.removeChild(obj)
                        obj = null
                }
        }
}

package se.xcom.effects.particle
{
import flash.display.BlendMode;
import flash.display.Sprite;
import flash.events.TimerEvent;
import flash.utils.Timer;

import gs.TweenMax;
import gs.easing.Quad;

        public class StarEmitter extends Sprite
        {
                private var emitTimer:Timer
                private static const STAR_TIME:Number = 4
                private static const EMIT_TIME:Number = 1
               
                public function StarEmitter()
                {
                        super();
                        emitTimer = new Timer(EMIT_TIME)
                        emitTimer.addEventListener(TimerEvent.TIMER,onTimer)
                        emitTimer.start()
                       
                        // initiating with some stars
                        for (var i:uint=0;i < 40;i++)
                        {
                                createParticle()
                        }
                }
               
                public function onTimer(e:TimerEvent)
                {
                        for (var i:uint=0;i < 3;i++)
                        {
                                createParticle()
                        }
                }
               
                private function createParticle()
                {
                        var part:Sprite = new Star()  // is a simple bitmap in flash library converted as a Sprite.
                       
                        // modifying particle.
                        var z:Number = Math.random();  // z = 1 means it is in the same Z as the camera
                        var posX:Number = (Math.random()*1500-750)
                        var posY:Number = (Math.random()*1500-750)
                       
                        part.blendMode = BlendMode.ADD
                        part.alpha = 0
                        part.scaleX = part.scaleY =0
                        part.x = posX*z
                        part.y = posY*z
                        addChild(part)
                       
                        var t:Number = STAR_TIME*(1-z)
                        var endScale:Number = Math.random()
                       
                        TweenMax.to(part,t,{x:posX,y:posY,scaleX:endScale,scaleY:endScale,ease:Quad.easeIn, onComplete:killParticle,onCompleteParams:[part]})
                        TweenMax.to(part,t/2,{alpha:1,overwrite:false})
                        TweenMax.to(part,t*1/2,{delay:t*1/2,alpha:0,overwrite:false})
                }
               
                private function killParticle(obj:Sprite)
                {
                        this.removeChild(obj)
                        obj = null
                }
        }
}

package
{
        import flash.display.GradientType;
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.filters.GlowFilter;
        import flash.geom.Matrix;
        import flash.media.SoundMixer;
        import flash.utils.ByteArray;
        import se.xcom.math.DegreesVector;

        public class Firebird extends Sprite
        {
                private const BAR_WIDTH:int = 1;
                private var ba:ByteArray;
                private var matrix:Matrix;
                private var degrees:DegreesVector;
                private var counter:int;
                private var aColours:Array;
               
                public function Firebird()
                {
                        super();
                        counter = 0;
                        aColours = [0xFFFFFF,0xFFFF33,0xFF2200,0xFF0000];
                        ba = new ByteArray();
                        matrix = new Matrix();
                        degrees = new DegreesVector();
                        this.filters = [new GlowFilter(0xFF2211,1,20,30,3,2)];
                        this.addEventListener(Event.ENTER_FRAME,onFrameTick);
                }
               
                private function onFrameTick(e:Event)
                {
                        var enhance:Number
                        var barHeight:Number
                        var posY:Number
                       
                        // get new ByteArray from soundmixer
                        SoundMixer.computeSpectrum(ba,true);
                       
                        // setting up gradientcolours. Using the aColours gives us the flexibility
                        //  to switch between different colours in the future if we would like to.
                        var gradientColours:Array = [aColours[3], aColours[2], aColours[1], aColours[0], aColours[1], aColours[2], aColours[3]];
                       
                        with(graphics)
                        {      
                                clear();
                                for (var i:int=0; i<256; i+=BAR_WIDTH)
                                {      
                                        // enhance largen the shape towards the middle. The first 60 bars will be enhanced
                                        // (simply to create the birdhead)
                                        enhance = 60-i;
                                        enhance = (enhance <0)?0:enhance;
                                       
                                        // now the bar is moved in Y-axis using a normal sinus curve. (Using a faster custom Sine-class)
                                        posY = degrees.fastSin(int(counter+i*0.65))*160;       
                                       
                                        // bar height is calculated using the sound spectrum in the ByteArray.
                                        // It is multiplied and enhanced if close to the middle
                                barHeight = (ba.readFloat() * (100+enhance));
                               
                                // creating the gradientbox set up gradientfill.
                                matrix.createGradientBox(BAR_WIDTH,2*barHeight,1.57075,0,-barHeight-posY*0.5);
                                        beginGradientFill(GradientType.LINEAR,gradientColours,[0,1,1,1,1,1,0],[0,50,110,128,146,205,255],matrix);
                                       
                                        // Draing 2 bars. One for each wing. Adding BAR_WIDTH on the left to avoid a gap in the middle.
                                drawRect(i, -barHeight-posY*0.5, BAR_WIDTH, 2*barHeight);    
                                drawRect(-i+BAR_WIDTH, -barHeight-posY*0.5, BAR_WIDTH, 2*barHeight);            
                                }
                        }
                        // adding counter so the Sine-curve starts one step away next frame (result: the wave motion)
                        counter+=1;
                }
        }
}