#

API Docs for: 1.4.3
Show: Inherited Protected Private Deprecated

# File: src/pixi/display/DisplayObject.js

    /**
     * @author Mat Groves http://matgroves.com/ @Doormat23
     */

    /**
     * The base class for all objects that are rendered on the screen.
     *
     * @class DisplayObject
     * @constructor
     */
    PIXI.DisplayObject = function()
    {
        this.last = this;
        this.first = this;
        /**
         * The coordinate of the object relative to the local coordinates of the parent.
         *
         * @property position
         * @type Point
         */
        this.position = new PIXI.Point();

        /**
         * The scale factor of the object.
         *
         * @property scale
         * @type Point
         */
        this.scale = new PIXI.Point(1,1);//{x:1, y:1};

        /**
         * The pivot point of the displayObject that it rotates around
         *
         * @property pivot
         * @type Point
         */
        this.pivot = new PIXI.Point(0,0);

        /**
         * The rotation of the object in radians.
         *
         * @property rotation
         * @type Number
         */
        this.rotation = 0;

        /**
         * The opacity of the object.
         *
         * @property alpha
         * @type Number
         */
        this.alpha = 1;

        /**
         * The visibility of the object.
         *
         * @property visible
         * @type Boolean
         */
        this.visible = true;

        /**
         * This is the defined area that will pick up mouse / touch events. It is null by default.
         * Setting it is a neat way of optimising the hitTest function that the interactionManager will use (as it will not need to hit test all the children)
         *
         * @property hitArea
         * @type Rectangle|Circle|Ellipse|Polygon
         */
        this.hitArea = null;

        /**
         * This is used to indicate if the displayObject should display a mouse hand cursor on rollover
         *
         * @property buttonMode
         * @type Boolean
         */
        this.buttonMode = false;

        /**
         * Can this object be rendered
         *
         * @property renderable
         * @type Boolean
         */
        this.renderable = false;

        /**
         * [read-only] The display object container that contains this display object.
         *
         * @property parent
         * @type DisplayObjectContainer
         * @readOnly
         */
        this.parent = null;

        /**
         * [read-only] The stage the display object is connected to, or undefined if it is not connected to the stage.
         *
         * @property stage
         * @type Stage
         * @readOnly
         */
        this.stage = null;

        /**
         * [read-only] The multiplied alpha of the displayObject
         *
         * @property worldAlpha
         * @type Number
         * @readOnly
         */
        this.worldAlpha = 1;

        /**
         * [read-only] Whether or not the object is interactive, do not toggle directly! use the `interactive` property
         *
         * @property _interactive
         * @type Boolean
         * @readOnly
         * @private
         */
        this._interactive = false;

        /**
         * This is the cursor that will be used when the mouse is over this object. To enable this the element must have interaction = true and buttonMode = true
         *
         * @property defaultCursor
         * @type String
         *
        */
        this.defaultCursor = 'pointer';

        /**
         * [read-only] Current transform of the object based on world (parent) factors
         *
         * @property worldTransform
         * @type Mat3
         * @readOnly
         * @private
         */
        this.worldTransform = PIXI.mat3.create(); //mat3.identity();

        /**
         * [read-only] Current transform of the object locally
         *
         * @property localTransform
         * @type Mat3
         * @readOnly
         * @private
         */
        this.localTransform = PIXI.mat3.create(); //mat3.identity();

        /**
         * [NYI] Unknown
         *
         * @property color
         * @type Array<>
         * @private
         */
        this.color = [];

        /**
         * [NYI] Holds whether or not this object is dynamic, for rendering optimization
         *
         * @property dynamic
         * @type Boolean
         * @private
         */
        this.dynamic = true;

        // cached sin rotation and cos rotation
        this._sr = 0;
        this._cr = 1;

        this.filterArea = new PIXI.Rectangle(0,0,1,1);

        this._bounds = new PIXI.Rectangle(0, 0, 1, 1);
        this._currentBounds = null;
        this._mask = null;

        /*
         * MOUSE Callbacks
         */

        /**
         * A callback that is used when the users clicks on the displayObject with their mouse
         * @method click
         * @param interactionData {InteractionData}
         */

        /**
         * A callback that is used when the user clicks the mouse down over the sprite
         * @method mousedown
         * @param interactionData {InteractionData}
         */

        /**
         * A callback that is used when the user releases the mouse that was over the displayObject
         * for this callback to be fired the mouse must have been pressed down over the displayObject
         * @method mouseup
         * @param interactionData {InteractionData}
         */

        /**
         * A callback that is used when the user releases the mouse that was over the displayObject but is no longer over the displayObject
         * for this callback to be fired, The touch must have started over the displayObject
         * @method mouseupoutside
         * @param interactionData {InteractionData}
         */

        /**
         * A callback that is used when the users mouse rolls over the displayObject
         * @method mouseover
         * @param interactionData {InteractionData}
         */

        /**
         * A callback that is used when the users mouse leaves the displayObject
         * @method mouseout
         * @param interactionData {InteractionData}
         */

        /*
         * TOUCH Callbacks
         */

        /**
         * A callback that is used when the users taps on the sprite with their finger
         * basically a touch version of click
         * @method tap
         * @param interactionData {InteractionData}
         */

        /**
         * A callback that is used when the user touches over the displayObject
         * @method touchstart
         * @param interactionData {InteractionData}
         */

        /**
         * A callback that is used when the user releases a touch over the displayObject
         * @method touchend
         * @param interactionData {InteractionData}
         */

        /**
         * A callback that is used when the user releases the touch that was over the displayObject
         * for this callback to be fired, The touch must have started over the sprite
         * @method touchendoutside
         * @param interactionData {InteractionData}
         */
    };

    // constructor
    PIXI.DisplayObject.prototype.constructor = PIXI.DisplayObject;

    /**
     * [Deprecated] Indicates if the sprite will have touch and mouse interactivity. It is false by default
     * Instead of using this function you can now simply set the interactive property to true or false
     *
     * @method setInteractive
     * @param interactive {Boolean}
     * @deprecated Simply set the `interactive` property directly
     */
    PIXI.DisplayObject.prototype.setInteractive = function(interactive)
    {
        this.interactive = interactive;
    };

    /**
     * Indicates if the sprite will have touch and mouse interactivity. It is false by default
     *
     * @property interactive
     * @type Boolean
     * @default false
     */
    Object.defineProperty(PIXI.DisplayObject.prototype, 'interactive', {
        get: function() {
            return this._interactive;
        },
        set: function(value) {
            this._interactive = value;

            // TODO more to be done here..
            // need to sort out a re-crawl!
            if(this.stage)this.stage.dirty = true;
        }
    });

    /**
     * [read-only] Indicates if the sprite is globaly visible.
     *
     * @property worldVisible
     * @type Boolean
     */
    Object.defineProperty(PIXI.DisplayObject.prototype, 'worldVisible', {
        get: function() {
            var item = this;

            do
            {
                if(!item.visible)return false;
                item = item.parent;
            }
            while(item);

            return true;
        }
    });

    /**
     * Sets a mask for the displayObject. A mask is an object that limits the visibility of an object to the shape of the mask applied to it.
     * In PIXI a regular mask must be a PIXI.Graphics object. This allows for much faster masking in canvas as it utilises shape clipping.
     * To remove a mask, set this property to null.
     *
     * @property mask
     * @type Graphics
     */
    Object.defineProperty(PIXI.DisplayObject.prototype, 'mask', {
        get: function() {
            return this._mask;
        },
        set: function(value) {

            if(this._mask)this._mask.isMask = false;
            this._mask = value;
            if(this._mask)this._mask.isMask = true;
        }
    });

    /**
     * Sets the filters for the displayObject.
     * * IMPORTANT: This is a webGL only feature and will be ignored by the canvas renderer.
     * To remove filters simply set this property to 'null'
     * @property filters
     * @type Array An array of filters
     */
    Object.defineProperty(PIXI.DisplayObject.prototype, 'filters', {
        get: function() {
            return this._filters;
        },
        set: function(value) {

            if(value)
            {
                // now put all the passes in one place..
                var passes = [];
                for (var i = 0; i < value.length; i++)
                {
                    var filterPasses = value[i].passes;
                    for (var j = 0; j < filterPasses.length; j++)
                    {
                        passes.push(filterPasses[j]);
                    }
                }

                // TODO change this as it is legacy
                this._filterBlock = {target:this, filterPasses:passes};
            }

            this._filters = value;
        }
    });

    /*
     * Updates the object transform for rendering
     *
     * @method updateTransform
     * @private
     */
    PIXI.DisplayObject.prototype.updateTransform = function()
    {
        // TODO OPTIMIZE THIS!! with dirty
        if(this.rotation !== this.rotationCache)
        {
            this.rotationCache = this.rotation;
            this._sr =  Math.sin(this.rotation);
            this._cr =  Math.cos(this.rotation);
        }

        var localTransform = this.localTransform;
        var parentTransform = this.parent.worldTransform;
        var worldTransform = this.worldTransform;
        //console.log(localTransform)
        localTransform[0] = this._cr * this.scale.x;
        localTransform[1] = -this._sr * this.scale.y;
        localTransform[3] = this._sr * this.scale.x;
        localTransform[4] = this._cr * this.scale.y;

        // TODO --> do we even need a local matrix???

        var px = this.pivot.x;
        var py = this.pivot.y;

        // Cache the matrix values (makes for huge speed increases!)
        var a00 = localTransform[0], a01 = localTransform[1], a02 = this.position.x - localTransform[0] * px - py * localTransform[1],
            a10 = localTransform[3], a11 = localTransform[4], a12 = this.position.y - localTransform[4] * py - px * localTransform[3],

            b00 = parentTransform[0], b01 = parentTransform[1], b02 = parentTransform[2],
            b10 = parentTransform[3], b11 = parentTransform[4], b12 = parentTransform[5];

        localTransform[2] = a02;
        localTransform[5] = a12;

        worldTransform[0] = b00 * a00 + b01 * a10;
        worldTransform[1] = b00 * a01 + b01 * a11;
        worldTransform[2] = b00 * a02 + b01 * a12 + b02;

        worldTransform[3] = b10 * a00 + b11 * a10;
        worldTransform[4] = b10 * a01 + b11 * a11;
        worldTransform[5] = b10 * a02 + b11 * a12 + b12;

        // because we are using affine transformation, we can optimise the matrix concatenation process.. wooo!
        // mat3.multiply(this.localTransform, this.parent.worldTransform, this.worldTransform);
        this.worldAlpha = this.alpha * this.parent.worldAlpha;
    };

    PIXI.DisplayObject.prototype.getBounds = function()
    {
        return PIXI.EmptyRectangle;
    };

    PIXI.DisplayObject.prototype.getLocalBounds = function()
    {
        var matrixCache = this.worldTransform;

        this.worldTransform = PIXI.identityMatrix;

        this.updateTransform();

        var bounds = this.getBounds();

        this.worldTransform = matrixCache;

        return bounds;
    };

    PIXI.DisplayObject.prototype.setStageReference = function(stage)
    {
        this.stage = stage;
        if(this._interactive)this.stage.dirty = true;
    };

    PIXI.DisplayObject.prototype._renderWebGL = function(renderSession)
    {
        // OVERWRITE;
        // this line is just here to pass jshinting :)
        renderSession = renderSession;
    };

    PIXI.DisplayObject.prototype._renderCanvas = function(renderSession)
    {
        // OVERWRITE;
        // this line is just here to pass jshinting :)
        renderSession = renderSession;
    };

    PIXI.EmptyRectangle = new PIXI.Rectangle(0,0,0,0);