docs: function DisplayObject()
  {
      EventEmitter.call(this);
  
      /**
       * The coordinate of the object relative to the local coordinates of the parent.
       *
       * @member {Point}
       */
      this.position = new math.Point();
  
      /**
       * The scale factor of the object.
       *
       * @member {Point}
       */
      this.scale = new math.Point(1, 1);
  
      /**
       * The pivot point of the displayObject that it rotates around
       *
       * @member {Point}
       */
      this.pivot = new math.Point(0, 0);
  
      /**
       * The rotation of the object in radians.
       *
       * @member {number}
       */
      this.rotation = 0;
  
      /**
       * The opacity of the object.
       *
       * @member {number}
       */
      this.alpha = 1;
  
      /**
       * The visibility of the object. If false the object will not be drawn, and
       * the updateTransform function will not be called.
       *
       * @member {boolean}
       */
      this.visible = true;
  
      /**
       * Can this object be rendered, if false the object will not be drawn but the updateTransform
       * methods will still be called.
       *
       * @member {boolean}
       */
      this.renderable = true;
  
      /**
       * The display object container that contains this display object.
       *
       * @member {Container}
       * @readOnly
       */
      this.parent = null;
  
      /**
       * The multiplied alpha of the displayObject
       *
       * @member {number}
       * @readOnly
       */
      this.worldAlpha = 1;
  
      /**
       * Current transform of the object based on world (parent) factors
       *
       * @member {Matrix}
       * @readOnly
       */
      this.worldTransform = new math.Matrix();
  
      /**
       * The area the filter is applied to. This is used as more of an optimisation
       * rather than figuring out the dimensions of the displayObject each frame you can set this rectangle
       *
       * @member {Rectangle}
       */
      this.filterArea = null;
  
      /**
       * cached sin rotation
       *
       * @member {number}
       * @private
       */
      this._sr = 0;
  
      /**
       * cached cos rotation
       *
       * @member {number}
       * @private
       */
      this._cr = 1;
  
      /**
       * The original, cached bounds of the object
       *
       * @member {Rectangle}
       * @private
       */
      this._bounds = new math.Rectangle(0, 0, 1, 1);
  
      /**
       * The most up-to-date bounds of the object
       *
       * @member {Rectangle}
       * @private
       */
      this._currentBounds = null;
  
      /**
       * The original, cached mask of the object
       *
       * @member {Rectangle}
       * @private
       */
      this._mask = null;
  
      //TODO rename to _isMask
     // this.isMask = false;
  
      /**
       * Cached internal flag.
       *
       * @member {boolean}
       * @private
       */
      this._cacheAsBitmap = false;
      this._cachedObject = null;
  }