EffectHub.com: your best source for gaming

Recommendation

More Effects...

ActionScript

// forked from Test_Dept's Kaleidoscope
//
// mouse right click or Ctrl + click and
// from context menu, select or save your image.
//
package {

import flash.display.Sprite;

/**
     * Kaleidoscope
     * @author Test Dept
     */
    [SWF(backgroundColor="#000000", width="465", height="465")]
    public class Kaleidoscope extends Sprite {
        public function Kaleidoscope() {
            addChild(new KaleidoscopeImpl() );    
        }        
    }
}

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Graphics;
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.display.Sprite;
import flash.events.ContextMenuEvent;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.media.Camera;
import flash.media.Video;
import flash.net.FileFilter;
import flash.net.FileReference;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFieldType;
import flash.ui.ContextMenu;
import flash.ui.ContextMenuItem;

import mx.graphics.codec.PNGEncoder;

class KaleidoscopeImpl extends Sprite {

private static const MAX_SIZE : int = 4096;

private var _a : UIPoint;
    private var _b : UIPoint;
    private var _c : UIPoint;

private var _bmp : BitmapData;

private var _video : Video;

private var _filename : String;

private var _fileRef : FileReference;

private var _markAlpha : Number;

private var _idleCount : int;

public function KaleidoscopeImpl() {
        addEventListener(Event.ADDED_TO_STAGE, addedToStageHandler);
    }
    
    private function addedToStageHandler(event : Event) : void {
        
        var width : Number = stage.stageWidth;
        var height : Number = stage.stageHeight;
        
        addChild(_a = new UIPoint(0x000000, 10, height / 2, "a", true) );
        addChild(_b = new UIPoint(0x000000, width - 10, height / 2 - 40, "b", true) );
        addChild(_c = new UIPoint(0x000000, width / 2, height / 2, "c", true) );

_markAlpha = 0;
        _idleCount = 0;

_bmp = new BitmapData(width, height, false, 0xffffff);
        _bmp.draw(new RandomImage(width, height) );
        _filename = "IMG.IMG";

var camera : Camera = Camera.getCamera();
        if (camera != null) {
            camera.setMode(width, height, 16, true);
            _video = new Video(camera.width, camera.height);
            _video.attachCamera(camera);
        } else {
            _video = null;
        }
        
        contextMenu = new ContextMenu();
        contextMenu.hideBuiltInItems();
        contextMenu.customItems.push(createMenuItem("Select Source Image", contextMenu_loadHandler) );
        contextMenu.customItems.push(createMenuItem("Save Image", contextMenu_saveHandler) );

addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
        addEventListener(Event.ENTER_FRAME, enterFrameHandler);
    }

private function createMenuItem(label : String, handler : Function) : ContextMenuItem {
        var menuItem : ContextMenuItem = new ContextMenuItem(label);
        menuItem.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, handler);
        return menuItem;
    }

private function contextMenu_loadHandler(event : ContextMenuEvent) : void {
        _fileRef = new FileReference();
        _fileRef.browse([
            new FileFilter("Image Files", "*.jpg;*.png"),
            new FileFilter("All Files", "*.*"),
        ]);
        _fileRef.addEventListener(Event.SELECT, _fileRef_selectHandler);    
    }
    
    private function _fileRef_selectHandler(event : Event) : void {
        _filename = _fileRef.name;
        _fileRef.load();
        _fileRef.addEventListener(Event.COMPLETE, _fileRef_load_completeHandler);
    }

