Show:

File: libs/DisplayObject.js

var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
/**
 * @module annie
 */
var annie;
(function (annie) {
    /**
     * 显示对象抽象类,不能直接实例化。一切显示对象的基类,包含了显示对象需要的一切属性
     * DisplayObject 类本身不包含任何用于在屏幕上呈现内容的 API。
     * 因此,如果要创建 DisplayObject 类的自定义子类,您将需要扩展其中一个具有在屏幕
     * 上呈现内容的 API 的子类,如 Shape、Sprite、Bitmap、TextField 或 MovieClip 类。
     * @class annie.DisplayObject
     * @since 1.0.0
     * @extends annie.EventDispatcher
     */
    var DisplayObject = /** @class */ (function (_super) {
        __extends(DisplayObject, _super);
        // events:
        /**
         * annie.DisplayObject显示对象加入到舞台事件
         * @event ADD_TO_STAGE
         * @since 1.0.0
         */
        /**
         * annie.DisplayObject显示对象从舞台移出事件
         * @event REMOVE_TO_STAGE
         * @since 1.0.0
         */
        /**
         * annie.DisplayObject显示对象 循环帧事件
         * @event ENTER_FRAME
         * @since 1.0.0
         */
        //MouseEvent
        /**
         * annie.DisplayObject鼠标或者手指按下事件
         * @event MOUSE_DOWN
         * @since 1.0.0
         */
        /**
         * annie.DisplayObject鼠标或者手指抬起事件
         * @event MOUSE_UP
         * @since 1.0.0
         */
        /**
         * annie.DisplayObject鼠标或者手指单击
         * @event CLICK
         * @type {string}
         */
        /**
         * annie.DisplayObject鼠标或者手指移动事件
         * @event MOUSE_MOVE
         * @since 1.0.0
         */
        /**
         * annie.DisplayObject鼠标或者手指移入到显示对象上里触发的事件
         * @event MOUSE_OVER
         * @since 1.0.0
         */
        /**
         * annie.DisplayObject鼠标或者手指移出显示对象边界触发的事件
         * @event MOUSE_OUT
         * @since 1.0.0
         */
        //
        /**
         * @method DisplayObject
         * @since 1.0.0
         * @public
         */
        function DisplayObject() {
            var _this = _super.call(this) || this;
            //更新信息对象是否更新矩阵 a2x_ua 是否更新Alpha a2x_uf 是否更新滤镜
            _this.a2x_um = false;
            _this.a2x_ua = false;
            _this.a2x_uf = false;
            _this._isCache = false;
            _this._cacheAsBitmap = false;
            /**
             * 此显示对象所在的舞台对象,如果此对象没有被添加到显示对象列表中,此对象为空。
             * @property stage
             * @public
             * @since 1.0.0
             * @type {Stage}
             * @default null;
             * @readonly
             * */
            _this.stage = null;
            /**
             * 显示对象的父级
             * @property parent
             * @since 1.0.0
             * @public
             * @type {annie.Sprite}
             * @default null
             * @readonly
             */
            _this.parent = null;
            //显示对象在显示列表上的最终表现出来的透明度,此透明度会继承父级的透明度依次相乘得到最终的值
            _this._cAlpha = 1;
            _this._ocAlpha = 1;
            //显示对象上对显示列表上的最终合成的矩阵,此矩阵会继承父级的显示属性依次相乘得到最终的值
            _this._cMatrix = new annie.Matrix();
            /**
             * 是否可以接受点击事件,如果设置为false,此显示对象将无法接收到点击事件
             * @property mouseEnable
             * @type {boolean}
             * @public
             * @since 1.0.0
             * @default false
             */
            _this.mouseEnable = true;
            //显示对象上对显示列表上的最终的所有滤镜组
            _this.cFilters = [];
            /**
             * 每一个显示对象都可以给他命一个名字,这样我们在查找子级的时候就可以直接用this.getChildrndByName("name")获取到这个对象的引用
             * @property name
             * @since 1.0.0
             * @public
             * @type {string}
             * @default ""
             */
            _this.name = "";
            _this._x = 0;
            _this._offsetX = 0;
            _this._offsetY = 0;
            _this._y = 0;
            _this._scaleX = 1;
            _this._scaleY = 1;
            _this._rotation = 0;
            _this._alpha = 1;
            _this._skewX = 0;
            _this._skewY = 0;
            _this._anchorX = 0;
            _this._anchorY = 0;
            _this._visible = true;
            _this._blendMode = 0;
            _this._matrix = new annie.Matrix();
            _this._mask = null;
            _this._filters = [];
            //是否自己的父级发生的改变
            _this._cp = true;
            _this._isUseToMask = 0;
            _this._hitArea = null;
            /**
             * <h4><font color="red">小游戏不支持 小程序不支持</font></h4>
             * 是否对图片对象使用像素碰撞检测透明度,默认关闭
             * @property hitTestWithPixel
             * @type {boolean}
             * @default false
             * @since 1.1.0
             */
            _this.hitTestWithPixel = false;
            // 缓存起来的纹理对象。最后真正送到渲染器去渲染的对象
            _this._texture = null;
            _this._bounds = new annie.Rectangle();
            _this._splitBoundsList = [];
            /**
             * 当前对象包含的声音列表
             * @property soundList
             * @public
             * @since 2.0.0
             * @type {Array}
             * @default []
             */
            _this.soundList = [];
            //每个Flash文件生成的对象都有一个自带的初始化信息
            _this._a2x_res_obj = {};
            //这里为什么要用undefined呢,这样可以知道一个对象是否从未添加到舞台过
            _this._isOnStage = undefined;
            _this._changeTransformInfo = [false, false, false, false, false, false];
            _this._instanceType = "annie.DisplayObject";
            return _this;
        }
        Object.defineProperty(DisplayObject.prototype, "isCache", {
            /**
             * 是否被缓存了
             * @property isCache
             * @since 3.2.0
             * @type {boolean}
             */
            get: function () {
                return this._isCache;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "cacheAsBitmap", {
            /**
             * 是否将这个对象缓存为位图了
             * @property cacheAsBitmap
             * @since 3.2.0
             * @return {boolean}
             */
            get: function () {
                return this._cacheAsBitmap;
            },
            set: function (value) {
                var s = this;
                if (value != s._cacheAsBitmap) {
                    s._cacheAsBitmap = value;
                    s._isCache = (s._cacheAsBitmap || s._filters.length > 0 || s._blendMode != 0);
                    s.a2x_uf = true;
                }
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "x", {
            /**
             * 显示对象位置x
             * @property x
             * @public
             * @since 1.0.0
             * @type {number}
             * @default 0
             */
            get: function () {
                return this._x;
            },
            set: function (value) {
                var s = this;
                if (value != s._x) {
                    s._x = value;
                    s.a2x_um = true;
                }
                s._changeTransformInfo[0] = true;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "y", {
            /**
             * 显示对象位置y
             * @property y
             * @public
             * @since 1.0.0
             * @type {number}
             * @default 0
             */
            get: function () {
                return this._y;
            },
            set: function (value) {
                var s = this;
                if (value != s._y) {
                    s._y = value;
                    s.a2x_um = true;
                }
                s._changeTransformInfo[1] = true;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "scaleX", {
            /**
             * 显示对象x方向的缩放值
             * @property scaleX
             * @public
             * @since 1.0.0
             * @type {number}
             * @default 1
             */
            get: function () {
                return this._scaleX;
            },
            set: function (value) {
                var s = this;
                if (value != s._scaleX) {
                    s._scaleX = value;
                    s.a2x_um = true;
                }
                s._changeTransformInfo[2] = true;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "scaleY", {
            /**
             * 显示对象y方向的缩放值
             * @property scaleY
             * @public
             * @since 1.0.0
             * @type {number}
             * @default 1
             */
            get: function () {
                return this._scaleY;
            },
            set: function (value) {
                var s = this;
                if (value != s._scaleY) {
                    s._scaleY = value;
                    s.a2x_um = true;
                }
                s._changeTransformInfo[3] = true;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "rotation", {
            /**
             * 显示对象旋转角度
             * @property rotation
             * @public
             * @since 1.0.0
             * @type {number}
             * @default 0
             */
            get: function () {
                return this._rotation;
            },
            set: function (value) {
                var s = this;
                if (value != s._rotation || s._skewX != 0 || s._skewY != 0) {
                    s._rotation = value;
                    s._skewX = 0;
                    s._skewY = 0;
                    s.a2x_um = true;
                }
                s._changeTransformInfo[4] = true;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "alpha", {
            /**
             * 显示对象透明度
             * @property alpha
             * @public
             * @since 1.0.0
             * @type {number}
             * @default 1
             */
            get: function () {
                return this._alpha;
            },
            set: function (value) {
                var s = this;
                if (value != s._alpha) {
                    s._alpha = value;
                    s.a2x_ua = true;
                }
                s._changeTransformInfo[5] = true;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "skewX", {
            /**
             * 显示对象x方向的斜切值
             * @property skewX
             * @public
             * @since 1.0.0
             * @type {number}
             * @default 0
             */
            get: function () {
                return this._skewX;
            },
            set: function (value) {
                var s = this;
                if (value != s._skewX || s._rotation != 0) {
                    s._skewX = value;
                    s._rotation = 0;
                    s.a2x_um = true;
                }
                s._changeTransformInfo[4] = true;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "skewY", {
            /**
             * 显示对象y方向的斜切值
             * @property skewY
             * @public
             * @since 1.0.0
             * @type {number}
             * @default 0
             */
            get: function () {
                return this._skewY;
            },
            set: function (value) {
                var s = this;
                if (value != s._skewY || s._rotation != 0) {
                    s._skewY = value;
                    s._rotation = 0;
                    s.a2x_um = true;
                }
                s._changeTransformInfo[4] = true;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "anchorX", {
            /**
             * 显示对象上x方向的缩放或旋转点
             * @property anchorX
             * @public
             * @since 1.0.0
             * @type {number}
             * @default 0
             */
            get: function () {
                return this._anchorX;
            },
            set: function (value) {
                var s = this;
                if (value != s._anchorX) {
                    s._anchorX = value;
                    s.a2x_um = true;
                }
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "anchorY", {
            /**
             * 显示对象上y方向的缩放或旋转点
             * @property anchorY
             * @public
             * @since 1.0.0
             * @type {number}
             * @default 0
             */
            get: function () {
                return this._anchorY;
            },
            set: function (value) {
                var s = this;
                if (value != s._anchorY) {
                    s._anchorY = value;
                    s.a2x_um = true;
                }
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "visible", {
            /**
             * 显未对象是否可见
             * @property visible
             * @public
             * @since 1.0.0
             * @type {boolean}
             * @default 0
             */
            get: function () {
                return this._visible;
            },
            set: function (value) {
                var s = this;
                if (value != s._visible) {
                    s._cp = true;
                    s._visible = value;
                }
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "blendMode", {
            /**
             * 显示对象的混合模式
             * 支持的混合模式大概有23种,具体查看annie.BlendMode
             * @property blendMode
             * @public
             * @since 1.0.0
             * @type {number}
             * @default 0
             */
            get: function () {
                return this._blendMode;
            },
            set: function (value) {
                var s = this;
                if (value != s._blendMode) {
                    s._blendMode = value;
                    s._isCache = (s._cacheAsBitmap || s._filters.length > 0 || s._blendMode != 0);
                    s.a2x_uf = true;
                }
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "matrix", {
            /**
             * 显示对象的变形矩阵
             * @property matrix
             * @public
             * @since 1.0.0
             * @type {annie.Matrix}
             * @default null
             */
            get: function () {
                return this._matrix;
            },
            enumerable: true,
            configurable: true
        });
        ;
        Object.defineProperty(DisplayObject.prototype, "mask", {
            /**
             * 显示对象的遮罩, 是一个Shape显示对象或是一个只包含shape显示对象的MovieClip
             * @property mask
             * @public
             * @since 1.0.0
             * @type {annie.DisplayObject}
             * @default null
             */
            get: function () {
                return this._mask;
            },
            set: function (value) {
                var s = this;
                if (value != s._mask) {
                    if (value instanceof annie.DisplayObject) {
                        value._isUseToMask++;
                    }
                    else {
                        if (s._mask instanceof annie.DisplayObject) {
                            s._mask._isUseToMask--;
                        }
                    }
                    s._mask = value;
                }
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(DisplayObject.prototype, "filters", {
            /**
             * <h4><font color="red">小游戏不支持 小程序不支持</font></h4>
             * 显示对象的滤镜数组
             * @property filters
             * @since 1.0.0
             * @public
             * @type {Array}
             * @default null
             */
            get: function () {
                return this._filters;
            },
            set: function (value) {
                var s = this;
                if (value instanceof Array) {
                    if (value.length != 0 || s._filters.length != 0) {
                        s._filters.length = 0;
                        for (var i = 0; i < value.length; i++) {
                            s.filters[i] = value[i];
                        }
                        s.a2x_uf = true;
                    }
                }
                else {
                    if (s._filters.length > 0) {
                        s._filters.length = 0;
                        s.a2x_uf = true;
                    }
                }
                s._isCache = (s._cacheAsBitmap || s._filters.length > 0 || s._blendMode != 0);
            },
            enumerable: true,
            configurable: true
        });
        /**
         *将全局坐标转换到本地坐标值
         * @method globalToLocal
         * @since 1.0.0
         * @public
         * @param {annie.Point} point
         * @return {annie.Point}
         */
        DisplayObject.prototype.globalToLocal = function (point, bp) {
            if (bp === void 0) { bp = null; }
            return this._cMatrix.invert().transformPoint(point.x, point.y, bp);
        };
        /**
         *将本地坐标转换到全局坐标值
         * @method localToGlobal
         * @public
         * @since 1.0.0
         * @param {annie.Point} point
         * @return {annie.Point}
         */
        DisplayObject.prototype.localToGlobal = function (point, bp) {
            if (bp === void 0) { bp = null; }
            return this._cMatrix.transformPoint(point.x, point.y, bp);
        };
        Object.defineProperty(DisplayObject.prototype, "hitArea", {
            get: function () {
                return this._hitArea;
            },
            /**
             * annie.Sprite显示容器的接受鼠标点击的区域。一但设置,容器里所有子级将不会触发任何鼠标相关的事件。
             * 相当于 mouseChildren=false,但在有大量子级显示对象的情况下,此方法的性能搞出mouseChildren几个数量级,建议使用。
             * @property hitArea
             * @param {annie.Rectangle} rect
             * @since 3.0.1
             */
            set: function (rect) {
                this._hitArea = rect;
            },
            enumerable: true,
            configurable: true
        });
        /**
         * 点击碰撞测试,就是舞台上的一个point是否在显示对象内,在则返回该对象,不在则返回null
         * @method hitTestPoint
         * @public
         * @since 1.0.0
         * @param {annie.Point} hitPoint 要检测碰撞的点
         * @param {boolean} isGlobalPoint 是不是全局坐标的点,默认false是本地坐标
         * @return {annie.DisplayObject}
         */
        DisplayObject.prototype.hitTestPoint = function (hitPoint, isGlobalPoint) {
            if (isGlobalPoint === void 0) { isGlobalPoint = false; }
            var s = this;
            if (!s.visible || !s.mouseEnable)
                return null;
            var texture = s._texture;
            if (!texture || texture.width == 0 || texture.height == 0) {
                return null;
            }
            var p;
            if (isGlobalPoint) {
                p = s.globalToLocal(hitPoint, DisplayObject._p1);
            }
            else {
                p = hitPoint;
            }
            //如果有设置鼠标活动区域,则优先使用活动区域
            if (s._hitArea) {
                if (s._hitArea.isPointIn(p)) {
                    return s;
                }
            }
            if (s.hitTestWithPixel) {
                var ctx = void 0;
                if (s.instanceType != "annie.Bitmap") {
                    ctx = texture.getContext('2d');
                    if (ctx.getImageData((p.x - s._offsetX) >> 0, (p.y - s._offsetY) >> 0, 1, 1).data[3] > 0) {
                        return s;
                    }
                }
                else {
                    var _canvas = DisplayObject._canvas;
                    ctx = _canvas.getContext('2d');
                    _canvas.width = 1;
                    _canvas.height = 1;
                    ctx.clearRect(0, 0, 1, 1);
                    ctx.setTransform(1, 0, 0, 1, p.x - s._offsetX, p.y - s._offsetY);
                    ctx.drawImage(texture, 0, 0);
                    if (ctx.getImageData(0, 0, 1, 1).data[3] > 0) {
                        return s;
                    }
                }
            }
            else {
                if (s._bounds.isPointIn(p)) {
                    return s;
                }
            }
            return null;
        };
        DisplayObject.prototype.getBounds = function () {
            return this._bounds;
        };
        /**
         * 获取对象形变后外切矩形
         * 可以从这个方法中读取到此显示对象变形后x方向上的宽和y方向上的高
         * @method getDrawRect
         * @public
         * @since 1.0.0
         * @return {annie.Rectangle}
         */
        DisplayObject.prototype.getDrawRect = function (matrix, bounds) {
            if (matrix === void 0) { matrix = null; }
            if (bounds === void 0) { bounds = null; }
            var s = this;
            if (matrix == void 0) {
                matrix = s.matrix;
            }
            if (bounds == void 0) {
                bounds = s.getBounds();
            }
            var x = bounds.x, y = bounds.y, w = bounds.width, h = bounds.height;
            matrix.transformPoint(x, y, DisplayObject._p1);
            matrix.transformPoint(x + w, y, DisplayObject._p2);
            matrix.transformPoint(x + w, y + h, DisplayObject._p3);
            matrix.transformPoint(x, y + h, DisplayObject._p4);
            annie.Rectangle.createFromPoints(DisplayObject._transformRect, DisplayObject._p1, DisplayObject._p2, DisplayObject._p3, DisplayObject._p4);
        };
        DisplayObject.prototype._updateMatrix = function (isOffCanvas) {
            if (isOffCanvas === void 0) { isOffCanvas = false; }
            var s = this, cm, pcm, ca, pca;
            var isHadParent = s.parent instanceof annie.Sprite;
            if (isOffCanvas) {
                if (!s._ocMatrix) {
                    s._ocMatrix = new annie.Matrix();
                }
                if (isHadParent) {
                    pcm = s.parent._ocMatrix;
                    pca = s.parent._ocAlpha;
                }
                else {
                    s._ocMatrix.identity();
                    s._ocMatrix.tx = -s._offsetX;
                    s._ocMatrix.ty = -s._offsetY;
                    s._ocAlpha = 1;
                    return;
                }
                cm = s._ocMatrix;
                s._matrix.createBox(s._x, s._y, s._scaleX, s._scaleY, s._rotation, s._skewX, s._skewY, s._anchorX, s._anchorY);
                cm.setFrom(s._matrix);
                ca = s._alpha;
                if (isHadParent) {
                    cm.prepend(pcm);
                    ca *= pca;
                }
                s._ocAlpha = ca;
            }
            else {
                cm = s._cMatrix;
                ca = s._cAlpha;
                if (isHadParent) {
                    pcm = s.parent._cMatrix;
                    pca = s.parent._cAlpha;
                }
                if (s.a2x_um) {
                    s._matrix.createBox(s._x, s._y, s._scaleX, s._scaleY, s._rotation, s._skewX, s._skewY, s._anchorX, s._anchorY);
                }
                if (s._cp) {
                    s.a2x_um = s.a2x_ua = true;
                }
                else {
                    if (isHadParent) {
                        var PUI = s.parent;
                        if (PUI.a2x_um) {
                            s.a2x_um = true;
                        }
                        if (PUI.a2x_ua) {
                            s.a2x_ua = true;
                        }
                    }
                }
                if (s.a2x_um) {
                    cm.setFrom(s._matrix);
                    if (isHadParent) {
                        cm.prepend(pcm);
                    }
                }
                if (s.a2x_ua) {
                    ca = s._alpha;
                    if (isHadParent) {
                        ca *= pca;
                    }
                }
                s._cp = false;
                s._cAlpha = ca;
            }
        };
        DisplayObject.prototype._render = function (renderObj) {
            var s = this;
            if (s._visible && s._cAlpha > 0) {
                renderObj.draw(s);
            }
        };
        Object.defineProperty(DisplayObject.prototype, "width", {
            /**
             * 获取或者设置显示对象在父级里的x方向的宽,不到必要不要用此属性获取高
             * 如果你要同时获取宽高,建议使用 getWH()方法获取宽和高
             * @property  width
             * @public
             * @since 1.0.3
             * @return {number}
             */
            get: function () {
                this._updateMatrix();
                this.getDrawRect();
                return DisplayObject._transformRect.width;
            },
            set: function (value) {
                var s = this;
                s._updateMatrix();
                s.getDrawRect();
                var w = DisplayObject._transformRect.width;
                if (w > 0) {
                    var sx = value / w;
                    s.scaleX *= sx;
                }
                else {
                    s.scaleX = 1;
                }
            },
            enumerable: true,
            configurable: true
        });
        /**
         * 获取宽高
         * @method getWH
         * @since 1.1.0
         * @return {{w: number; h: number}}
         */
        DisplayObject.prototype.getWH = function () {
            this._updateMatrix();
            this.getDrawRect();
            return { w: DisplayObject._transformRect.width, h: DisplayObject._transformRect.height };
        };
        Object.defineProperty(DisplayObject.prototype, "height", {
            /**
             * 获取或者设置显示对象在父级里的y方向的高,不到必要不要用此属性获取高
             * 如果你要同时获取宽高,建议使用getWH()方法获取宽和高
             * @property  height
             * @public
             * @since 1.0.3
             * @return {number}
             */
            get: function () {
                this._updateMatrix();
                this.getDrawRect();
                return DisplayObject._transformRect.height;
            },
            set: function (value) {
                var s = this;
                s._updateMatrix();
                s.getDrawRect();
                var h = DisplayObject._transformRect.height;
                if (h > 0) {
                    var sy = value / h;
                    s.scaleY *= sy;
                }
                else {
                    s.scaleY = 1;
                }
            },
            enumerable: true,
            configurable: true
        });
        /**
         * 停止这个显示对象上的所有声音
         * @method stopAllSounds
         * @public
         * @since 2.0.0
         * @return {void}
         */
        DisplayObject.prototype.stopAllSounds = function () {
            var sounds = this.soundList;
            if (sounds instanceof Array) {
                for (var i = sounds.length - 1; i >= 0; i--) {
                    sounds[i].stop();
                }
            }
        };
        /**
         * 更新boundsList矩阵
         * @method _updateSplitBounds
         * @private
         */
        DisplayObject.prototype._updateSplitBounds = function () {
            var s = this;
            var sbl = [];
            var bounds = s.getBounds();
            if (bounds.width * bounds.height > 0) {
                var row = 1;
                var col = 1;
                var br = 0;
                var bc = 0;
                var newWidth = bounds.width;
                var newHeight = bounds.height;
                if (annie.isCutDraw) {
                    br = 1024;
                    bc = 1024;
                    newWidth = br + 2;
                    newHeight = bc + 2;
                    if (bounds.width > br) {
                        row = Math.ceil(bounds.width / br);
                    }
                    if (bounds.height > bc) {
                        col = Math.ceil(bounds.height / bc);
                    }
                }
                for (var i = 0; i < row; i++) {
                    for (var j = 0; j < col; j++) {
                        var newX = i * br;
                        var newY = j * bc;
                        if (i == row - 1) {
                            newWidth = bounds.width - newX;
                        }
                        if (j == col - 1) {
                            newHeight = bounds.height - newY;
                        }
                        sbl.push({
                            isDraw: true,
                            rect: new annie.Rectangle(newX + bounds.x, newY + bounds.y, newWidth, newHeight)
                        });
                    }
                }
            }
            s._splitBoundsList = sbl;
        };
        DisplayObject.prototype._checkDrawBounds = function () {
            var s = this;
            //检查所有bounds矩阵是否在可视范围里
            var sbl = s._splitBoundsList;
            var dtr = DisplayObject._transformRect;
            if (s.stage) {
                for (var i = 0; i < sbl.length; i++) {
                    s.getDrawRect(s._cMatrix, sbl[i].rect);
                    sbl[i].isDraw = annie.Rectangle.testRectCross(dtr, s.stage.renderObj.viewPort);
                }
            }
        };
        /**
         * @method getSound
         * @param {number|string} id
         * @return {Array} 这个对象里所有叫这个名字的声音引用数组
         * @since 2.0.0
         */
        DisplayObject.prototype.getSound = function (id) {
            var sounds = this.soundList, newSounds = [];
            if (sounds instanceof Array) {
                if (typeof (id) == "string") {
                    for (var i = sounds.length - 1; i >= 0; i--) {
                        if (sounds[i].name == id) {
                            //这里是全部找出来
                            newSounds.push(sounds[i]);
                        }
                    }
                }
                else {
                    if (id >= 0 && id < sounds.length) {
                        newSounds.push(sounds[id]);
                    }
                }
            }
            return newSounds;
        };
        /**
         * 返回一个id,这个id你要留着作为删除他时使用。
         * 这个声音会根据这个显示对象添加到舞台时播放,移出舞台而关闭
         * @method addSound
         * @param {annie.Sound} sound
         * @return {void}
         * @since 2.0.0
         * @public
         */
        DisplayObject.prototype.addSound = function (sound) {
            var s = this;
            if (!(s.soundList instanceof Array)) {
                s.soundList = [];
            }
            s.soundList.push(sound);
        };
        /**
         * 删除一个已经添加进来的声音
         * @method removeSound
         * @public
         * @since 2.0.0
         * @param {number|string} id
         * @return {void}
         */
        DisplayObject.prototype.removeSound = function (id) {
            var sounds = this.soundList;
            if (sounds instanceof Array) {
                if (typeof (id) == "string") {
                    for (var i = sounds.length - 1; i >= 0; i--) {
                        //这里是全部找出来
                        if (sounds[i].name == id) {
                            sounds.splice(i, 1);
                        }
                    }
                }
                else {
                    if (id >= 0 && id < sounds.length) {
                        sounds.splice(id, 1);
                    }
                }
            }
        };
        DisplayObject.prototype.destroy = function () {
            var s = this;
            //清除相应的数据引用
            s.stopAllSounds();
            for (var i = 0; i < s.soundList.length; i++) {
                s.soundList[i].destroy();
            }
            s.soundList = null;
            s._a2x_res_obj = null;
            s.mask = null;
            s.filters = null;
            s.parent = null;
            s.stage = null;
            s._bounds = null;
            s._splitBoundsList = null;
            s.cFilters = null;
            s._matrix = null;
            s._cMatrix = null;
            s._texture = null;
            _super.prototype.destroy.call(this);
        };
        DisplayObject.prototype._onRemoveEvent = function (isReSetMc) {
            //如果有音乐,则关闭音乐
            var s = this;
            s._isOnStage = false;
            var sounds = s.soundList;
            if (sounds.length > 0) {
                for (var i = 0; i < sounds.length; i++) {
                    sounds[i].stop2();
                }
            }
            s.dispatchEvent(annie.Event.REMOVE_TO_STAGE);
        };
        DisplayObject.prototype._onAddEvent = function () {
            var s = this;
            s._isOnStage = true;
            //如果有音乐,则播放音乐
            var sounds = s.soundList;
            if (sounds.length > 0) {
                for (var i = 0; i < sounds.length; i++) {
                    sounds[i].play2();
                }
            }
            s.dispatchEvent(annie.Event.ADD_TO_STAGE);
        };
        DisplayObject.prototype._onUpdateFrame = function (mcSpeed, isOffCanvas) {
            if (mcSpeed === void 0) { mcSpeed = 1; }
            if (isOffCanvas === void 0) { isOffCanvas = false; }
            if (this._visible && !isOffCanvas) {
                this.dispatchEvent(annie.Event.ENTER_FRAME);
            }
        };
        /**
         * 启动鼠标或者触摸拖动
         * @method startDrag
         * @param {boolean} isCenter 指定将可拖动的对象锁定到指针位置中心 (true),还是锁定到用户第一次单击该对象的位置 (false) 默认false
         * @param {annie.Rectangle} bounds 相对于显示对象父级的坐标的值,用于指定 Sprite 约束矩形
         * @since 1.1.2
         * @public
         * @return {void}
         */
        DisplayObject.prototype.startDrag = function (isCenter, bounds) {
            if (isCenter === void 0) { isCenter = false; }
            if (bounds === void 0) { bounds = null; }
            var s = this;
            annie.Stage._dragDisplay = s;
            annie.Stage._isDragCenter = isCenter;
            annie.Stage._lastDragPoint.x = Number.MAX_VALUE;
            annie.Stage._lastDragPoint.y = Number.MAX_VALUE;
            if (bounds) {
                annie.Stage._dragBounds.x = bounds.x;
                annie.Stage._dragBounds.y = bounds.y;
                annie.Stage._dragBounds.width = bounds.width;
                annie.Stage._dragBounds.height = bounds.height;
            }
            else {
                annie.Stage._dragBounds.x = 0;
                annie.Stage._dragBounds.y = 0;
                annie.Stage._dragBounds.width = Number.MIN_VALUE;
                annie.Stage._dragBounds.height = Number.MIN_VALUE;
            }
        };
        /**
         * 停止鼠标跟随
         * @method stopDrag
         */
        DisplayObject.prototype.stopDrag = function () {
            annie.Stage._dragDisplay = null;
        };
        /**
         * 如果你在mc更改了对象的x y scale rotation alpha,最后想还原,不再需要自我控制,可以调用这方法
         * @method clearCustomTransform
         * @param transId{number}  //0->x,1->y,2->scaleX,3->scaleY,4->rotation,5->alpha,-1->all
         * @public
         * @since 3.1.0
         */
        DisplayObject.prototype.clearCustomTransform = function (transId) {
            if (transId === void 0) { transId = -1; }
            var s = this;
            if (transId = -1) {
                for (var i = 0; i < 6; i++) {
                    s._changeTransformInfo[i] = false;
                }
            }
            else {
                s._changeTransformInfo[transId] = false;
            }
        };
        DisplayObject.prototype.clearBounds = function () {
            this._bounds.x = 0;
            this._bounds.y = 0;
            this._bounds.width = 0;
            this._bounds.height = 0;
        };
        //为了 hitTestPoint,localToGlobal,globalToLocal等方法不复新不重复生成新的点对象而节约内存
        DisplayObject._p1 = new annie.Point();
        DisplayObject._p2 = new annie.Point();
        DisplayObject._p3 = new annie.Point();
        DisplayObject._p4 = new annie.Point();
        //画缓存位图的时候需要使用
        //<h4><font color="red">小游戏不支持 小程序不支持</font></h4>
        DisplayObject._canvas = window.document.createElement("canvas");
        DisplayObject._transformRect = new annie.Rectangle();
        return DisplayObject;
    }(annie.EventDispatcher));
    annie.DisplayObject = DisplayObject;
})(annie || (annie = {}));