Genome2d > GCamera mask

package {

    import com.genome2d.components.GCamera;
    import com.genome2d.components.renderables.GSprite;
    import com.genome2d.core.GConfig;
    import com.genome2d.core.GNode;
    import com.genome2d.core.GNodeFactory;
    import com.genome2d.core.Genome2D;
    import com.genome2d.textures.factories.GTextureFactory;
    import com.greensock.TweenMax;
    import com.greensock.easing.Back;

    import flash.display.BitmapData;
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageQuality;
    import flash.display.StageScaleMode;
    import flash.events.KeyboardEvent;
    import flash.events.MouseEvent;
    import flash.geom.Rectangle;
    import flash.text.TextField;
    import flash.text.TextFormat;
    import flash.ui.Keyboard;

    [SWF(width="800", height="600", backgroundColor="#323232", frameRate="60")]
    public class Main extends Sprite {

        private var viewport: Rectangle;
        private var _cams: Vector.<GCamera> = new Vector.<GCamera>();
        private var container: GNode;
        private var showAll: Boolean = false;
        private var showAllCameras: Boolean = true;

        public function Main() {
            init();
        }

        private function init(): void {
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
            stage.quality = StageQuality.LOW;
            stage.showDefaultContextMenu = false;
            initGenome();
        }

        private function initGenome(): void {
            viewport = new Rectangle(0, 0, 800, 600);
            var config: GConfig = new GConfig(viewport);
            config.showExtendedStats = true;
            config.enableStats = true;
            config.backgroundColor = stage.color;
            Genome2D.getInstance().onInitialized.addOnce(onInit);
            Genome2D.getInstance().init(stage, config);
        }

        private function onInit(): void {

            createTextures();

            // create 4 cameras.
            addCamera(1, 0xFF0000);
            addCamera(2, 0xFFDD00);
            addCamera(4, 0x0000FF);
            addCamera(8, 0x00FF00);

            // adjust the viewports.
            var viewW: Number = 1 / _cams.length;
            for (var i: int = 0; i < _cams.length; i++) {
                var cam: GCamera = _cams[i];
                cam.normalizedViewWidth = viewW;
                cam.normalizedViewX = i * viewW;
                var zoom: Number = 0.5 + Math.random() * 1.5;
                //normalizedViewWidth: 0.1 + Math.random() * 0.4, normalizedViewX: 0.2 + Math.random() * 0.5,
                TweenMax.to(cam, 0.5 + Math.random(), {  zoom: zoom, yoyo: true, repeat: -1});
//              TweenMax.to( cam.node.transform, 1, { x:'30', y:'30', yoyo:true, repeat:-1});
            }

            container = GNodeFactory.createNode();
            Genome2D.getInstance().root.addChild(container);

            // add objects.
            for (i = 0; i < 4; i++) {
                var spr: GSprite = GNodeFactory.createNodeWithComponent(GSprite) as GSprite;
                spr.textureId = 'box' + i;
                var twn: Object = {};
                twn.x = String(Math.random() * 120 - 60);
                twn.ease = Back.easeOut;
                twn.yoyo = true;
                twn.repeat = -1;
                TweenMax.to(spr.node.transform, 0.8, twn);

                spr.node.cameraGroup = Math.pow(2, i);
                container.addChild(spr.node);
                spr.node.userData.idx = i;
                spr.node.transform.y = -150 + i * 100;
            }

            stage.addEventListener(MouseEvent.CLICK, onStageClick);
            stage.addEventListener(KeyboardEvent.KEY_DOWN, handleKey);
            Genome2D.getInstance().onPreUpdate.add(onUpdate);
        }

        private function handleKey(event: KeyboardEvent): void {
            if (event.keyCode == Keyboard.SPACE) {
                toggleCameras();
            }
        }


        private function toggleCameras(): void {
            showAllCameras = !showAllCameras;
            var viewW: Number = 1 / _cams.length;
            TweenMax.to(_cams[0], 1, { normalizedViewWidth: showAllCameras ? viewW : 1 });
//          _cams[0].active
            for (var i: int = 1; i < _cams.length; i++) {
                _cams[i].node.active = showAllCameras;
            }

        }

        private function onUpdate(t: int): void {
            _cams[2].node.transform.rotation += .01;
        }


        private function onStageClick(event: MouseEvent): void {
            showAll = !showAll;
            for (var child: GNode = container.firstChild; child != null; child = child.next) {
                child.cameraGroup = showAll ? 0 : Math.pow(2, child.userData.idx);
            }
        }

        private function createTextures(): void {
            // create 4 cube textures.
            var bd: BitmapData;
            var spr: Sprite = new Sprite();
            spr.graphics.beginFill(0x0);
            spr.graphics.drawRoundRect(0, 0, 64, 64, 12);
            spr.graphics.endFill();
            var tf: TextField = new TextField();
            tf.defaultTextFormat = new TextFormat('Arial', 20, 0xFF0000);
            tf.autoSize = 'left';
            spr.addChild(tf);

            bd = new BitmapData(64, 64, true, 0x0);
            for (var i: int = 0; i < 4; i++) {
                tf.text = String(i + 1);
                bd.draw(spr);
                GTextureFactory.createFromBitmapData('box' + i, bd);
            }
        }

        private function onStageClick(event: MouseEvent): void {
            showAll = !showAll;
            for (var child: GNode = container.firstChild; child != null; child = child.next) {
                child.cameraGroup = showAll ? 0 : Math.pow(2, child.userData.idx);
            }
        }

        private function addCamera(pMask: int, pColor: uint): void {
            var cam: GCamera = GNodeFactory.createNodeWithComponent(GCamera) as GCamera;
            Genome2D.getInstance().root.addChild(cam.node);
            cam.mask = pMask;
            cam.backgroundRed = (( pColor & 0xFF0000 ) >> 16 ) / 255;
            cam.backgroundGreen = (( pColor & 0x00FF00 ) >> 8 ) / 255;
            cam.backgroundBlue = ( pColor & 0x0000FF ) / 255;
            cam.backgroundAlpha = 0.0001;
            _cams.push(cam);
        }
    }
}