private function _fileRef_load_completeHandler(event : Event) : void {
        var loader : Loader = new Loader();
        loader.loadBytes(_fileRef.data);
        loader.contentLoaderInfo.addEventListener(Event.COMPLETE, upload_completeHandler);
    }
    
    private function upload_completeHandler(event : Event) : void {
        var loaderInfo : LoaderInfo = event.target as LoaderInfo;
        var bitmap : Bitmap = loaderInfo.content as Bitmap;
        _bmp = bitmap.bitmapData;
        _video = null;
    }
    
    private function contextMenu_saveHandler(event : ContextMenuEvent) : void {

var sp : Sprite = new Sprite();
        var g : Graphics = sp.graphics;
        g.clear();
        draw(g);

var scale : Number = 1 / getScale();
        var rect : Rectangle = sp.getBounds(sp);
        
        if (rect.width * scale > MAX_SIZE) {
            scale = MAX_SIZE / rect.width;
        }
        if (rect.height * scale > MAX_SIZE) {
            scale = MAX_SIZE / rect.height;
        }
        
        var bmp : BitmapData = new BitmapData(
            Math.min(rect.width * scale, MAX_SIZE),
            Math.min(rect.height * scale, MAX_SIZE),
            true, 0);
        bmp.draw(sp, new Matrix(scale, 0, 0, scale, -rect.x * scale, -rect.y * scale) );

var match : Object = /^(.+)\..+$/.exec(_filename);
        
        var newFilename : String = match[1] + "_" + new Date().getTime() + ".png";
        var encoder : PNGEncoder = new PNGEncoder();

_fileRef = new FileReference();
        _fileRef.save(encoder.encode(bmp), newFilename);
    }

private function enterFrameHandler(event : Event) : void {

if (_idleCount > 0) {
            _idleCount--;
        } else {
            _markAlpha = Math.max(0, _markAlpha - 0.04);
        }

_a.alpha = _markAlpha;
        _b.alpha = _markAlpha;
        _c.alpha = _markAlpha;

if (_video != null) {
            _bmp.draw(_video, new Matrix(_video.scaleX, 0, 0, _video.scaleY) );
        }

var g : Graphics = graphics;
        g.clear();
        g.lineStyle(1, 0x000000, _markAlpha);
        draw(g);
    }
    
    private function draw(g : Graphics) : void {

var a : Point = new Point(_a.x, _a.y);
        var b : Point = new Point(_b.x, _b.y);
        var c : Point = new Point(_c.x, _c.y);

var o : Point = GeoUtil.getCenter(a, b, c);
                
        var ref_c : Point = GeoUtil.getCRef(a, b, c);

var p_bc : Point = GeoUtil.getCrossPoint(o, a, b, ref_c);
        var p_ac : Point = GeoUtil.getCrossPoint(o, b, a, ref_c);
        
        var new_c : Point;
        
        if (p_bc != null) {
            new_c = p_bc;    
        } else if (p_ac != null) {
            new_c = p_ac;    
        } else {
            new_c = ref_c;
        }

var scale : Number = getScale();

var ksImage : KaleidoscopeImage = new KaleidoscopeImage(
            _bmp.width * scale, _bmp.height * scale);
        g.beginBitmapFill(_bmp);
        ksImage.draw(g, o, a, b, c);
        g.endFill();
    }
    
    private function getScale() : Number {
        return (_bmp.width / _bmp.height > stage.stageWidth / stage.stageHeight)?
            stage.stageWidth / _bmp.width : stage.stageHeight / _bmp.height;            
    }
    
    private function mouseMoveHandler(event : Event) : void {
        _markAlpha = 0.5;
        _idleCount = 20;
    }
}

class KaleidoscopeImage {

private var _width : Number;
    private var _height : Number;

private var _maxNest : int;
    
    private var _o : Point;
    
    private var _vertices : Vector.<Number>;
    private var _indices : Vector.<int>;
    private var _uvtData : Vector.<Number>;
    
    public function KaleidoscopeImage(width : Number, height : Number, maxNest : int = 16) {
        _width = width;
        _height = height;
        _maxNest = maxNest;
    }

public function draw(g : Graphics, o : Point, a : Point, b : Point, c : Point) : void {

_o = o;
                    
        _vertices = new Vector.<Number>();
        _indices = new Vector.<int>();
        _uvtData = new Vector.<Number>();

var t : Point = get_uvt(a);
         var u : Point = get_uvt(b);
         var v : Point = get_uvt(c);
        
        addTriangle(a, b, c, t, u, v);
                 
        reflect(a, b, c, t, u, v, 0);
        reflect(b, c, a, u, v, t, 0);
        reflect(c, a, b, v, t, u, 0);

g.drawTriangles(_vertices, null, _uvtData);
    }
    
