'use strict';
exports.__esModule = true;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _eventemitter = require('eventemitter3');
var _eventemitter2 = _interopRequireDefault(_eventemitter);
var _const = require('../const');
var _settings = require('../settings');
var _settings2 = _interopRequireDefault(_settings);
var _TransformStatic = require('./TransformStatic');
var _TransformStatic2 = _interopRequireDefault(_TransformStatic);
var _Transform = require('./Transform');
var _Transform2 = _interopRequireDefault(_Transform);
var _Bounds = require('./Bounds');
var _Bounds2 = _interopRequireDefault(_Bounds);
var _math = require('../math');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
// _tempDisplayObjectParent = new DisplayObject();
/**
* The base class for all objects that are rendered on the screen.
* This is an abstract class and should not be used on its own rather it should be extended.
*
* @class
* @extends EventEmitter
* @mixes PIXI.interaction.interactiveTarget
* @memberof PIXI
*/
var DisplayObject = function (_EventEmitter) {
_inherits(DisplayObject, _EventEmitter);
/**
*
*/
function DisplayObject() {
_classCallCheck(this, DisplayObject);
var _this = _possibleConstructorReturn(this, _EventEmitter.call(this));
var TransformClass = _settings2.default.TRANSFORM_MODE === _const.TRANSFORM_MODE.STATIC ? _TransformStatic2.default : _Transform2.default;
_this.tempDisplayObjectParent = null;
// TODO: need to create Transform from factory
/**
* World transform and local transform of this object.
* This will become read-only later, please do not assign anything there unless you know what are you doing
*
* @member {PIXI.TransformBase}
*/
_this.transform = new TransformClass();
/**
* 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.
*
* Only affects recursive calls from parent. You can ask for bounds or call updateTransform manually
*
* @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.
*
* Only affects recursive calls from parent. You can ask for bounds manually
*
* @member {boolean}
*/
_this.renderable = true;
/**
* The display object container that contains this display object.
*
* @member {PIXI.Container}
* @readonly
*/
_this.parent = null;
/**
* The multiplied alpha of the displayObject
*
* @member {number}
* @readonly
*/
_this.worldAlpha = 1;
/**
* 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
*
* Also works as an interaction mask
*
* @member {PIXI.Rectangle}
*/
_this.filterArea = null;
_this._filters = null;
_this._enabledFilters = null;
/**
* The bounds object, this is used to calculate and store the bounds of the displayObject
*
* @member {PIXI.Rectangle}
* @private
*/
_this._bounds = new _Bounds2.default();
_this._boundsID = 0;
_this._lastBoundsID = -1;
_this._boundsRect = null;
_this._localBoundsRect = null;
/**
* The original, cached mask of the object
*
* @member {PIXI.Rectangle}
* @private
*/
_this._mask = null;
return _this;
}
/**
* @private
* @member {PIXI.DisplayObject}
*/
/**
* Updates the object transform for rendering
*
* TODO - Optimization pass!
*/
DisplayObject.prototype.updateTransform = function updateTransform() {
this.transform.updateTransform(this.parent.transform);
// multiply the alphas..
this.worldAlpha = this.alpha * this.parent.worldAlpha;
this._bounds.updateID++;
};
/**
* recursively updates transform of all objects from the root to this one
* internal function for toLocal()
*/
DisplayObject.prototype._recursivePostUpdateTransform = function _recursivePostUpdateTransform() {
if (this.parent) {
this.parent._recursivePostUpdateTransform();
this.transform.updateTransform(this.parent.transform);
} else {
this.transform.updateTransform(this._tempDisplayObjectParent.transform);
}
};
/**
* Retrieves the bounds of the displayObject as a rectangle object.
*
* @param {boolean} skipUpdate - setting to true will stop the transforms of the scene graph from
* being updated. This means the calculation returned MAY be out of date BUT will give you a
* nice performance boost
* @param {PIXI.Rectangle} rect - Optional rectangle to store the result of the bounds calculation
* @return {PIXI.Rectangle} the rectangular bounding area
*/
DisplayObject.prototype.getBounds = function getBounds(skipUpdate, rect) {
if (!skipUpdate) {
if (!this.parent) {
this.parent = this._tempDisplayObjectParent;
this.updateTransform();
this.parent = null;
} else {
this._recursivePostUpdateTransform();
this.updateTransform();
}
}
if (this._boundsID !== this._lastBoundsID) {
this.calculateBounds();
}
if (!rect) {
if (!this._boundsRect) {
this._boundsRect = new _math.Rectangle();
}
rect = this._boundsRect;
}
return this._bounds.getRectangle(rect);
};
/**
* Retrieves the local bounds of the displayObject as a rectangle object
*
* @param {PIXI.Rectangle} [rect] - Optional rectangle to store the result of the bounds calculation
* @return {PIXI.Rectangle} the rectangular bounding area
*/
DisplayObject.prototype.getLocalBounds = function getLocalBounds(rect) {
var transformRef = this.transform;
var parentRef = this.parent;
this.parent = null;
this.transform = this._tempDisplayObjectParent.transform;
if (!rect) {
if (!this._localBoundsRect) {
this._localBoundsRect = new _math.Rectangle();
}
rect = this._localBoundsRect;
}
var bounds = this.getBounds(false, rect);
this.parent = parentRef;
this.transform = transformRef;
return bounds;
};
/**
* Calculates the global position of the display object
*
* @param {PIXI.Point} position - The world origin to calculate from
* @param {PIXI.Point} [point] - A Point object in which to store the value, optional
* (otherwise will create a new Point)
* @param {boolean} [skipUpdate=false] - Should we skip the update transform.
* @return {PIXI.Point} A point object representing the position of this object
*/
DisplayObject.prototype.toGlobal = function toGlobal(position, point) {
var skipUpdate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
if (!skipUpdate) {
this._recursivePostUpdateTransform();
// this parent check is for just in case the item is a root object.
// If it is we need to give it a temporary parent so that displayObjectUpdateTransform works correctly
// this is mainly to avoid a parent check in the main loop. Every little helps for performance :)
if (!this.parent) {
this.parent = this._tempDisplayObjectParent;
this.displayObjectUpdateTransform();
this.parent = null;
} else {
this.displayObjectUpdateTransform();
}
}
// don't need to update the lot
return this.worldTransform.apply(position, point);
};
/**
* Calculates the local position of the display object relative to another point
*
* @param {PIXI.Point} position - The world origin to calculate from
* @param {PIXI.DisplayObject} [from] - The DisplayObject to calculate the global position from
* @param {PIXI.Point} [point] - A Point object in which to store the value, optional
* (otherwise will create a new Point)
* @param {boolean} [skipUpdate=false] - Should we skip the update transform
* @return {PIXI.Point} A point object representing the position of this object
*/
DisplayObject.prototype.toLocal = function toLocal(position, from, point, skipUpdate) {
if (from) {
position = from.toGlobal(position, point, skipUpdate);
}
if (!skipUpdate) {
this._recursivePostUpdateTransform();
// this parent check is for just in case the item is a root object.
// If it is we need to give it a temporary parent so that displayObjectUpdateTransform works correctly
// this is mainly to avoid a parent check in the main loop. Every little helps for performance :)
if (!this.parent) {
this.parent = this._tempDisplayObjectParent;
this.displayObjectUpdateTransform();
this.parent = null;
} else {
this.displayObjectUpdateTransform();
}
}
// simply apply the matrix..
return this.worldTransform.applyInverse(position, point);
};
/**
* Renders the object using the WebGL renderer
*
* @param {PIXI.WebGLRenderer} renderer - The renderer
*/
DisplayObject.prototype.renderWebGL = function renderWebGL(renderer) // eslint-disable-line no-unused-vars
{}
// OVERWRITE;
/**
* Renders the object using the Canvas renderer
*
* @param {PIXI.CanvasRenderer} renderer - The renderer
*/
;
DisplayObject.prototype.renderCanvas = function renderCanvas(renderer) // eslint-disable-line no-unused-vars
{}
// OVERWRITE;
/**
* Set the parent Container of this DisplayObject
*
* @param {PIXI.Container} container - The Container to add this DisplayObject to
* @return {PIXI.Container} The Container that this DisplayObject was added to
*/
;
DisplayObject.prototype.setParent = function setParent(container) {
if (!container || !container.addChild) {
throw new Error('setParent: Argument must be a Container');
}
container.addChild(this);
return container;
};
/**
* Convenience function to set the position, scale, skew and pivot at once.
*
* @param {number} [x=0] - The X position
* @param {number} [y=0] - The Y position
* @param {number} [scaleX=1] - The X scale value
* @param {number} [scaleY=1] - The Y scale value
* @param {number} [rotation=0] - The rotation
* @param {number} [skewX=0] - The X skew value
* @param {number} [skewY=0] - The Y skew value
* @param {number} [pivotX=0] - The X pivot value
* @param {number} [pivotY=0] - The Y pivot value
* @return {PIXI.DisplayObject} The DisplayObject instance
*/
DisplayObject.prototype.setTransform = function setTransform() {
var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
var scaleX = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
var scaleY = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
var rotation = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
var skewX = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
var skewY = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
var pivotX = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 0;
var pivotY = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : 0;
this.position.x = x;
this.position.y = y;
this.scale.x = !scaleX ? 1 : scaleX;
this.scale.y = !scaleY ? 1 : scaleY;
this.rotation = rotation;
this.skew.x = skewX;
this.skew.y = skewY;
this.pivot.x = pivotX;
this.pivot.y = pivotY;
return this;
};
/**
* Base destroy method for generic display objects. This will automatically
* remove the display object from its parent Container as well as remove
* all current event listeners and internal references. Do not use a DisplayObject
* after calling `destroy`.
*
*/
DisplayObject.prototype.destroy = function destroy() {
this.removeAllListeners();
if (this.parent) {
this.parent.removeChild(this);
}
this.transform = null;
this.parent = null;
this._bounds = null;
this._currentBounds = null;
this._mask = null;
this.filterArea = null;
this.interactive = false;
this.interactiveChildren = false;
};
/**
* The position of the displayObject on the x axis relative to the local coordinates of the parent.
* An alias to position.x
*
* @member {number}
* @memberof PIXI.DisplayObject#
*/
_createClass(DisplayObject, [{
key: '_tempDisplayObjectParent',
get: function get() {
if (this.tempDisplayObjectParent === null) {
this.tempDisplayObjectParent = new DisplayObject();
}
return this.tempDisplayObjectParent;
}
}, {
key: 'x',
get: function get() {
return this.position.x;
}
/**
* Sets the X position of the object.
*
* @param {number} value - The value to set to.
*/
,
set: function set(value) {
this.transform.position.x = value;
}
/**
* The position of the displayObject on the y axis relative to the local coordinates of the parent.
* An alias to position.y
*
* @member {number}
* @memberof PIXI.DisplayObject#
*/
}, {
key: 'y',
get: function get() {
return this.position.y;
}
/**
* Sets the Y position of the object.
*
* @param {number} value - The value to set to.
*/
,
set: function set(value) {
this.transform.position.y = value;
}
/**
* Current transform of the object based on world (parent) factors
*
* @member {PIXI.Matrix}
* @memberof PIXI.DisplayObject#
* @readonly
*/
}, {
key: 'worldTransform',
get: function get() {
return this.transform.worldTransform;
}
/**
* Current transform of the object based on local factors: position, scale, other stuff
*
* @member {PIXI.Matrix}
* @memberof PIXI.DisplayObject#
* @readonly
*/
}, {
key: 'localTransform',
get: function get() {
return this.transform.localTransform;
}
/**
* The coordinate of the object relative to the local coordinates of the parent.
* Assignment by value since pixi-v4.
*
* @member {PIXI.Point|PIXI.ObservablePoint}
* @memberof PIXI.DisplayObject#
*/
}, {
key: 'position',
get: function get() {
return this.transform.position;
}
/**
* Copies the point to the position of the object.
*
* @param {PIXI.Point} value - The value to set to.
*/
,
set: function set(value) {
this.transform.position.copy(value);
}
/**
* The scale factor of the object.
* Assignment by value since pixi-v4.
*
* @member {PIXI.Point|PIXI.ObservablePoint}
* @memberof PIXI.DisplayObject#
*/
}, {
key: 'scale',
get: function get() {
return this.transform.scale;
}
/**
* Copies the point to the scale of the object.
*
* @param {PIXI.Point} value - The value to set to.
*/
,
set: function set(value) {
this.transform.scale.copy(value);
}
/**
* The pivot point of the displayObject that it rotates around
* Assignment by value since pixi-v4.
*
* @member {PIXI.Point|PIXI.ObservablePoint}
* @memberof PIXI.DisplayObject#
*/
}, {
key: 'pivot',
get: function get() {
return this.transform.pivot;
}
/**
* Copies the point to the pivot of the object.
*
* @param {PIXI.Point} value - The value to set to.
*/
,
set: function set(value) {
this.transform.pivot.copy(value);
}
/**
* The skew factor for the object in radians.
* Assignment by value since pixi-v4.
*
* @member {PIXI.ObservablePoint}
* @memberof PIXI.DisplayObject#
*/
}, {
key: 'skew',
get: function get() {
return this.transform.skew;
}
/**
* Copies the point to the skew of the object.
*
* @param {PIXI.Point} value - The value to set to.
*/
,
set: function set(value) {
this.transform.skew.copy(value);
}
/**
* The rotation of the object in radians.
*
* @member {number}
* @memberof PIXI.DisplayObject#
*/
}, {
key: 'rotation',
get: function get() {
return this.transform.rotation;
}
/**
* Sets the rotation of the object.
*
* @param {number} value - The value to set to.
*/
,
set: function set(value) {
this.transform.rotation = value;
}
/**
* Indicates if the object is globally visible.
*
* @member {boolean}
* @memberof PIXI.DisplayObject#
* @readonly
*/
}, {
key: 'worldVisible',
get: function get() {
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 or a PIXI.Sprite object. This allows for much faster masking in canvas as it
* utilises shape clipping. To remove a mask, set this property to null.
*
* @todo For the moment, PIXI.CanvasRenderer doesn't support PIXI.Sprite as mask.
*
* @member {PIXI.Graphics|PIXI.Sprite}
* @memberof PIXI.DisplayObject#
*/
}, {
key: 'mask',
get: function get() {
return this._mask;
}
/**
* Sets the mask.
*
* @param {PIXI.Graphics|PIXI.Sprite} value - The value to set to.
*/
,
set: function set(value) {
if (this._mask) {
this._mask.renderable = true;
}
this._mask = value;
if (this._mask) {
this._mask.renderable = false;
}
}
/**
* 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'
*
* @member {PIXI.Filter[]}
* @memberof PIXI.DisplayObject#
*/
}, {
key: 'filters',
get: function get() {
return this._filters && this._filters.slice();
}
/**
* Shallow copies the array to the filters of the object.
*
* @param {PIXI.Filter[]} value - The filters to set.
*/
,
set: function set(value) {
this._filters = value && value.slice();
}
}]);
return DisplayObject;
}(_eventemitter2.default);
// performance increase to avoid using call.. (10x faster)
exports.default = DisplayObject;
DisplayObject.prototype.displayObjectUpdateTransform = DisplayObject.prototype.updateTransform;
//# sourceMappingURL=DisplayObject.js.map
