@safe-engine/cocos 1.6.4 → 1.6.5

package/dist/dragonbones/cocos/CocosFactory.js

@@ -0,0 +1,231 @@
+"use strict";
+// @ts-nocheck
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CocosFactory = void 0;
+var dragonbones_js_1 = require("@cocos/dragonbones-js");
+var CocosArmatureDisplay_1 = require("./CocosArmatureDisplay");
+var CocosSlot_1 = require("./CocosSlot");
+var CocosTextureAtlasData_1 = require("./CocosTextureAtlasData");
+/**
+ * - The PixiJS factory.
+ * @version DragonBones 3.0
+ * @language en_US
+ */
+/**
+ * - PixiJS 工厂。
+ * @version DragonBones 3.0
+ * @language zh_CN
+ */
+var CocosFactory = /** @class */ (function (_super) {
+    __extends(CocosFactory, _super);
+    /**
+     * @inheritDoc
+     */
+    function CocosFactory(dataParser, useSharedTicker) {
+        if (dataParser === void 0) { dataParser = null; }
+        if (useSharedTicker === void 0) { useSharedTicker = true; }
+        var _this = _super.call(this, dataParser) || this;
+        if (CocosFactory._dragonBonesInstance === null) {
+            var eventManager = new CocosArmatureDisplay_1.CocosArmatureDisplay();
+            CocosFactory._dragonBonesInstance = new dragonbones_js_1.DragonBones(eventManager);
+            // if (useSharedTicker) {
+            //   PIXI.Ticker.shared.add(CocosFactory._clockHandler, CocosFactory);
+            // }
+        }
+        _this._dragonBones = CocosFactory._dragonBonesInstance;
+        return _this;
+    }
+    CocosFactory._clockHandler = function (passedTime) {
+        this._dragonBonesInstance.advanceTime((passedTime));
+    };
+    /*
+     * `passedTime` is elapsed time, specified in seconds.
+     */
+    CocosFactory.advanceTime = function (passedTime) {
+        this._dragonBonesInstance.advanceTime(passedTime);
+    };
+    Object.defineProperty(CocosFactory, "factory", {
+        /**
+         * - A global factory instance that can be used directly.
+         * @version DragonBones 4.7
+         * @language en_US
+         */
+        /**
+         * - 一个可以直接使用的全局工厂实例。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        get: function () {
+            if (CocosFactory._factory === null) {
+                CocosFactory._factory = new CocosFactory(null, CocosFactory.useSharedTicker);
+            }
+            return CocosFactory._factory;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * - 一个获取全局工厂实例(单例)的方法, 和get factory相比, 优点是可以传参数。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    CocosFactory.newInstance = function (useSharedTicker) {
+        if (useSharedTicker === void 0) { useSharedTicker = true; }
+        if (CocosFactory._factory === null) {
+            CocosFactory._factory = new CocosFactory(null, useSharedTicker);
+        }
+        return CocosFactory._factory;
+    };
+    CocosFactory.prototype._buildTextureAtlasData = function (textureAtlasData, textureAtlas) {
+        if (textureAtlasData) {
+            console.log(textureAtlasData, 'textureAtlasData', textureAtlas);
+            var scale = cc.director.getContentScaleFactor();
+            textureAtlasData.scale = scale;
+            textureAtlasData.renderTexture = textureAtlas;
+        }
+        else {
+            textureAtlasData = dragonbones_js_1.BaseObject.borrowObject(CocosTextureAtlasData_1.CocosTextureAtlasData);
+        }
+        return textureAtlasData;
+    };
+    CocosFactory.prototype._buildArmature = function (dataPackage) {
+        var armature = dragonbones_js_1.BaseObject.borrowObject(dragonbones_js_1.Armature);
+        var armatureDisplay = new CocosArmatureDisplay_1.CocosArmatureDisplay();
+        armature.init(dataPackage.armature, armatureDisplay, armatureDisplay, this._dragonBones);
+        return armature;
+    };
+    CocosFactory.prototype._buildSlot = function (_dataPackage, slotData, armature) {
+        var slot = dragonbones_js_1.BaseObject.borrowObject(CocosSlot_1.CocosSlot);
+        slot.init(slotData, armature, new cc.Sprite(), new cc.Sprite());
+        return slot;
+    };
+    /**
+     * - Create a armature from cached DragonBonesData instances and TextureAtlasData instances, then use the {@link #clock} to update it.
+     * The difference is that the armature created by {@link #buildArmature} is not WorldClock instance update.
+     * @param armatureName - The armature data name.
+     * @param dragonBonesName - The cached name of the DragonBonesData instance. (If not set, all DragonBonesData instances are retrieved, and when multiple DragonBonesData instances contain a the same name armature data, it may not be possible to accurately create a specific armature)
+     * @param skinName - The skin name, you can set a different ArmatureData name to share it's skin data. (If not set, use the default skin data)
+     * @returns The armature display container.
+     * @see dragonBones.IArmatureProxy
+     * @see dragonBones.BaseFactory#buildArmature
+     * @version DragonBones 4.5
+     * @example
+     * <pre>
+     *     let armatureDisplay = factory.buildArmatureDisplay("armatureName", "dragonBonesName");
+     * </pre>
+     * @language en_US
+     */
+    /**
+     * - 通过缓存的 DragonBonesData 实例和 TextureAtlasData 实例创建一个骨架，并用 {@link #clock} 更新该骨架。
+     * 区别在于由 {@link #buildArmature} 创建的骨架没有 WorldClock 实例驱动。
+     * @param armatureName - 骨架数据名称。
+     * @param dragonBonesName - DragonBonesData 实例的缓存名称。 （如果未设置，将检索所有的 DragonBonesData 实例，当多个 DragonBonesData 实例中包含同名的骨架数据时，可能无法准确的创建出特定的骨架）
+     * @param skinName - 皮肤名称，可以设置一个其他骨架数据名称来共享其皮肤数据。 （如果未设置，则使用默认的皮肤数据）
+     * @returns 骨架的显示容器。
+     * @see dragonBones.IArmatureProxy
+     * @see dragonBones.BaseFactory#buildArmature
+     * @version DragonBones 4.5
+     * @example
+     * <pre>
+     *     let armatureDisplay = factory.buildArmatureDisplay("armatureName", "dragonBonesName");
+     * </pre>
+     * @language zh_CN
+     */
+    CocosFactory.prototype.buildArmatureDisplay = function (armatureName, dragonBonesName, skinName, textureAtlasName) {
+        if (dragonBonesName === void 0) { dragonBonesName = ''; }
+        if (skinName === void 0) { skinName = ''; }
+        if (textureAtlasName === void 0) { textureAtlasName = ''; }
+        var armature = this.buildArmature(armatureName, dragonBonesName || '', skinName || '', textureAtlasName || '');
+        if (armature !== null) {
+            this._dragonBones.clock.add(armature);
+            return armature.display;
+        }
+        return null;
+    };
+    /**
+     * - Create the display object with the specified texture.
+     * @param textureName - The texture data name.
+     * @param textureAtlasName - The texture atlas data name (Of not set, all texture atlas data will be searched)
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 创建带有指定贴图的显示对象。
+     * @param textureName - 贴图数据名称。
+     * @param textureAtlasName - 贴图集数据名称。 （如果未设置，将检索所有的贴图集数据）
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    CocosFactory.prototype.getTextureDisplay = function (textureName, textureAtlasName) {
+        if (textureAtlasName === void 0) { textureAtlasName = null; }
+        var textureData = this._getTextureData(textureAtlasName !== null ? textureAtlasName : '', textureName);
+        if (textureData !== null && textureData.renderTexture !== null) {
+            return new cc.Sprite(textureData.renderTexture);
+        }
+        return null;
+    };
+    Object.defineProperty(CocosFactory.prototype, "soundEventManager", {
+        /**
+         * - A global sound event manager.
+         * Sound events can be listened to uniformly from the manager.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 全局声音事件管理器。
+         * 声音事件可以从该管理器统一侦听。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        get: function () {
+            return this._dragonBones.eventManager;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CocosFactory._dragonBonesInstance = null;
+    CocosFactory._factory = null;
+    /*
+    * whether use `PIXI.Ticker.shared`
+    */
+    CocosFactory.useSharedTicker = true;
+    return CocosFactory;
+}(dragonbones_js_1.BaseFactory));
+exports.CocosFactory = CocosFactory;

package/dist/dragonbones/cocos/CocosSlot.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import { Slot } from '@cocos/dragonbones-js';
+export declare class CocosSlot extends Slot {
+    _updateGlueMesh(): void;
+    static toString(): string;
+    private _textureScale;
+    private _renderDisplay;
+    protected _onClear(): void;
+    protected _initDisplay(value: any, isRetain: boolean): void;
+    protected _disposeDisplay(value: any, isRelease: boolean): void;
+    protected _onUpdateDisplay(): void;
+    protected _addDisplay(): void;
+    protected _replaceDisplay(value: any): void;
+    protected _removeDisplay(): void;
+    protected _updateZOrder(): void;
+    /**
+     * @internal
+     */
+    _updateVisible(): void;
+    protected _updateBlendMode(): void;
+    protected _updateColor(): void;
+    protected _updateFrame(): void;
+    protected _updateMesh(): void;
+    protected _updateTransform(): void;
+    protected _updateTransformV3(): void;
+    protected _identityTransform(): void;
+}
+//# sourceMappingURL=CocosSlot.d.ts.map

package/dist/dragonbones/cocos/CocosSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CocosSlot.d.ts","sourceRoot":"","sources":["../../../src/dragonbones/cocos/CocosSlot.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAsC,IAAI,EAAa,MAAM,uBAAuB,CAAC;AAK5F,qBAAa,SAAU,SAAQ,IAAI;IACjC,eAAe,IAAI,IAAI;WAGT,QAAQ,IAAI,MAAM;IAIhC,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,cAAc,CAAU;IAEhC,SAAS,CAAC,QAAQ,IAAI,IAAI;IAQ1B,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI;IAO3D,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI;IAQ/D,SAAS,CAAC,gBAAgB,IAAI,IAAI;IAIlC,SAAS,CAAC,WAAW,IAAI,IAAI;IAK7B,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI;IAS3C,SAAS,CAAC,cAAc,IAAI,IAAI;IAIhC,SAAS,CAAC,aAAa,IAAI,IAAI;IAO/B;;OAEG;IACI,cAAc,IAAI,IAAI;IAI7B,SAAS,CAAC,gBAAgB,IAAI,IAAI;IAOlC,SAAS,CAAC,YAAY,IAAI,IAAI;IAW9B,SAAS,CAAC,YAAY,IAAI,IAAI;IAyG9B,SAAS,CAAC,WAAW,IAAI,IAAI;IA0J7B,SAAS,CAAC,gBAAgB,IAAI,IAAI;IAqBlC,SAAS,CAAC,kBAAkB,IAAI,IAAI;IAwBpC,SAAS,CAAC,kBAAkB,IAAI,IAAI;CAiBrC"}

package/dist/dragonbones/cocos/CocosSlot.js

@@ -0,0 +1,385 @@
+"use strict";
+// @ts-nocheck
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CocosSlot = void 0;
+var dragonbones_js_1 = require("@cocos/dragonbones-js");
+var CocosTextureAtlasData_1 = require("./CocosTextureAtlasData");
+var CocosSlot = /** @class */ (function (_super) {
+    __extends(CocosSlot, _super);
+    function CocosSlot() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CocosSlot.prototype._updateGlueMesh = function () {
+    };
+    CocosSlot.toString = function () {
+        return '[class dragonBones.CocosSlot]';
+    };
+    CocosSlot.prototype._onClear = function () {
+        _super.prototype._onClear.call(this);
+        this._textureScale = 1.0;
+        this._renderDisplay = null;
+        // this._updateTransform = cc[0] === '3' ? this._updateTransformV3 : this._updateTransformV4;
+    };
+    CocosSlot.prototype._initDisplay = function (value, isRetain) {
+        // tslint:disable-next-line:no-unused-expression
+        value;
+        // tslint:disable-next-line:no-unused-expression
+        isRetain;
+    };
+    CocosSlot.prototype._disposeDisplay = function (value, isRelease) {
+        // tslint:disable-next-line:no-unused-expression
+        value;
+        if (!isRelease) {
+            value.destroy();
+        }
+    };
+    CocosSlot.prototype._onUpdateDisplay = function () {
+        this._renderDisplay = (this._display ? this._display : this._rawDisplay);
+    };
+    CocosSlot.prototype._addDisplay = function () {
+        var container = this._armature.display;
+        container.addChild(this._renderDisplay);
+    };
+    CocosSlot.prototype._replaceDisplay = function (value) {
+        var container = this._armature.display;
+        var prevDisplay = value;
+        container.addChild(this._renderDisplay);
+        container.swapChildren(this._renderDisplay, prevDisplay);
+        container.removeChild(prevDisplay);
+        this._textureScale = 1.0;
+    };
+    CocosSlot.prototype._removeDisplay = function () {
+        this._renderDisplay.parent.removeChild(this._renderDisplay);
+    };
+    CocosSlot.prototype._updateZOrder = function () {
+        if (this._renderDisplay.getLocalZOrder() === this._zOrder) {
+            return;
+        }
+        this._renderDisplay.setLocalZOrder(this._zOrder);
+    };
+    /**
+     * @internal
+     */
+    CocosSlot.prototype._updateVisible = function () {
+        this._renderDisplay.visible = this._parent.visible && this._visible;
+    };
+    CocosSlot.prototype._updateBlendMode = function () {
+        if (this._renderDisplay instanceof cc.Sprite) {
+        }
+        // TODO child armature.
+    };
+    CocosSlot.prototype._updateColor = function () {
+        var alpha = this._colorTransform.alphaMultiplier * this._globalAlpha;
+        this._renderDisplay.alpha = alpha;
+        if (this._renderDisplay instanceof cc.Sprite || this._renderDisplay instanceof Cocos.SimpleMesh) {
+            var color = (Math.round(this._colorTransform.redMultiplier * 0xFF) << 16) + (Math.round(this._colorTransform.greenMultiplier * 0xFF) << 8) + Math.round(this._colorTransform.blueMultiplier * 0xFF);
+            this._renderDisplay.tint = color;
+        }
+        // TODO child armature.
+    };
+    CocosSlot.prototype._updateFrame = function () {
+        var currentTextureData = this._textureData;
+        if (this._displayIndex >= 0 && this._display !== null && currentTextureData !== null) {
+            var currentTextureAtlasData = currentTextureData.parent;
+            if (this._armature.replacedTexture !== null) { // Update replaced texture atlas.
+                if (this._armature._replaceTextureAtlasData === null) {
+                    currentTextureAtlasData = dragonbones_js_1.BaseObject.borrowObject(CocosTextureAtlasData_1.CocosTextureAtlasData);
+                    currentTextureAtlasData.copyFrom(currentTextureData.parent);
+                    currentTextureAtlasData.renderTexture = this._armature.replacedTexture;
+                    this._armature._replaceTextureAtlasData = currentTextureAtlasData;
+                }
+                else {
+                    currentTextureAtlasData = this._armature._replaceTextureAtlasData;
+                }
+                currentTextureData = currentTextureAtlasData.getTexture(currentTextureData.name);
+            }
+            var renderTexture = currentTextureData.renderTexture;
+            if (renderTexture !== null) {
+                if (this._geometryData) { // Mesh.
+                    var data = this._geometryData.data;
+                    var intArray = data.intArray;
+                    var floatArray = data.floatArray;
+                    var vertexCount = intArray[this._geometryData.offset + dragonbones_js_1.BinaryOffset.GeometryVertexCount];
+                    var triangleCount = intArray[this._geometryData.offset + dragonbones_js_1.BinaryOffset.GeometryTriangleCount];
+                    var vertexOffset = intArray[this._geometryData.offset + dragonbones_js_1.BinaryOffset.GeometryFloatOffset];
+                    if (vertexOffset < 0) {
+                        vertexOffset += 65536; // Fixed out of bouds bug.
+                    }
+                    var uvOffset = vertexOffset + vertexCount * 2;
+                    var scale = this._armature._armatureData.scale;
+                    var meshDisplay = this._renderDisplay;
+                    var vertices = new Float32Array(vertexCount * 2);
+                    var uvs = new Float32Array(vertexCount * 2);
+                    var indices = new Uint16Array(triangleCount * 3);
+                    for (var i = 0, l = vertexCount * 2; i < l; ++i) {
+                        vertices[i] = floatArray[vertexOffset + i] * scale;
+                    }
+                    for (var i = 0; i < triangleCount * 3; ++i) {
+                        indices[i] = intArray[this._geometryData.offset + dragonbones_js_1.BinaryOffset.GeometryVertexIndices + i];
+                    }
+                    for (var i = 0, l = vertexCount * 2; i < l; i += 2) {
+                        var u = floatArray[uvOffset + i];
+                        var v = floatArray[uvOffset + i + 1];
+                        if (currentTextureData.rotated) {
+                            uvs[i] = 1 - v;
+                            uvs[i + 1] = u;
+                        }
+                        else {
+                            uvs[i] = u;
+                            uvs[i + 1] = v;
+                        }
+                    }
+                    this._textureScale = 1.0;
+                    meshDisplay.texture = renderTexture;
+                    meshDisplay.vertices = vertices;
+                    meshDisplay.uvBuffer.update(uvs);
+                    meshDisplay.geometry.addIndex(indices);
+                    var isSkinned = this._geometryData.weight !== null;
+                    var isSurface = this._parent._boneData.type !== dragonbones_js_1.BoneType.Bone;
+                    if (isSkinned || isSurface) {
+                        this._identityTransform();
+                    }
+                }
+                else {
+                    // Normal texture.
+                    this._textureScale = currentTextureData.parent.scale * this._armature._armatureData.scale;
+                    var normalDisplay = this._renderDisplay;
+                    normalDisplay.setSpriteFrame(renderTexture);
+                }
+                this._visibleDirty = true;
+                return;
+            }
+        }
+        if (this._geometryData) {
+            var meshDisplay = this._renderDisplay;
+            meshDisplay.texture = null;
+            meshDisplay.x = 0.0;
+            meshDisplay.y = 0.0;
+            meshDisplay.visible = false;
+        }
+        else {
+            var normalDisplay = this._renderDisplay;
+            normalDisplay.texture = null;
+            normalDisplay.x = 0.0;
+            normalDisplay.y = 0.0;
+            normalDisplay.visible = false;
+        }
+        this._renderDisplay.setPosition(0.0, 0.0);
+    };
+    CocosSlot.prototype._updateMesh = function () {
+        var scale = this._armature._armatureData.scale;
+        var deformVertices = this._displayFrame.deformVertices;
+        var bones = this._geometryBones;
+        var geometryData = this._geometryData;
+        var weightData = geometryData.weight;
+        var hasDeform = deformVertices.length > 0 && geometryData.inheritDeform;
+        var meshDisplay = this._renderDisplay.getComponent(cc.Sprite)._sgNode; // as cc.Scale9Sprite;
+        var polygonInfo = meshDisplay.getMeshPolygonInfo();
+        if (!polygonInfo) {
+            return;
+        }
+        var verticesAndUVs = polygonInfo.triangles.verts;
+        var boundsRect = cc.rect(999999.0, 999999.0, -999999.0, -999999.0);
+        if (weightData !== null) {
+            var data = geometryData.data;
+            var intArray = data.intArray;
+            var floatArray = data.floatArray;
+            var vertexCount = intArray[geometryData.offset + dragonbones_js_1.BinaryOffset.MeshVertexCount];
+            var weightFloatOffset = intArray[weightData.offset + dragonbones_js_1.BinaryOffset.WeigthFloatOffset];
+            if (weightFloatOffset < 0) {
+                weightFloatOffset += 65536; // Fixed out of bouds bug.
+            }
+            for (var i = 0, iB = weightData.offset + dragonbones_js_1.BinaryOffset.WeigthBoneIndices + bones.length, iV = weightFloatOffset, iF = 0; i < vertexCount; ++i) {
+                var boneCount = intArray[iB++];
+                var xG = 0.0, yG = 0.0;
+                for (var j = 0; j < boneCount; ++j) {
+                    var boneIndex = intArray[iB++];
+                    var bone = bones[boneIndex];
+                    if (bone !== null) {
+                        var matrix = bone.globalTransformMatrix;
+                        var weight = floatArray[iV++];
+                        var xL = floatArray[iV++] * scale;
+                        var yL = floatArray[iV++] * scale;
+                        if (hasDeform) {
+                            xL += deformVertices[iF++];
+                            yL += deformVertices[iF++];
+                        }
+                        xG += (matrix.a * xL + matrix.c * yL + matrix.tx) * weight;
+                        yG += (matrix.b * xL + matrix.d * yL + matrix.ty) * weight;
+                    }
+                }
+                var vertex = verticesAndUVs[i];
+                vertex.x = xG;
+                vertex.y = yG;
+                if (boundsRect.x > xG) {
+                    boundsRect.x = xG;
+                }
+                if (boundsRect.width < xG) {
+                    boundsRect.width = xG;
+                }
+                if (boundsRect.y > yG) {
+                    boundsRect.y = yG;
+                }
+                if (boundsRect.height < yG) {
+                    boundsRect.height = yG;
+                }
+            }
+        }
+        else {
+            var isSurface = this._parent._boneData.type !== dragonbones_js_1.BoneType.Bone;
+            var data = geometryData.data;
+            var intArray = data.intArray;
+            var floatArray = data.floatArray;
+            var vertexCount = intArray[geometryData.offset + dragonbones_js_1.BinaryOffset.MeshVertexCount];
+            var vertexOffset = intArray[geometryData.offset + dragonbones_js_1.BinaryOffset.MeshFloatOffset];
+            if (vertexOffset < 0) {
+                vertexOffset += 65536; // Fixed out of bouds bug.
+            }
+            for (var i = 0, l = vertexCount * 2; i < l; i += 2) {
+                var iH = i / 2; // int.
+                var x = floatArray[vertexOffset + i] * scale;
+                var y = floatArray[vertexOffset + i + 1] * scale;
+                if (hasDeform) {
+                    x += deformVertices[i];
+                    y += deformVertices[i + 1];
+                }
+                var vertex = verticesAndUVs[iH];
+                if (isSurface) {
+                    var matrix = (this._parent)._getGlobalTransformMatrix(x, y);
+                    vertex.x = matrix.a * x + matrix.c * y + matrix.tx;
+                    vertex.y = matrix.b * x + matrix.d * y + matrix.ty;
+                    //
+                    x = vertex.x;
+                    y = vertex.y;
+                }
+                else {
+                    vertex.x = x;
+                    y = vertex.y = -y;
+                }
+                if (boundsRect.x > x) {
+                    boundsRect.x = x;
+                }
+                if (boundsRect.width < x) {
+                    boundsRect.width = x;
+                }
+                if (boundsRect.y > y) {
+                    boundsRect.y = y;
+                }
+                if (boundsRect.height < y) {
+                    boundsRect.height = y;
+                }
+            }
+        }
+        boundsRect.width -= boundsRect.x;
+        boundsRect.height -= boundsRect.y;
+        polygonInfo.rect = boundsRect;
+        meshDisplay.setContentSize(cc.size(boundsRect.width, boundsRect.height));
+        meshDisplay.setMeshPolygonInfo(polygonInfo);
+        if (weightData !== null) {
+            this._identityTransform();
+        }
+        else {
+            var transform = this.global;
+            var globalTransformMatrix = this.globalTransformMatrix;
+            this._renderDisplay.x = transform.x - (globalTransformMatrix.a * this._pivotX - globalTransformMatrix.c * this._pivotY);
+            this._renderDisplay.y = transform.y - (globalTransformMatrix.b * this._pivotX - globalTransformMatrix.d * this._pivotY);
+            this._renderDisplay.rotationX = -(transform.rotation + transform.skew) * dragonbones_js_1.Transform.RAD_DEG;
+            this._renderDisplay.rotationY = -transform.rotation * dragonbones_js_1.Transform.RAD_DEG;
+            this._renderDisplay.scaleX = transform.scaleX * this._textureScale;
+            this._renderDisplay.scaleY = -transform.scaleY * this._textureScale;
+        }
+    };
+    CocosSlot.prototype._updateTransform = function () {
+        this.updateGlobalTransform();
+        var transform = this.global;
+        // const globalTransformMatrix = this.globalTransformMatrix;
+        // if (this._renderDisplay === this._rawDisplay || this._renderDisplay === this._meshDisplay) {
+        //   this._renderDisplay.x = transform.x - (globalTransformMatrix.a * this._pivotX - globalTransformMatrix.c * this._pivotY);
+        //   this._renderDisplay.y = transform.y - (globalTransformMatrix.b * this._pivotX - globalTransformMatrix.d * this._pivotY);
+        // }
+        // else {
+        this._renderDisplay.x = transform.x;
+        this._renderDisplay.y = transform.y;
+        // }
+        this._renderDisplay.rotationX = -(transform.rotation + transform.skew) * dragonbones_js_1.Transform.RAD_DEG;
+        this._renderDisplay.rotationY = -transform.rotation * dragonbones_js_1.Transform.RAD_DEG;
+        this._renderDisplay.scaleX = transform.scaleX * this._textureScale;
+        this._renderDisplay.scaleY = -transform.scaleY * this._textureScale;
+    };
+    CocosSlot.prototype._updateTransformV3 = function () {
+        this.updateGlobalTransform(); // Update transform.
+        var transform = this.global;
+        if (this._renderDisplay === this._rawDisplay || this._renderDisplay === this._meshDisplay) {
+            var x = transform.x - (this.globalTransformMatrix.a * this._pivotX + this.globalTransformMatrix.c * this._pivotY);
+            var y = transform.y - (this.globalTransformMatrix.b * this._pivotX + this.globalTransformMatrix.d * this._pivotY);
+            // this._renderDisplay.transform = new cc.AffineTransform(
+            //   x, y,
+            //   transform.scaleX * this._textureScale, transform.scaleY * this._textureScale,
+            //   transform.rotation,
+            //   transform.skew, 0.0,
+            // );
+            this._renderDisplay.setPosition(x, y);
+        }
+        else {
+            this._renderDisplay.setPosition(transform.x, transform.y);
+            this._renderDisplay.rotation = transform.rotation;
+            this._renderDisplay.skewX = transform.skew;
+            this._renderDisplay.setScale(transform.scaleX, transform.scaleY);
+        }
+    };
+    CocosSlot.prototype._identityTransform = function () {
+        // const helpMatrix = TransformObject._helpMatrix;
+        // helpMatrix.a = 1.0;
+        // helpMatrix.b = 0.0;
+        // helpMatrix.c = -0.0;
+        // helpMatrix.d = -1.0;
+        // helpMatrix.tx = 0.0;
+        // helpMatrix.ty = 0.0;
+        // (this._renderDisplay as any)._renderCmd.setNodeToParentTransform(helpMatrix);
+        this._renderDisplay.x = 0.0;
+        this._renderDisplay.y = 0.0;
+        this._renderDisplay.rotationX = 0.0;
+        this._renderDisplay.rotationY = 0.0;
+        this._renderDisplay.scaleX = 1.0;
+        this._renderDisplay.scaleY = 1.0;
+    };
+    return CocosSlot;
+}(dragonbones_js_1.Slot));
+exports.CocosSlot = CocosSlot;