    private function reflect(
        a : Point, b : Point, c : Point,
        t : Point, u : Point, v : Point,
        nest : int
    ) : void {

if (nest > _maxNest) {
            return;
        }

if (!isVisible(a, b, c) ) {
            return;
        }

var ref_c : Point = GeoUtil.getCRef(a, b, c);

var c_bc : Point = GeoUtil.getCrossPoint(_o, a, b, ref_c);
        var c_ac : Point = GeoUtil.getCrossPoint(_o, b, a, ref_c);

var new_c : Point;
        if (c_bc != null) {
            new_c = c_bc;
        } else if (c_ac != null) {
            new_c = c_ac;
        } else {
            new_c = ref_c;
        }

var new_v : Point = GeoUtil.createTransformMatrix(a, b, ref_c, t, u, v)
            .transformPoint(new_c);
        
        addTriangle(a, b, new_c, t, u, new_v);

if (c_bc == null) {
            reflect(new_c, a, b, new_v, t, u, nest + 1);
        }
        if (c_ac == null) {
            reflect(new_c, b, a, new_v, u, t, nest + 1);
        }
    }

private function addTriangle(
        a : Point, b : Point, c : Point,
        t : Point, u : Point, v : Point
    ) : void {
        _vertices.push(a.x, a.y, b.x, b.y, c.x, c.y);
        _indices.push(0, 1, 2);
        _uvtData.push(t.x, t.y, u.x, u.y, v.x, v.y);
    }    
    
    private function get_uvt(p : Point) : Point {
        return new Point(p.x / _width, p.y / _height);        
    }
    
    private function isVisible(a : Point, b : Point, c : Point) : Boolean {

var minX : Number = Math.min(a.x, b.x, c.x);
        var minY : Number = Math.min(a.y, b.y, c.y);
        var maxX : Number = Math.max(a.x, b.x, c.x);
        var maxY : Number = Math.max(a.y, b.y, c.y);
        
        var r1 : Rectangle = new Rectangle(
            0, 0, _width, _height);

var r2 : Rectangle = new Rectangle(
            minX, minY, maxX - minX, maxY - minY);

return r1.intersects(r2);
    }
}

class RandomImage extends Sprite {

public function RandomImage(width : Number, height : Number) {

var colors : Array = [
            0xff0000,
            0xffff00,
            0x00ff00,
            0x00ffff,
            0x0000ff,
            0xff00ff
        ];
        
//        var rand : Function = Math.random;
        var rand : Function = FakeRand.random;

var g : Graphics = graphics;
        
        g.clear();
        
        for (var i : int = 0; i < 100; i++) {

var x : Number = rand() * width;
            var y : Number = rand() * height;
            var r : Number = rand() * 50 + 10;
            var c : uint = colors[i % colors.length];

g.beginFill(c, 0.4);
            g.drawCircle(x, y, r);
            g.endFill();
        }
    }
}

class FakeRand {

private var _num : Number;
    private var _digits : int;
    
    public function FakeRand(seed : Number = 0, digits : int = 10000) {
        _num = Math.exp(seed);
        _digits = digits;
    }
    
    public function next() : Number {
        _num = _num * _digits + Math.PI;
        _num = _num - Math.floor(_num);
        return int(_num * _digits) % _digits / _digits;
    }
    
    private static var _instance : FakeRand = new FakeRand();
    
    public static function random() : Number {
        return _instance.next();
    }
}

class GeoUtil {

public static function getCenter(
        a : Point, b : Point, c : Point
    ) : Point {

var bc : Point = new Point(
            (b.x + c.x) / 2,
            (b.y + c.y) / 2);

return new Point(
            a.x + (bc.x - a.x) * 2 / 3,
            a.y + (bc.y - a.y) * 2 / 3);        
    }

public static function createMatrix(
        a : Point, b : Point, c : Point,
        invert : Boolean = false
    ) : Matrix {

var m : Matrix = new Matrix(
            b.x - a.x, b.y - a.y,
            c.x - a.x, c.y - a.y);

if (invert) {
            m.invert();
        }

return m;
    }
    
