Fuckin' camera

package camera {

    import flash.display.Stage;
    import flash.events.Event;
    import flash.events.KeyboardEvent;
    import flash.events.MouseEvent;
    import flash.filters.DropShadowFilter;
    import flash.geom.Matrix3D;
    import flash.geom.Point;
    import flash.geom.Vector3D;
    import flash.text.TextField;
    import flash.text.TextFieldAutoSize;
    import flash.ui.Keyboard;

    /**
     * @author L'aut con
     * @date 7 sept. 2011;
     */
    public class SimpleFreeCamera {

        private var _stage:Stage;
        private var _pressed:Boolean;
        private var _goForward:Boolean;
        private var _offsetDrag:Point;
        private var _phi:Number;
        private var _theta:Number;
        private var _speed:Number;
        private var _roll:Number;
        private var _up:Vector3D;
        private var _forward:Vector3D;
        private var _position:Vector3D;
        private var _lookAt:Vector3D;
        private var _right:Vector3D;
        private var _rotationMatrix:Matrix3D;
        private var _tf:TextField;




        /* *********** *
         * CONSTRUCTOR *
         * *********** */
        /**
         * Creates an instance of <code>SimpleFreeCamera</code>.
         */
        public function SimpleFreeCamera(stage:Stage) {
            _stage = stage;
            initialize();
        }



        /* ***************** *
         * GETTERS / SETTERS *
         * ***************** */



        /* ****** *
         * PUBLIC *
         * ****** */

        /**
         * Creates the projection matrix.
         *
         * @param viewWidth     viewport width
         * @param viewHeight    viewport height
         * @param orthogonal    get an orthogonal projection (true) or a perspective projection (false)
         */
        public function createProjectionMatrix(viewWidth:Number, viewHeight:Number, orthogonal:Boolean = false):Matrix3D {
            var zNear:Number = 1000;
            var zFar:int = 1;
            if(!orthogonal) {
                var fov:Number = .2;//Math.PI */ 3;
                var w1:Number = (2 * zNear / (zNear * Math.atan(fov) - viewWidth)) / 1.33333;
                var h1:Number = (2 * zNear / (zNear * Math.atan(fov) + viewHeight));
                var q1:Number = -1 * (zFar + zNear) / (zFar - zNear);
                var q2:Number = -2 * (zFar * zNear) / (zFar - zNear);

                return new Matrix3D(Vector.<Number>([w1, 0, 0, 0, 0, h1, 0, 0, 0, 0, q1, q2, 0, 0, -1, 0]));
            }else{
                zNear = 2000;
                zFar = -2000;
                return new Matrix3D(Vector.<Number>
                ([
                2/viewWidth, 0  ,       0,        0,
                0  , 2/viewHeight,       0,        0,
                0  , 0  ,       1/(zFar-zNear),           0,
                0  , 0  ,       zNear/(zNear-zFar),        1
                ]));
            }
        }

        public function getProjectionMatrix(viewWidth:Number, viewHeight:Number, orthogonal:Boolean = false):Matrix3D {
            var m:Matrix3D = new Matrix3D();
            m.appendTranslation(_position.x, _position.y, _position.z);
            m.append(_rotationMatrix);
//          m.appendRotation(_phi / Math.PI * 180, Vector3D.X_AXIS);
//          m.appendRotation(_theta / Math.PI * 180, Vector3D.Z_AXIS);
//          m.append(createProjectionMatrix(viewWidth, viewHeight, orthogonal));
            m.append(createProjectionMatrix(viewWidth, viewHeight, orthogonal));
            return m;
        }




        /* ******* *
         * PRIVATE *
         * ******* */
        /**
         * Initialize the class.
         */
        private function initialize():void {
            _roll = 0;
            _position = new Vector3D(-50,-50,6);
            _up = new Vector3D();
            _forward = new Vector3D();
            _lookAt = new Vector3D(0,0,0);

            _tf = _stage.addChild(new TextField()) as TextField;
            _tf.autoSize = TextFieldAutoSize.LEFT;
            _tf.textColor = 0xffffff;

            _speed = 2;
            _phi = 2*Math.PI;
            _theta = 0;
            _stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseEventHandler);
            _stage.addEventListener(MouseEvent.MOUSE_UP, mouseEventHandler);
            _stage.addEventListener(KeyboardEvent.KEY_DOWN, keyboardEventHandler);
            _stage.addEventListener(KeyboardEvent.KEY_UP, keyboardEventHandler);
            _stage.addEventListener(Event.ENTER_FRAME, enterFrameHandler);
        }

        /**
         * Called on a mouse event.
         */
        private function mouseEventHandler(event:MouseEvent):void {
            if(event.type == MouseEvent.MOUSE_DOWN) {
                _pressed = true;
                _offsetDrag = new Point(_stage.mouseX, _stage.mouseY);
            }else{
                _pressed = false;
            }
        }

        /**
         * Called on a keyboard event.
         */
        private function keyboardEventHandler(event:KeyboardEvent):void {
            if(event.type == KeyboardEvent.KEY_DOWN) {
                if(event.keyCode == Keyboard.UP) _goForward = true;
            }else{
                if(event.keyCode == Keyboard.UP) _goForward = false;
            }

            switch(event.keyCode){
                case Keyboard.LEFT: _position.x ++; break;
                case Keyboard.RIGHT: _position.x --; break;
                case Keyboard.UP: _position.y ++; break;
                case Keyboard.DOWN: _position.y --; break;
                case Keyboard.Q: _lookAt.z ++; break;
                case Keyboard.D: _lookAt.z --; break;
                case Keyboard.Z: _lookAt.y ++; break;
                case Keyboard.S: _lookAt.y --; break;
                case Keyboard.W: _lookAt.x ++; break;
                case Keyboard.X: _lookAt.x --; break;
                case Keyboard.PAGE_UP: _roll += .05; break;
                case Keyboard.PAGE_DOWN: _roll -= .05; break;
                default:
            }
        }

        /**
         * Called on ENTER_FRAME event
         *
         * Formulas source : http://mathworld.wolfram.com/SphericalCoordinates.html
         */
        private function enterFrameHandler(event:Event):void {
            if(_pressed) {
                _phi += Math.min((_stage.mouseX - _offsetDrag.x), 600) / 600 * Math.PI * .1;
                _theta += Math.min((_stage.mouseY - _offsetDrag.y), 600) / 600 * Math.PI * .1;
                _roll += Math.min((_stage.mouseX - _offsetDrag.x), 600) / 600 * Math.PI * .1;
//              _position.z += Math.min((_stage.mouseY - _offsetDrag.y), 200) / 200 * 2;
//              _theta += Math.min((_stage.mouseX - _offsetDrag.x), 600) / 200 * Math.PI * .01;
//              _theta = _theta % (Math.PI * 2);
//              _phi += Math.min((_stage.mouseY - _offsetDrag.y), 600) / 200 * Math.PI * .01;
//              _phi = _phi % Math.PI;
            }
            _lookAt.x = _position.x - Math.cos(_phi) * 200;
            _lookAt.y = _position.y - Math.sin(_phi) * 200;
            _lookAt.z = _position.z + Math.sin(Math.max(Math.min(_theta, Math.PI), -Math.PI)) * 200;
            if(_goForward) {
//              _x += Math.cos(_theta) * Math.sin(_phi) * _speed;
//              _y += Math.sin(_theta) * Math.cos(_phi) * _speed;
//              _z += Math.cos(_phi) * _speed;
            }
//          _lookAt.x = _position.x + Math.sin(_roll) * 10;
//          _lookAt.y = _position.y - Math.cos(_roll) * 10;

            _up.x = Math.sin(_roll);
            _up.z = -Math.cos(_roll);
            _up.y = 0;

            _forward.x = _lookAt.x - _position.x;
            _forward.y = _lookAt.y - _position.y;
            _forward.z = _lookAt.z - _position.z;
            _forward.normalize();

            _right = _up.crossProduct(_forward);
            _right.normalize();

            _up = _right.crossProduct(_forward);
            _up.normalize();

            _rotationMatrix = new Matrix3D();
//          _rotationMatrix.pointAt(_position, _lookAt, _up);
            _rotationMatrix = new Matrix3D(Vector.<Number>([_up.x, _up.y, _up.z, 0,
                                                            _right.x, _right.y, _right.z, 0,
                                                            _forward.x, _forward.y, _forward.z, 0,
                                                            0, 0, 0, 1
                                                            ]));
        }

    }
}