@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/display/BitmapData.d.ts

@@ -0,0 +1,63 @@
+import { IAssetAdapter } from '@awayjs/core';
+import { BitmapImage2D } from '@awayjs/stage';
+import { Rectangle } from '../geom/Rectangle';
+import { Point } from '../geom/Point';
+import { Matrix } from '../geom/Matrix';
+import { ColorTransform } from '../geom/ColorTransform';
+import { BitmapFilter } from '../filters/BitmapFilter';
+import { IBitmapDrawable } from './IBitmapDrawable';
+import { SceneImage2D } from '@awayjs/scene';
+import { IBitmapDataOwner } from './IBitmapDataOwner';
+import { ASObject, ByteArray, Uint32Vector, GenericVector, ASArray } from '@awayfl/avm2';
+export declare class BitmapData extends ASObject implements IBitmapDrawable, IAssetAdapter {
+    private _adaptee;
+    private _owners;
+    compare(other: BitmapData): boolean;
+    get adaptee(): SceneImage2D;
+    set adaptee(value: SceneImage2D);
+    static loadBitmap(id: string): BitmapData;
+    setPixels(rect: Rectangle, inputByteArray: ByteArray): void;
+    getPixels(rect: Rectangle): ByteArray;
+    copyPixelsToByteArray(rect: Rectangle, data: ByteArray): void;
+    getVector(rect: Rectangle): Uint32Vector;
+    setVector(rect: Rectangle, inputVector: Uint32Vector): void;
+    histogram(hRect?: Rectangle): GenericVector;
+    encode(rect: Rectangle, compressor: ASObject, byteArray?: ByteArray): ByteArray;
+    drawWithQuality(source: any, matrix?: Matrix, colorTransform?: ColorTransform, blendMode?: string, clipRect?: Rectangle, smoothing?: boolean, quality?: string): void;
+    constructor(width: number | SceneImage2D | BitmapImage2D, height?: number, transparent?: boolean, fillColor?: number);
+    get transparent(): boolean;
+    set transparent(value: boolean);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    clone(): BitmapData;
+    get rect(): Rectangle;
+    getPixel(x: number, y: number): number;
+    getPixel32(x: number, y: number): number;
+    setPixel(x: number, y: number, color: number): void;
+    setPixel32(x: number, y: number, color: number): void;
+    applyFilter(sourceBitmap: BitmapData, sourceRect: Rectangle, destPoint: Point, filter: BitmapFilter): void;
+    colorTransform(rect: Rectangle, colorTransform: ColorTransform): void;
+    copyChannel(sourceBitmap: BitmapData, sourceRect: Rectangle, destPoint: Point, sourceChannel: number, destChannel: number): void;
+    copyPixels(sourceBitmap: any, sourceRect: Rectangle, destPoint: Point, alphaBitmapData?: BitmapData, alphaPoint?: Point, mergeAlpha?: boolean): void;
+    dispose(): void;
+    draw(source: any, matrix: Matrix, colorTransform?: ColorTransform, blendMode?: any, clipRect?: Rectangle, smoothing?: boolean): void;
+    fillRect(rect: Rectangle, color: number): void;
+    floodFill(x: number, y: number, color: number): void;
+    generateFilterRect(sourceRect: Rectangle, filter: BitmapFilter): Rectangle;
+    getColorBoundsRect(mask: number, color: number, findColor: boolean): Rectangle;
+    hitTest(firstPoint: Point, firstAlphaThreshold: number, secondObject: any, secondBitmapPoint: Point, secondAlphaThreshold?: number): boolean;
+    lock(): void;
+    merge(sourceBitmap: BitmapData, sourceRect: Rectangle, destPoint: Point, redMult: number, greenMult: number, blueMult: number, alphaMult: number): void;
+    noise(randomSeed: number, low: number, high: number, channelOptions: number, grayScale: boolean): void;
+    paletteMap(sourceBitmap: BitmapData, sourceRect: Rectangle, destPoint: Point, redArray: any[], greenArray: any[], blueArray: any[], alphaArray: any[]): void;
+    perlinNoise(baseX: number, baseY: number, numOctaves: number, randomSeed: number, stitch: boolean, fractalNoise: boolean, channelOptions: number, grayScale: boolean, offsets?: ASArray): void;
+    pixelDissolve(sourceBitmap: BitmapData, sourceRect: Rectangle, destPoint: Point, randomSeed: number, numberOfPixels: number, fillColor: number): number;
+    scroll(x: number, y: number): void;
+    threshold(sourceBitmap: BitmapData, sourceRect: Rectangle, destPoint: Point, operation: string, threshold: number, color: number, mask: number, copySource: boolean): number;
+    unlock(): void;
+    _addOwner(owner: IBitmapDataOwner): void;
+    _removeOwner(owner: IBitmapDataOwner): void;
+}
+//# sourceMappingURL=BitmapData.d.ts.map

