@safe-engine/pixi 8.8.2 → 8.8.4

package/dist/dragonbones/db-pixi/PixiSlot.js

@@ -0,0 +1,332 @@
+import * as PIXI from 'pixi.js';
+import { MeshSimple, Sprite } from 'pixi.js';
+import { BaseObject, Slot } from '../dragonBones';
+import { PixiTextureAtlasData } from './PixiTextureAtlasData';
+/**
+ * - The PixiJS slot.
+ * @version DragonBones 3.0
+ * @language en_US
+ */
+export class PixiSlot extends Slot {
+    static toString() {
+        return '[class dragonBones.PixiSlot]';
+    }
+    _onClear() {
+        super._onClear();
+        this._textureScale = 1.0;
+        this._renderDisplay = null;
+        this._updateTransform = this._updateTransformV4;
+    }
+    _initDisplay(value, isRetain) {
+        // tslint:disable-next-line:no-unused-expression
+        // value
+        // tslint:disable-next-line:no-unused-expression
+        // isRetain
+    }
+    _disposeDisplay(value, isRelease) {
+        // tslint:disable-next-line:no-unused-expression
+        // value
+        if (!isRelease) {
+            ;
+            value.destroy();
+        }
+    }
+    _onUpdateDisplay() {
+        this._renderDisplay = (this._display ? this._display : this._rawDisplay);
+    }
+    _addDisplay() {
+        const container = this._armature.display;
+        container.addChild(this._renderDisplay);
+    }
+    _replaceDisplay(value) {
+        const container = this._armature.display;
+        const prevDisplay = value;
+        container.addChild(this._renderDisplay);
+        container.swapChildren(this._renderDisplay, prevDisplay);
+        container.removeChild(prevDisplay);
+        this._textureScale = 1.0;
+    }
+    _removeDisplay() {
+        this._renderDisplay.parent.removeChild(this._renderDisplay);
+    }
+    _updateZOrder() {
+        const container = this._armature.display;
+        const index = container.getChildIndex(this._renderDisplay);
+        if (index === this._zOrder) {
+            return;
+        }
+        container.addChildAt(this._renderDisplay, this._zOrder);
+    }
+    /**
+     * @internal
+     */
+    _updateVisible() {
+        this._renderDisplay.visible = this._parent.visible && this._visible;
+    }
+    _updateBlendMode() {
+        if (this._renderDisplay instanceof PIXI.Sprite) {
+            switch (this._blendMode) {
+                case 0 /* BlendMode.Normal */:
+                    this._renderDisplay.blendMode = 'normal';
+                    break;
+                case 1 /* BlendMode.Add */:
+                    this._renderDisplay.blendMode = 'add';
+                    break;
+                case 3 /* BlendMode.Darken */:
+                    this._renderDisplay.blendMode = 'darken';
+                    break;
+                case 4 /* BlendMode.Difference */:
+                    this._renderDisplay.blendMode = 'difference';
+                    break;
+                case 6 /* BlendMode.HardLight */:
+                    this._renderDisplay.blendMode = 'hard-light';
+                    break;
+                case 9 /* BlendMode.Lighten */:
+                    this._renderDisplay.blendMode = 'lighten';
+                    break;
+                case 10 /* BlendMode.Multiply */:
+                    this._renderDisplay.blendMode = 'multiply';
+                    break;
+                case 11 /* BlendMode.Overlay */:
+                    this._renderDisplay.blendMode = 'overlay';
+                    break;
+                case 12 /* BlendMode.Screen */:
+                    this._renderDisplay.blendMode = 'screen';
+                    break;
+                default:
+                    break;
+            }
+        }
+        // TODO child armature.
+    }
+    _updateColor() {
+        const alpha = this._colorTransform.alphaMultiplier * this._globalAlpha;
+        this._renderDisplay.alpha = alpha;
+        if (this._renderDisplay instanceof Sprite || this._renderDisplay instanceof MeshSimple) {
+            const 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.
+    }
+    _updateFrame() {
+        let currentTextureData = this._textureData;
+        if (this._displayIndex >= 0 && this._display !== null && currentTextureData !== null) {
+            let currentTextureAtlasData = currentTextureData.parent;
+            if (this._armature.replacedTexture !== null) {
+                // Update replaced texture atlas.
+                if (this._armature._replaceTextureAtlasData === null) {
+                    currentTextureAtlasData = BaseObject.borrowObject(PixiTextureAtlasData);
+                    currentTextureAtlasData.copyFrom(currentTextureData.parent);
+                    currentTextureAtlasData.renderTexture = this._armature.replacedTexture;
+                    this._armature._replaceTextureAtlasData = currentTextureAtlasData;
+                }
+                else {
+                    currentTextureAtlasData = this._armature._replaceTextureAtlasData;
+                }
+                currentTextureData = currentTextureAtlasData.getTexture(currentTextureData.name);
+            }
+            const renderTexture = currentTextureData.renderTexture;
+            if (renderTexture !== null) {
+                if (this._geometryData !== null) {
+                    // Mesh.
+                    const data = this._geometryData.data;
+                    const intArray = data.intArray;
+                    const floatArray = data.floatArray;
+                    const vertexCount = intArray[this._geometryData.offset + 0 /* BinaryOffset.GeometryVertexCount */];
+                    const triangleCount = intArray[this._geometryData.offset + 1 /* BinaryOffset.GeometryTriangleCount */];
+                    let vertexOffset = intArray[this._geometryData.offset + 2 /* BinaryOffset.GeometryFloatOffset */];
+                    if (vertexOffset < 0) {
+                        vertexOffset += 65536; // Fixed out of bouds bug.
+                    }
+                    const uvOffset = vertexOffset + vertexCount * 2;
+                    const scale = this._armature._armatureData.scale;
+                    const meshDisplay = this._renderDisplay;
+                    const vertices = new Float32Array(vertexCount * 2);
+                    const uvs = new Float32Array(vertexCount * 2);
+                    const indices = new Uint16Array(triangleCount * 3);
+                    for (let i = 0, l = vertexCount * 2; i < l; ++i) {
+                        vertices[i] = floatArray[vertexOffset + i] * scale;
+                    }
+                    for (let i = 0; i < triangleCount * 3; ++i) {
+                        indices[i] = intArray[this._geometryData.offset + 4 /* BinaryOffset.GeometryVertexIndices */ + i];
+                    }
+                    for (let i = 0, l = vertexCount * 2; i < l; i += 2) {
+                        const u = floatArray[uvOffset + i];
+                        const 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.geometry.uvs = uvs;
+                    meshDisplay.geometry.indices = indices;
+                    const isSkinned = this._geometryData.weight !== null;
+                    const isSurface = this._parent._boneData.type !== 0 /* BoneType.Bone */;
+                    if (isSkinned || isSurface) {
+                        this._identityTransform();
+                    }
+                }
+                else {
+                    // Normal texture.
+                    this._textureScale = currentTextureData.parent.scale * this._armature._armatureData.scale;
+                    const normalDisplay = this._renderDisplay;
+                    normalDisplay.texture = renderTexture;
+                }
+                this._visibleDirty = true;
+                return;
+            }
+        }
+        if (this._geometryData !== null) {
+            const meshDisplay = this._renderDisplay;
+            meshDisplay.texture = null;
+            meshDisplay.x = 0.0;
+            meshDisplay.y = 0.0;
+            meshDisplay.visible = false;
+        }
+        else {
+            const normalDisplay = this._renderDisplay;
+            normalDisplay.texture = null;
+            normalDisplay.x = 0.0;
+            normalDisplay.y = 0.0;
+            normalDisplay.visible = false;
+        }
+    }
+    _updateMesh() {
+        const scale = this._armature._armatureData.scale;
+        const deformVertices = this._displayFrame.deformVertices;
+        const bones = this._geometryBones;
+        const geometryData = this._geometryData;
+        const weightData = geometryData.weight;
+        const hasDeform = deformVertices.length > 0 && geometryData.inheritDeform;
+        const meshDisplay = this._renderDisplay;
+        if (weightData !== null) {
+            const data = geometryData.data;
+            const intArray = data.intArray;
+            const floatArray = data.floatArray;
+            const vertexCount = intArray[geometryData.offset + 0 /* BinaryOffset.GeometryVertexCount */];
+            let weightFloatOffset = intArray[weightData.offset + 1 /* BinaryOffset.WeigthFloatOffset */];
+            if (weightFloatOffset < 0) {
+                weightFloatOffset += 65536; // Fixed out of bouds bug.
+            }
+            for (let i = 0, iD = 0, iB = weightData.offset + 2 /* BinaryOffset.WeigthBoneIndices */ + bones.length, iV = weightFloatOffset, iF = 0; i < vertexCount; ++i) {
+                const boneCount = intArray[iB++];
+                let xG = 0.0, yG = 0.0;
+                for (let j = 0; j < boneCount; ++j) {
+                    const boneIndex = intArray[iB++];
+                    const bone = bones[boneIndex];
+                    if (bone !== null) {
+                        const matrix = bone.globalTransformMatrix;
+                        const weight = floatArray[iV++];
+                        let xL = floatArray[iV++] * scale;
+                        let 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;
+                    }
+                }
+                meshDisplay.vertices[iD++] = xG;
+                meshDisplay.vertices[iD++] = yG;
+            }
+        }
+        else {
+            const isSurface = this._parent._boneData.type !== 0 /* BoneType.Bone */;
+            const data = geometryData.data;
+            const intArray = data.intArray;
+            const floatArray = data.floatArray;
+            const vertexCount = intArray[geometryData.offset + 0 /* BinaryOffset.GeometryVertexCount */];
+            let vertexOffset = intArray[geometryData.offset + 2 /* BinaryOffset.GeometryFloatOffset */];
+            if (vertexOffset < 0) {
+                vertexOffset += 65536; // Fixed out of bouds bug.
+            }
+            for (let i = 0, l = vertexCount * 2; i < l; i += 2) {
+                let x = floatArray[vertexOffset + i] * scale;
+                let y = floatArray[vertexOffset + i + 1] * scale;
+                if (hasDeform) {
+                    x += deformVertices[i];
+                    y += deformVertices[i + 1];
+                }
+                if (isSurface) {
+                    const matrix = this._parent._getGlobalTransformMatrix(x, y);
+                    meshDisplay.vertices[i] = matrix.a * x + matrix.c * y + matrix.tx;
+                    meshDisplay.vertices[i + 1] = matrix.b * x + matrix.d * y + matrix.ty;
+                }
+                else {
+                    meshDisplay.vertices[i] = x;
+                    meshDisplay.vertices[i + 1] = y;
+                }
+            }
+        }
+    }
+    _updateTransform() {
+        throw new Error();
+    }
+    /*
+    protected _updateTransformV3(): void {
+      this.updateGlobalTransform(); // Update transform.
+  
+      const transform = this.global;
+  
+      if (this._renderDisplay === this._rawDisplay || this._renderDisplay === this._meshDisplay) {
+        const x = transform.x - (this.globalTransformMatrix.a * this._pivotX + this.globalTransformMatrix.c * this._pivotY);
+        const y = transform.y - (this.globalTransformMatrix.b * this._pivotX + this.globalTransformMatrix.d * this._pivotY);
+        this._renderDisplay.worldTransform.setTransform(
+          x, y,
+          0, 0, //TODO: NOTE: Add pivot
+          transform.scaleX * this._textureScale, transform.scaleY * this._textureScale,
+          transform.rotation,
+          transform.skew, 0.0,
+        );
+      }
+      else {
+        this._renderDisplay.position.set(transform.x, transform.y);
+        this._renderDisplay.rotation = transform.rotation;
+        this._renderDisplay.skew.set(transform.skew, 0.0);
+        this._renderDisplay.scale.set(transform.scaleX, transform.scaleY);
+      }
+    }
+  */
+    _updateTransformV4() {
+        this.updateGlobalTransform(); // Update transform.
+        const transform = this.global;
+        if (this._renderDisplay === this._rawDisplay || this._renderDisplay === this._meshDisplay) {
+            //console.log("PixiSlot._updateTransformV4", "Raw/Mesh", this.name);
+            const x = transform.x - (this.globalTransformMatrix.a * this._pivotX + this.globalTransformMatrix.c * this._pivotY);
+            const y = transform.y - (this.globalTransformMatrix.b * this._pivotX + this.globalTransformMatrix.d * this._pivotY);
+            /*
+            this._renderDisplay.worldTransform.setTransform(
+              x, y,
+              0, 0, //TODO: NOTE: Add pivot
+              transform.scaleX * this._textureScale, transform.scaleY * this._textureScale,
+              transform.rotation,
+              -transform.skew, 0.0
+            );
+            */
+            this._renderDisplay.position.set(x, y);
+            this._renderDisplay.rotation = transform.rotation;
+            this._renderDisplay.skew.set(-transform.skew, 0.0);
+            this._renderDisplay.scale.set(transform.scaleX, transform.scaleY);
+        }
+        else {
+            //console.log("PixiSlot._updateTransformV4", "Sprite", this.name);
+            this._renderDisplay.position.set(transform.x, transform.y);
+            this._renderDisplay.rotation = transform.rotation;
+            this._renderDisplay.skew.set(-transform.skew, 0.0);
+            this._renderDisplay.scale.set(transform.scaleX, transform.scaleY);
+        }
+    }
+    _identityTransform() {
+        this._renderDisplay.worldTransform.setTransform(0.0, 0.0, 0, 0, 1.0, 1.0, 0.0, 0.0, 0.0);
+    }
+}

package/dist/dragonbones/db-pixi/PixiTextureAtlasData.d.ts

@@ -0,0 +1,38 @@
+import * as PIXI from 'pixi.js';
+import { Texture } from 'pixi.js';
+import { TextureAtlasData, TextureData } from '../dragonBones';
+/**
+ * - The PixiJS texture atlas data.
+ * @version DragonBones 3.0
+ * @language en_US
+ */
+export declare class PixiTextureAtlasData extends TextureAtlasData {
+    static toString(): string;
+    private _renderTexture;
+    protected _onClear(): void;
+    /**
+     * @inheritDoc
+     */
+    createTexture(): TextureData;
+    /**
+     * - The PixiJS texture.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - PixiJS 贴图。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    get renderTexture(): Texture | null;
+    set renderTexture(value: Texture | null);
+}
+/**
+ * @internal
+ */
+export declare class PixiTextureData extends TextureData {
+    static toString(): string;
+    renderTexture: PIXI.Texture | null;
+    protected _onClear(): void;
+}
+//# sourceMappingURL=PixiTextureAtlasData.d.ts.map

package/dist/dragonbones/db-pixi/PixiTextureAtlasData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PixiTextureAtlasData.d.ts","sourceRoot":"","sources":["../../../src/dragonbones/db-pixi/PixiTextureAtlasData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAa,OAAO,EAAE,MAAM,SAAS,CAAA;AAC5C,OAAO,EAAc,gBAAgB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC1E;;;;GAIG;AACH,qBAAa,oBAAqB,SAAQ,gBAAgB;WAC1C,QAAQ,IAAI,MAAM;IAIhC,OAAO,CAAC,cAAc,CAAuB;IAE7C,SAAS,CAAC,QAAQ,IAAI,IAAI;IAS1B;;OAEG;IACI,aAAa,IAAI,WAAW;IAGnC;;;;OAIG;IACH;;;;OAIG;IACH,IAAW,aAAa,IAAI,OAAO,GAAG,IAAI,CAEzC;IACD,IAAW,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,EAwB7C;CACF;AACD;;GAEG;AACH,qBAAa,eAAgB,SAAQ,WAAW;WAChC,QAAQ,IAAI,MAAM;IAIzB,aAAa,EAAE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAO;IAEhD,SAAS,CAAC,QAAQ,IAAI,IAAI;CAS3B"}

package/dist/dragonbones/db-pixi/PixiTextureAtlasData.js

@@ -0,0 +1,85 @@
+import { Rectangle, Texture } from 'pixi.js';
+import { BaseObject, TextureAtlasData, TextureData } from '../dragonBones';
+/**
+ * - The PixiJS texture atlas data.
+ * @version DragonBones 3.0
+ * @language en_US
+ */
+export class PixiTextureAtlasData extends TextureAtlasData {
+    constructor() {
+        super(...arguments);
+        this._renderTexture = null; // Initial value.
+    }
+    static toString() {
+        return '[class dragonBones.PixiTextureAtlasData]';
+    }
+    _onClear() {
+        super._onClear();
+        if (this._renderTexture !== null) {
+            // this._renderTexture.dispose();
+        }
+        this._renderTexture = null;
+    }
+    /**
+     * @inheritDoc
+     */
+    createTexture() {
+        return BaseObject.borrowObject(PixiTextureData);
+    }
+    /**
+     * - The PixiJS texture.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - PixiJS 贴图。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    get renderTexture() {
+        return this._renderTexture;
+    }
+    set renderTexture(value) {
+        if (this._renderTexture === value) {
+            return;
+        }
+        this._renderTexture = value;
+        if (this._renderTexture !== null) {
+            for (const k in this.textures) {
+                const textureData = this.textures[k];
+                textureData.renderTexture = new Texture({
+                    source: this._renderTexture.source,
+                    frame: new Rectangle(textureData.region.x, textureData.region.y, textureData.region.width, textureData.region.height),
+                    orig: new Rectangle(textureData.region.x, textureData.region.y, textureData.region.width, textureData.region.height),
+                    trim: new Rectangle(0, 0, textureData.region.width, textureData.region.height),
+                    rotate: textureData.rotated ? 2 : 0,
+                });
+            }
+        }
+        else {
+            for (const k in this.textures) {
+                const textureData = this.textures[k];
+                textureData.renderTexture = null;
+            }
+        }
+    }
+}
+/**
+ * @internal
+ */
+export class PixiTextureData extends TextureData {
+    constructor() {
+        super(...arguments);
+        this.renderTexture = null; // Initial value.
+    }
+    static toString() {
+        return '[class dragonBones.PixiTextureData]';
+    }
+    _onClear() {
+        super._onClear();
+        if (this.renderTexture !== null) {
+            this.renderTexture.destroy(false);
+        }
+        this.renderTexture = null;
+    }
+}

package/dist/dragonbones/db-pixi/index.d.ts

@@ -0,0 +1,5 @@
+export * from './PixiArmatureDisplay';
+export * from './PixiFactory';
+export * from './PixiSlot';
+export * from './PixiTextureAtlasData';
+//# sourceMappingURL=index.d.ts.map

package/dist/dragonbones/db-pixi/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dragonbones/db-pixi/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,wBAAwB,CAAA"}

package/dist/dragonbones/db-pixi/index.js

@@ -0,0 +1,4 @@
+export * from './PixiArmatureDisplay';
+export * from './PixiFactory';
+export * from './PixiSlot';
+export * from './PixiTextureAtlasData';