Pyramids

@author Anatoly Zenkov
http://anatolyzenkov.com/

CLICK TO REGENERATE

forked:7
favorite:76
lines:231
license : see code comments
modified : 2012-02-29 17:59:04

Embed: Tweet

package {
    /**
     * @author Anatoly Zenkov
     * http://anatolyzenkov.com/
     */
     // CLICK TO REGENERATE
    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.display.BlendMode;
    import flash.display.DisplayObject;
    import flash.display.Loader;
    import flash.display.LoaderInfo;
    import flash.display.Shape;
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.events.IOErrorEvent;
    import flash.events.MouseEvent;
    import flash.geom.ColorTransform;
    import flash.geom.Matrix;
    import flash.geom.Point;
    import flash.geom.Rectangle;
    import flash.net.URLRequest;
    import flash.system.LoaderContext;

[SWF(backgroundColor=0x000000,frameRate=41)]
    public class Pyramids extends Sprite {
        private var _bitmap : Bitmap;
        private var _pyramids : Array;
        static public const DOUBLE_PI : Number = 2 * Math.PI;
        static public const HALF_PI : Number = .5 * Math.PI;
        static public var OFFSET_X : Number;
        static public var OFFSET_Y : Number;
        private var _pyramidLayer : Shape;
        private var _gradient : BitmapData;
        private var _currentBitmap : BitmapData;
        private const REFLECTIONS : int = 4;
        private const MAX_PYRAMIDS : int = 6;
        private const SIDES : int = 7;

public function Pyramids() {
            addEventListener(Event.ADDED_TO_STAGE, addedToStageHandler);
        }

private function addedToStageHandler(event : Event) : void {
            removeEventListener(Event.ADDED_TO_STAGE, addedToStageHandler);
            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;
            
            addChild(_bitmap = new Bitmap());
            _gradient = new BitmapData(600, 600, false);
            _currentBitmap = _gradient;
            var rect : Rectangle = new Rectangle(0, 0, 600, 600 / 255);
            for (var i : int = 0;i < 255;i++) {
                rect.y = i / 255 * 600;
                _currentBitmap.fillRect(rect, i << 16 | i << 8 | i);
            }
            _bitmap.bitmapData = _currentBitmap.clone();
            alignBitmap();
            load("http://assets.anatolyzenkov.com/misc/pool.jpg");
            
            _pyramidLayer = new Shape();
            
            stage.addEventListener(MouseEvent.CLICK, addPyramids);
            addPyramids(null);
            addEventListener(Event.ENTER_FRAME, updatePyramids);
        }

private function updatePyramids(event : Event) : void {
            _bitmap.bitmapData.copyPixels(_currentBitmap, _currentBitmap.rect, new Point());
            var rects : Array = [];
            var p : Pyramid;
            for each (p in _pyramids) {
                p.update((stage.stageWidth * .5 - mouseX) / stage.stageWidth * 2, (stage.stageHeight * .5 - mouseY) / stage.stageHeight * 2);
                rects[rects.length] = p.getBoundRect();
            }
            var m : Number;
            for (var i : int = 0;i < REFLECTIONS;i++) {
                m = 0.9 + .1 * i / REFLECTIONS;
                var j : int = 0;
                var colortrans : ColorTransform = new ColorTransform(m, m, m);
                for each (p in _pyramids) {
                    _pyramidLayer.graphics.clear();
                    p.draw(_pyramidLayer.graphics, _bitmap.bitmapData);
                    _bitmap.bitmapData.draw(_pyramidLayer, new Matrix(1, 0, 0, 1, -OFFSET_X, -OFFSET_Y), colortrans, BlendMode.NORMAL, rects[j]);
                    j++;
                }
            }
        }

private function addPyramids(event : MouseEvent) : void {
            _pyramids = [];
            var r : Number;
            var p : Pyramid;
            for (var i : int = 0;i < 2 + (MAX_PYRAMIDS - 2) * Math.random();i++) {
                var points : Array = [];
                for (var j : Number = 0;j < DOUBLE_PI;j += DOUBLE_PI / (2 + (SIDES - 2) * Math.random())) {
                    r = 100 + Math.random() * 50;
                    points[points.length] = new Point(r * Math.cos(j), r * Math.sin(j));
                }
                p = new Pyramid(points);
                p.x = 50 + (stage.stageWidth - 100) * Math.random();
                p.y = 50 + (stage.stageHeight - 100) * Math.random();
                p.scale = .6 + .6 * Math.random();
                p.scale *= p.scale;
                _pyramids[_pyramids.length] = p;
            }
            _pyramids.sortOn("scale");
        }

private function alignBitmap() : void {
            _bitmap.x = OFFSET_X = int((stage.stageWidth - _bitmap.width) * .5);
            _bitmap.y = OFFSET_Y = int((stage.stageHeight - _bitmap.height) * .5);
        }

///////////////////////////////////////////////////////////////////////////////
        // imageLoader stuff
        ///////////////////////////////////////////////////////////////////////////////
        private function load(url : String) : void {
            var imageLoader : Loader = new Loader();
            imageLoader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, imageLoader_ioErrorEventHandler);
            imageLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, imageLoader_compelteEventHandler);
            imageLoader.load(new URLRequest(url), new LoaderContext(true));
        }

private function imageLoader_compelteEventHandler(event : Event) : void {
            var content : DisplayObject = (event.target as LoaderInfo).content;
            _currentBitmap = (content as Bitmap).bitmapData;
            _bitmap.bitmapData = _currentBitmap.clone();
            alignBitmap();
            clearLoader(event.target as LoaderInfo);
        }