package/dist/lib/display/BitmapData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BitmapData.d.ts","sourceRoot":"","sources":["../../../lib/display/BitmapData.ts"],"names":[],"mappings":"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"}

package/dist/lib/display/BitmapData.js

@@ -0,0 +1,315 @@
+import { __extends } from "tslib";
+import { Debug, Point as APoint } from '@awayjs/core';
+import { StageManager } from '@awayjs/stage';
+import { SceneImage2D } from '@awayjs/scene';
+import { ASObject } from '@awayfl/avm2';
+var ALER_TABLE = {};
+var ALERT_ONCE = function (id, message) {
+    if (ALER_TABLE[id])
+        return;
+    console.warn("".concat(id, ":"), message);
+    ALER_TABLE[id] = true;
+};
+var BitmapData = /** @class */ (function (_super) {
+    __extends(BitmapData, _super);
+    function BitmapData(width, height, transparent, fillColor) {
+        if (transparent === void 0) { transparent = true; }
+        if (fillColor === void 0) { fillColor = 0xffffffff; }
+        var _this = _super.call(this) || this;
+        _this._owners = [];
+        if (typeof width === 'number') {
+            if (!_this._adaptee) {
+                _this._adaptee = SceneImage2D.getImage(width, height, transparent, fillColor, false, StageManager.getInstance().getStageAt(0));
+                // we construct a SceneImage2D direct, use weak, that call dispose after garbaging
+                _this._adaptee.useWeakRef();
+            }
+        }
+        else {
+            _this._adaptee = width;
+        }
+        _this._adaptee.adapter = _this;
+        return _this;
+    }
+    // for AVM1:
+    BitmapData.prototype.compare = function (other) {
+        return true;
+    };
+    Object.defineProperty(BitmapData.prototype, "adaptee", {
+        get: function () {
+            return this._adaptee;
+        },
+        set: function (value) {
+            this._adaptee = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BitmapData.loadBitmap = function (id) {
+        // @todo
+        Debug.throwPIR('playerglobals/display/BitmapData', 'loadBitmap', '');
+        return null;
+    };
+    BitmapData.prototype.setPixels = function (rect, inputByteArray) {
+        var count = (rect.width | 0) * (rect.height | 0);
+        var argb = new Uint8ClampedArray(count * 4);
+        // ByteArray holds 32-bit unmultiplied ARGB (readUnsignedInt order).
+        for (var i = 0; i < count; i++) {
+            var v = inputByteArray.readUnsignedInt() >>> 0;
+            var o = i * 4;
+            argb[o] = v >>> 24;
+            argb[o + 1] = (v >>> 16) & 0xff;
+            argb[o + 2] = (v >>> 8) & 0xff;
+            argb[o + 3] = v & 0xff;
+        }
+        this.adaptee.setPixels(rect.adaptee, argb);
+    };
+    BitmapData.prototype.getPixels = function (rect) {
+        // Adaptee returns unmultiplied ARGB bytes - wrap without channel reorder.
+        var pixels = this.adaptee.getPixels(rect.adaptee);
+        var buffer = pixels.buffer.slice(pixels.byteOffset, pixels.byteOffset + pixels.byteLength);
+        var arr = new this.sec.flash.utils.ByteArray();
+        // @ts-ignore
+        arr.setArrayBuffer(buffer);
+        return arr;
+    };
+    BitmapData.prototype.copyPixelsToByteArray = function (rect, data) {
+        // @todo
+        Debug.throwPIR('playerglobals/display/BitmapData', 'copyPixelsToByteArray', '');
+    };
+    BitmapData.prototype.getVector = function (rect) {
+        // Adaptee returns unmultiplied ARGB bytes; pack as ARGB uint32s.
+        var u8 = this.adaptee.getPixels(rect.adaptee);
+        var vector = new this.sec.Uint32Vector(0, true);
+        var count = (u8.length / 4) | 0;
+        var u32 = new Uint32Array(count);
+        for (var i = 0; i < count; i++) {
+            var o = i * 4;
+            u32[i] = ((u8[o] << 24) | (u8[o + 1] << 16) | (u8[o + 2] << 8) | u8[o + 3]) >>> 0;
+        }
+        // replace a buffer for avoid coping
+        //@ts-ignore
+        vector._buffer = u32;
+        // remap size
+        //@ts-ignore
+        vector._length = u32.length;
+        return vector;
+    };
+    BitmapData.prototype.setVector = function (rect, inputVector) {
+        var count = (rect.width | 0) * (rect.height | 0);
+        var argb = new Uint8ClampedArray(count * 4);
+        var src = inputVector._view();
+        for (var i = 0; i < count; i++) {
+            var v = src[i] >>> 0;
+            var o = i * 4;
+            argb[o] = v >>> 24;
+            argb[o + 1] = (v >>> 16) & 0xff;
+            argb[o + 2] = (v >>> 8) & 0xff;
+            argb[o + 3] = v & 0xff;
+        }
+        this.adaptee.setPixels(rect.adaptee, argb);
+    };
+    BitmapData.prototype.histogram = function (hRect) {
+        if (hRect === void 0) { hRect = null; }
+        // @todo
+        Debug.throwPIR('playerglobals/display/BitmapData', 'histogram', '');
+        return;
+    };
+    BitmapData.prototype.encode = function (rect, compressor, byteArray) {
+        if (byteArray === void 0) { byteArray = null; }
+        // @todo
+        Debug.throwPIR('playerglobals/display/BitmapData', 'encode', '');
+        return;
+    };
+    BitmapData.prototype.drawWithQuality = function (source, matrix, colorTransform, blendMode, clipRect, smoothing, quality) {
+        if (matrix === void 0) { matrix = null; }
+        if (colorTransform === void 0) { colorTransform = null; }
+        if (blendMode === void 0) { blendMode = null; }
+        if (clipRect === void 0) { clipRect = null; }
+        if (smoothing === void 0) { smoothing = false; }
+        if (quality === void 0) { quality = null; }
+        this._adaptee.draw(source.adaptee, matrix === null || matrix === void 0 ? void 0 : matrix.adaptee, colorTransform === null || colorTransform === void 0 ? void 0 : colorTransform.adaptee, blendMode, clipRect === null || clipRect === void 0 ? void 0 : clipRect.adaptee, smoothing);
+    };
+    Object.defineProperty(BitmapData.prototype, "transparent", {
+        get: function () {
+            return this._adaptee.transparent;
+        },
+        set: function (value) {
+            this._adaptee.transparent = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BitmapData.prototype, "width", {
+        get: function () {
+            return this._adaptee.width;
+        },
+        set: function (value) {
+            this._adaptee.width = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BitmapData.prototype, "height", {
+        get: function () {
+            return this._adaptee.height;
+        },
+        set: function (value) {
+            this._adaptee.height = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BitmapData.prototype.clone = function () {
+        var clone = new this.sec.flash.display.BitmapData(this._adaptee.width, this._adaptee.height, this._adaptee.transparent, null);
+        // refclone
+        if (this._adaptee.copyTo) {
+            this._adaptee.copyTo(clone._adaptee);
+        }
+        else {
+            clone.copyPixels(this, this.rect, new this.sec.flash.geom.Point());
+        }
+        return clone;
+    };
+    Object.defineProperty(BitmapData.prototype, "rect", {
+        get: function () {
+            return new this.sec.flash.geom.Rectangle(this._adaptee.rect.clone());
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BitmapData.prototype.getPixel = function (x, y) {
+        return this._adaptee.getPixel(x, y);
+    };
+    BitmapData.prototype.getPixel32 = function (x, y) {
+        return this._adaptee.getPixel32(x, y);
+    };
+    BitmapData.prototype.setPixel = function (x, y, color) {
+        this._adaptee.setPixel(x, y, color);
+    };
+    BitmapData.prototype.setPixel32 = function (x, y, color) {
+        this._adaptee.setPixel32(x, y, color);
+    };
+    BitmapData.prototype.applyFilter = function (sourceBitmap, sourceRect, destPoint, filter) {
+        if (this._adaptee.applyFilter(sourceBitmap.adaptee, sourceRect.adaptee, destPoint.adaptee, filter.toAwayObject())) {
+            return;
+        }
+        Debug.throwPIR('playerglobals/display/BitmapData', 'applyFilter', filter.axClassName);
+    };
+    BitmapData.prototype.colorTransform = function (rect, colorTransform) {
+        this._adaptee.colorTransform(rect.adaptee, colorTransform.adaptee);
+    };
+    BitmapData.prototype.copyChannel = function (sourceBitmap, sourceRect, destPoint, sourceChannel, destChannel) {
+        this._adaptee.copyChannel(sourceBitmap.adaptee, sourceRect.adaptee, destPoint.adaptee, sourceChannel, destChannel);
+    };
+    BitmapData.prototype.copyPixels = function (sourceBitmap, sourceRect, destPoint, alphaBitmapData, alphaPoint, mergeAlpha) {
+        if (alphaBitmapData === void 0) { alphaBitmapData = null; }
+        if (alphaPoint === void 0) { alphaPoint = null; }
+        if (mergeAlpha === void 0) { mergeAlpha = false; }
+        this._adaptee.copyPixels(sourceBitmap.adaptee, sourceRect.adaptee, destPoint.adaptee, alphaBitmapData ? alphaBitmapData.adaptee : null, alphaPoint ? alphaPoint.adaptee : null, mergeAlpha);
+    };
+    BitmapData.prototype.dispose = function () {
+        // already disposed or not setted
+        if (!this._adaptee)
+            return;
+        //remove all owners
+        this._owners = [];
+        if (this._adaptee.canUnload) {
+            this._adaptee.dispose();
+        }
+        this._adaptee = null;
+    };
+    BitmapData.prototype.draw = function (source, matrix, colorTransform, blendMode, clipRect, smoothing) {
+        if (colorTransform === void 0) { colorTransform = null; }
+        if (blendMode === void 0) { blendMode = ''; }
+        if (clipRect === void 0) { clipRect = null; }
+        if (smoothing === void 0) { smoothing = false; }
+        this._adaptee.draw(source.adaptee, matrix === null || matrix === void 0 ? void 0 : matrix.adaptee, colorTransform === null || colorTransform === void 0 ? void 0 : colorTransform.adaptee, blendMode, clipRect === null || clipRect === void 0 ? void 0 : clipRect.adaptee, smoothing);
+    };
+    BitmapData.prototype.fillRect = function (rect, color) {
+        // var colorArr = ColorUtils.float32ColorToARGB(color);
+        // color = ColorUtils.ARGBtoFloat32(colorArr[0], colorArr[3], colorArr[2], colorArr[1]);
+        this._adaptee.fillRect(rect.adaptee, color);
+    };
+    BitmapData.prototype.floodFill = function (x, y, color) {
+        ALERT_ONCE('floodFill:' + this._adaptee.id, 'Unsage implementation!');
+        this._adaptee.floodFill(x, y, color);
+    };
+    BitmapData.prototype.generateFilterRect = function (sourceRect, filter) {
+        Debug.throwPIR('playerglobals/display/BitmapData', 'generateFilterRect', '');
+        return null;
+    };
+    BitmapData.prototype.getColorBoundsRect = function (mask, color, findColor) {
+        Debug.throwPIR('playerglobals/display/BitmapData', 'getColorBoundsRect', '');
+        return new this.sec.flash.geom.Rectangle(this._adaptee.getColorBoundsRect(mask, color, findColor));
+    };
+    BitmapData.prototype.hitTest = function (firstPoint, firstAlphaThreshold, secondObject, secondBitmapPoint, secondAlphaThreshold) {
+        if (secondAlphaThreshold === void 0) { secondAlphaThreshold = 0; }
+        Debug.throwPIR('playerglobals/display/BitmapData', 'hitTest', '');
+        return this._adaptee.hitTest(firstPoint.adaptee, firstAlphaThreshold, secondObject === null || secondObject === void 0 ? void 0 : secondObject.adaptee, secondBitmapPoint === null || secondBitmapPoint === void 0 ? void 0 : secondBitmapPoint.adaptee, secondAlphaThreshold);
+    };
+    BitmapData.prototype.lock = function () {
+        this._adaptee.lock();
+    };
+    BitmapData.prototype.merge = function (sourceBitmap, sourceRect, destPoint, redMult, greenMult, blueMult, alphaMult) {
+        this._adaptee.merge(sourceBitmap.adaptee, sourceBitmap.rect.adaptee, destPoint.adaptee, redMult, greenMult, blueMult, alphaMult);
+    };
+    BitmapData.prototype.noise = function (randomSeed, low, high, channelOptions, grayScale) {
+        this._adaptee.noise(randomSeed, low, high, channelOptions, grayScale);
+    };
+    BitmapData.prototype.paletteMap = function (sourceBitmap, sourceRect, destPoint, redArray, greenArray, blueArray, alphaArray) {
+        Debug.throwPIR('playerglobals/display/BitmapData', 'paletteMap', '');
+    };
+    BitmapData.prototype.perlinNoise = function (baseX, baseY, numOctaves, randomSeed, stitch, fractalNoise, channelOptions, grayScale, offsets) {
+        if (offsets === void 0) { offsets = null; }
+        var map_offsets = offsets ? [] : null;
+        if (offsets) {
+            var value = offsets.value;
+            var len = value.length;
+            // this is VERY strange, some games use [1, 1] and then push Point to offsets, map to [x, y, x, y]
+            for (var i = 0; i < len; i++) {
+                if (typeof value[i] === 'number') {
+                    map_offsets.push(value[i]);
+                }
+                else if (typeof value[i].x === 'number') {
+                    map_offsets.push(value[i].x, value[i].y);
+                }
+            }
+        }
+        //@ts-ignore
+        this._adaptee.perlinNoise(baseX, baseY, numOctaves, randomSeed, stitch, fractalNoise, channelOptions, grayScale, map_offsets);
+        Debug.throwPIR('playerglobals/display/BitmapData', 'perlinNoise', 'Unsafe implementation, results not equal!');
+    };
+    BitmapData.prototype.pixelDissolve = function (sourceBitmap, sourceRect, destPoint, randomSeed, numberOfPixels, fillColor) {
+        Debug.throwPIR('playerglobals/display/BitmapData', 'pixelDissolve', '');
+        return 0;
+    };
+    BitmapData.prototype.scroll = function (x, y) {
+        x = x | 0;
+        y = y | 0;
+        // 0, 0 scroll - is not scroll
+        if (!x && !y)
+            return;
+        this._adaptee.copyPixels(this._adaptee, this._adaptee.rect, new APoint(x, y), null, null, false);
+        //console.log('scroll not implemented yet in flash/BitmapData');
+    };
+    BitmapData.prototype.threshold = function (sourceBitmap, sourceRect, destPoint, operation, threshold, color, mask, copySource) {
+        this._adaptee.threshold(sourceBitmap.adaptee, sourceRect.adaptee, destPoint.adaptee, operation, threshold, color, mask, copySource);
+        return 0; //number of pixels is not implemented
+    };
+    BitmapData.prototype.unlock = function () {
+        this._adaptee.unlock();
+    };
+    BitmapData.prototype._addOwner = function (owner) {
+        //if (this._owners.indexOf(owner) == -1) this._owners.push(owner);
+    };
+    BitmapData.prototype._removeOwner = function (owner) {
+        // const index: number = this._owners.indexOf(owner);
+        // if (index != -1) {
+        // 	this._owners.splice(index, 1);
+        // 	if (this._owners.length === 0)
+        // 		this._adaptee.clear();
+        // }
+    };
+    return BitmapData;
+}(ASObject));
+export { BitmapData };

package/dist/lib/display/BitmapDataChannel.d.ts

@@ -0,0 +1,12 @@
+import { ASObject } from '@awayfl/avm2';
+export declare class BitmapDataChannel extends ASObject {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    constructor();
+    static ALPHA: number;
+    static BLUE: number;
+    static GREEN: number;
+    static RED: number;
+}
+//# sourceMappingURL=BitmapDataChannel.d.ts.map

package/dist/lib/display/BitmapDataChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BitmapDataChannel.d.ts","sourceRoot":"","sources":["../../../lib/display/BitmapDataChannel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,qBAAa,iBAAkB,SAAQ,QAAQ;IAG9C,OAAc,gBAAgB,EAAE,GAAG,CAAQ;IAG3C,OAAc,YAAY,EAAE,MAAM,EAAG,CAAQ;IAG7C,OAAc,eAAe,EAAE,MAAM,EAAG,CAAQ;;IAOhD,OAAc,KAAK,EAAE,MAAM,CAAc;IACzC,OAAc,IAAI,EAAE,MAAM,CAAc;IACxC,OAAc,KAAK,EAAE,MAAM,CAAc;IACzC,OAAc,GAAG,EAAE,MAAM,CAAc;CAEvC"}

package/dist/lib/display/BitmapDataChannel.js

@@ -0,0 +1,21 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+var BitmapDataChannel = /** @class */ (function (_super) {
+    __extends(BitmapDataChannel, _super);
+    function BitmapDataChannel() {
+        return _super.call(this) || this;
+    }
+    // Called whenever the class is initialized.
+    BitmapDataChannel.classInitializer = null;
+    // List of static symbols to link.
+    BitmapDataChannel.classSymbols = null; // [];
+    // List of instance symbols to link.
+    BitmapDataChannel.instanceSymbols = null; // [];
+    // JS -> AS Bindings
+    BitmapDataChannel.ALPHA = 8;
+    BitmapDataChannel.BLUE = 4;
+    BitmapDataChannel.GREEN = 2;
+    BitmapDataChannel.RED = 1;
+    return BitmapDataChannel;
+}(ASObject));
+export { BitmapDataChannel };