    public static function createTransformMatrix(
        a : Point, b : Point, c : Point,
        t : Point, u : Point, v : Point
    ) : Matrix {

var m1 : Matrix = new Matrix();
        m1.translate(-a.x, -a.y);
        m1.concat(createMatrix(a, b, c, true) );
        m1.concat(createMatrix(t, u, v) );
        m1.translate(t.x, t.y);
        
        return m1;
    }

public static function getCRef(
        a : Point, b : Point, c : Point
    ) : Point {

var m1 : Matrix = new Matrix();
        var m2 : Matrix = new Matrix(
            b.x - a.x, b.y - a.y, a.y - b.y, b.x - a.x);
        var m3 : Matrix = new Matrix(1, 0, 0, -1);

m1.translate(-a.x, -a.y);
        
        m2.invert();
        m1.concat(m2);
        
        m1.concat(m3);
        
        m2.invert();
        m1.concat(m2);
        
        m1.translate(a.x, a.y);
        
        return m1.transformPoint(new Point(c.x, c.y) );
    }
    
    public static function getCrossPoint(
        o : Point,
        a : Point, b : Point, c : Point
    ) : Point {
        
        var mat : Matrix = new Matrix(
            a.x - o.x, a.y - o.y,
            c.x - b.x, c.y - b.y);
        
        mat.invert();
        
        var st : Point = mat.transformPoint(b.subtract(o) );
        
        var s : Number = st.x;
        var t : Number = -st.y;
        
        if (0 <= t && t <= 1) {
            return new Point(
                o.x + (a.x - o.x) * s,
                o.y + (a.y - o.y) * s);
        } else {
            return null;
        }
    }
}

class UIPoint extends Sprite {

private var _pressed : Boolean;
    private var _dragX : Number;
    private var _dragY : Number;
    
    public function UIPoint(
        color : uint, x : Number, y : Number, label : String,
        movable : Boolean = false
    ) {

var g : Graphics = graphics;
        g.clear();
        g.lineStyle(2, 0xffffff ^ color);
        g.beginFill(color);
        g.drawCircle(0, 0, 5);
        g.endFill();
        
        var labelField : TextField = new TextField();
        labelField.type = TextFieldType.DYNAMIC;
        labelField.autoSize = TextFieldAutoSize.LEFT;
        labelField.selectable = false;
        labelField.text = label;
        labelField.x = 4;
        labelField.y = 4;
        addChild(labelField);

this.x = x;
        this.y = y;
        
        buttonMode = movable;
        useHandCursor = movable;

if (movable) {
            _pressed = false;
            addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);    
        }
    }
    
    private function mouseDownHandler(event : MouseEvent) : void {

if (_pressed) return;
        
        stage.addEventListener(MouseEvent.MOUSE_UP, stage_mouseUpHandler);
        stage.addEventListener(MouseEvent.MOUSE_MOVE, stage_mouseMoveHandler);
        stage.addEventListener(Event.MOUSE_LEAVE, stage_mouseLeaveHandler);

_dragX = mouseX;
        _dragY = mouseY;
        _pressed = true;
    }

private function stage_mouseMoveHandler(event : MouseEvent) : void {
        x += (mouseX - _dragX);
        y += (mouseY - _dragY);
    }
    
    private function stage_mouseUpHandler(event : MouseEvent) : void {
        releaseMouse();
    }
    
    private function stage_mouseLeaveHandler(event : Event) : void {
        releaseMouse();
    }

private function releaseMouse() : void {

if (!_pressed) return;

stage.removeEventListener(MouseEvent.MOUSE_UP, stage_mouseUpHandler);
        stage.removeEventListener(MouseEvent.MOUSE_MOVE, stage_mouseMoveHandler);
        stage.removeEventListener(Event.MOUSE_LEAVE, stage_mouseLeaveHandler);
        
        _pressed = false;
    }
}

Recommendation

Join Effecthub.com