private function imageLoader_ioErrorEventHandler(event : IOErrorEvent) : void {
            clearLoader(event.target as LoaderInfo);
        }

private function clearLoader(loaderInfo : LoaderInfo) : void {
            loaderInfo.removeEventListener(IOErrorEvent.IO_ERROR, imageLoader_ioErrorEventHandler);
            loaderInfo.removeEventListener(Event.COMPLETE, imageLoader_compelteEventHandler);
        }
        ///////////////////////////////////////////////////////////////////////////////
    }
}

import flash.display.BitmapData;
import flash.display.Graphics;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Rectangle;

class Pyramid {
    private var _points : Array;
    private var _centralPoint : Point;
    private var _matrix : Matrix;
    private var _targetAngle : Number;
    public var scale : Number;
    public var angle : Number;
    public var x : Number;
    public var y : Number;
    private var _easyAngle : Number;
    private var _transformedPoints : Array;
    private var _targetMouseX : Number;
    private var _targetMouseY : Number;

public function Pyramid(points : Array) {
        _centralPoint = new Point();
        _points = points;
        _matrix = new Matrix();
        _targetAngle = Pyramids.DOUBLE_PI * Math.random();
        _easyAngle = Pyramids.DOUBLE_PI * Math.random();
        _targetMouseX = 0;
        _targetMouseY = 0;
        scale = 1;
        angle = Pyramids.DOUBLE_PI * Math.random();
        x = 0;
        y = 0;
    }

public function draw(graphics : Graphics, bitmapData : BitmapData) : void {
        _transformedPoints = [];
        for each (var p : Point in _points) {
            _transformedPoints[_transformedPoints.length] = _matrix.transformPoint(p);
        }
        var cp : Point = _matrix.transformPoint(_centralPoint);
        cp.x -= 50 * _targetMouseX * scale * scale;
        cp.y -= 50 * _targetMouseY * scale * scale;
        p = new Point();
        var p0 : Point = _transformedPoints[0];
        var p1 : Point;
        var sp : Point = new Point();
        var mtrx : Matrix = new Matrix();
        for (var i : int = 1;i <= _transformedPoints.length;i++) {
            p1 = _transformedPoints[i % _transformedPoints.length];
            sp.x = p0.x - Pyramids.OFFSET_X;
            sp.y = p0.y - Pyramids.OFFSET_Y;
            var a0 : Number = Math.atan2(sp.y, sp.x);
            var a1 : Number = Math.atan2(p0.y - p1.y, p0.x - p1.x);
            var d : Number = 2 * sp.length * Math.cos(Pyramids.HALF_PI - a1 + a0);
            var a : Number = a1 - Pyramids.HALF_PI;
            p.x = Math.cos(a) * d;
            p.y = Math.sin(a) * d;
            
            mtrx.identity();
            mtrx.scale(-1, 1);
            mtrx.rotate(2 * a);
            mtrx.translate(p.x + Pyramids.OFFSET_X, p.y + Pyramids.OFFSET_Y);
            with (graphics) {
                beginBitmapFill(bitmapData, mtrx, true, true);
                moveTo(p0.x, p0.y);
                lineTo(p1.x, p1.y);
                lineTo(cp.x, cp.y);
                lineTo(p0.x, p0.y);
                endFill();
            }
            p0 = p1;
        }
    }

public function update(tx : Number, ty : Number) : void {
        if (Math.random() < .005) _targetAngle = (6 - 12 * Math.random()) * Pyramids.DOUBLE_PI;
        
        var da : Number = correctAngle(_targetAngle, _easyAngle);
        _easyAngle -= Math.min(Math.abs(da), 0.6) * .1 * sign(da);
        angle -= correctAngle(_easyAngle, angle) * .05;
        tx = Math.max(Math.min(tx, .7), -.7);
        ty = Math.max(Math.min(ty, .7), -.7);
        _targetMouseX += (tx - _targetMouseX) * .1;
        _targetMouseY += (ty - _targetMouseY) * .1;
        _matrix.identity();
        _matrix.scale(scale, scale);
        _matrix.rotate(angle);
        _matrix.translate(x - 300 * _targetMouseX * scale * scale, y - 300 * _targetMouseY * scale * scale);
    }

public function getBoundRect() : Rectangle {
        var r : Rectangle = new Rectangle(Infinity, Infinity, -Infinity, -Infinity);
        for each (var p : Point in _transformedPoints) {
            if (p.x < r.x) r.x = p.x;
            if (p.y < r.y) r.y = p.y;
            if (p.x > r.width) r.width = p.x;
            if (p.y > r.height) r.height = p.y;
        }
        r.width = r.width - r.x + 2;
        r.height = r.height - r.y + 2;
        r.x -= Pyramids.OFFSET_X + 1;
        r.y -= Pyramids.OFFSET_Y + 1;
        return r;
    }

public static function sign(n : Number) : Number {
        if (!n) return 0;
        return n > 0 ? 1 : -1;
    }

public static function correctAngle(a0 : Number, a1 : Number) : Number {
        var d : Number = a1 - a0;
        if (d > Pyramids.HALF_PI) return d % Pyramids.DOUBLE_PI;
        if (d < -Pyramids.HALF_PI) return d % (-Pyramids.DOUBLE_PI);
        return d;
    }
}

Code Fullscreen

Preview Fullscreen