@awayjs/stage

import { ColorTransform, Matrix, Rectangle, Point, IAssetAdapter, AssetEvent, IAsset } from '@awayjs/core'; import { UnloadManager, IUnloadable } from './../managers/UnloadManager'; import { Image2D } from './Image2D'; interface LazyImageSymbolTag { needParse: boolean; lazyParser(): LazyImageSymbolTag; definition: { width: number; height: number; data: Uint8ClampedArray; isPMA?: boolean; }; } export declare class BitmapImage2D extends Image2D implements IUnloadable { static UNLOAD_EVENT: string; static assetType: string; static _unloadManager: UnloadManager<BitmapImage2D>; static getManager(stage: Stage): UnloadManager<BitmapImage2D>; private _asyncRead; _lazySymbol: LazyImageSymbolTag; protected _isSymbolSource: boolean; protected _data: Uint8ClampedArray; protected _isWeakRef: boolean; protected _finalizer: FinalizationRegistry<any>; protected _weakRefAdapter: WeakRef<IAssetAdapter>; protected _transparent: boolean; protected _unpackPMA: boolean; protected _stage: Stage; protected _locked: boolean; protected _floodStack: number[]; protected _nestedBitmap: BitmapImage2D[]; protected _sourceBitmap: BitmapImage2D; protected _imageDataDirty: boolean; protected _initalFillColor: number; protected _lastUsedFill: number; protected syncData(async?: boolean): boolean | Promise<boolean>; getDataInternal(constructEmpty?: boolean, skipSync?: boolean): Uint8ClampedArray; needUpload: boolean; /** * @description Upload flag, marking a image that it was uploaded on GPU * and can use GPU operations * fillRect can be implemented on GPU or CPU */ wasUpload: boolean; get sourceBitmap(): BitmapImage2D; invalidateGPU(): void; invalidate(): void; isUnloaded: boolean; lastUsedTime: number; get canUnload(): boolean; unmarkToUnload(): void; markToUnload(): void; unload(): void; private _customMipLevels; addMipLevel(newLevel: BitmapImage2D): void; get mipLevels(): BitmapImage2D[]; /** * * @returns {string} */ get assetType(): string; /** * Defines whether the bitmap image supports per-pixel transparency. You can * set this value only when you construct a BitmapImage2D object by passing in * <code>true</code> for the <code>transparent</code> parameter of the * constructor. Then, after you create a BitmapImage2D object, you can check * whether it supports per-pixel transparency by determining if the value of * the <code>transparent</code> property is <code>true</code>. */ get transparent(): boolean; set transparent(value: boolean); /** * Store a mode, witch should be uploaded to GPU * not all case PMA is should be enabled */ get unpackPMA(): boolean; /** * Creates a BitmapImage2D object with a specified width and height. If you * specify a value for the <code>fillColor</code> parameter, every pixel in * the bitmap is set to that color. * * By default, the bitmap is created as transparent, unless you pass * the value <code>false</code> for the transparent parameter. After you * create an opaque bitmap, you cannot change it to a transparent bitmap. * Every pixel in an opaque bitmap uses only 24 bits of color channel * information. If you define the bitmap as transparent, every pixel uses 32 * bits of color channel information, including an alpha transparency * channel. * * @param width The width of the bitmap image in pixels. * @param height The height of the bitmap image in pixels. * @param transparent Specifies whether the bitmap image supports per-pixel * transparency. The default value is <code>true</code> * (transparent). To create a fully transparent bitmap, * set the value of the <code>transparent</code> * parameter to <code>true</code> and the value of the * <code>fillColor</code> parameter to 0x00000000(or to * 0). Setting the <code>transparent</code> property to * <code>false</code> can result in minor improvements * in rendering performance. * @param fillColor A 32-bit ARGB color value that you use to fill the * bitmap image area. The default value is * 0xFFFFFFFF(solid white). */ constructor(width: number, height: number, transparent?: boolean, fillColor?: number, powerOfTwo?: boolean, stage?: Stage); addLazySymbol(tag: LazyImageSymbolTag): void; applySymbol(): boolean; /** * @description transfer adapter to weak mode * Reference will dropped, and adapter destroyed after collecting a adapter */ useWeakRef(): void; unuseWeakRef(): void; get isWeakRef(): boolean; set adapter(v: IAssetAdapter); get adapter(): IAssetAdapter; private onAdapterDropped; addNestedReference(child: BitmapImage2D): void; dropNestedReference(child: BitmapImage2D): boolean; /** * @description Detach clone from source, and apply texture directly */ dropAllReferences(fireDroping?: boolean): void; protected deepClone(from: BitmapImage2D): void; copyTo(target: BitmapImage2D): BitmapImage2D; /** * Returns a new BitmapImage2D object that is a clone of the original instance * with an exact copy of the contained bitmap. * * @return A new BitmapImage2D object that is identical to the original. */ clone(): BitmapImage2D; /** * Adjusts the color values in a specified area of a bitmap image by using a * <code>ColorTransform</code> object. If the rectangle matches the * boundaries of the bitmap image, this method transforms the color values of * the entire image. * * @param rect A Rectangle object that defines the area of the * image in which the ColorTransform object is applied. * @param colorTransform A ColorTransform object that describes the color * transformation values to apply. */ colorTransform(rect: Rectangle, colorTransform: ColorTransform): void; /** * Transfers data from one channel of another BitmapImage2D object or the * current BitmapImage2D object into a channel of the current BitmapImage2D object. * All of the data in the other channels in the destination BitmapImage2D object * are preserved. * * The source channel value and destination channel value can be one of * following values: * * <ul> * <li><code>BitmapImage2DChannel.RED</code></li> * <li><code>BitmapImage2DChannel.GREEN</code></li> * <li><code>BitmapImage2DChannel.BLUE</code></li> * <li><code>BitmapImage2DChannel.ALPHA</code></li> * </ul> * * @param sourceBitmapImage2D The input bitmap image to use. The source image * can be a different BitmapImage2D object or it can * refer to the current BitmapImage2D object. * @param sourceRect The source Rectangle object. To copy only channel * data from a smaller area within the bitmap, * specify a source rectangle that is smaller than * the overall size of the BitmapImage2D object. * @param destPoint The destination Point object that represents the * upper-left corner of the rectangular area where * the new channel data is placed. To copy only * channel data from one area to a different area in * the destination image, specify a point other than * (0,0). * @param sourceChannel The source channel. Use a value from the * BitmapImage2DChannel class * (<code>BitmapImage2DChannel.RED</code>, * <code>BitmapImage2DChannel.BLUE</code>, * <code>BitmapImage2DChannel.GREEN</code>, * <code>BitmapImage2DChannel.ALPHA</code>). * @param destChannel The destination channel. Use a value from the * BitmapImage2DChannel class * (<code>BitmapImage2DChannel.RED</code>, * <code>BitmapImage2DChannel.BLUE</code>, * <code>BitmapImage2DChannel.GREEN</code>, * <code>BitmapImage2DChannel.ALPHA</code>). * @throws TypeError The sourceBitmapImage2D, sourceRect or destPoint are null. */ copyChannel(sourceBitmap: BitmapImage2D, sourceRect: Rectangle, destPoint: Point, sourceChannel: number, destChannel: number): void; merge(source: BitmapImage2D, sourceRect: Rectangle, destPoint: Point, redMultiplier: number, greenMultiplier: number, blueMultiplier: number, alphaMultiplier: number): void; /** * Frees memory that is used to store the BitmapImage2D object. * * When the <code>dispose()</code> method is called on an image, the width * and height of the image are set to 0. All subsequent calls to methods or * properties of this BitmapImage2D instance fail, and an exception is thrown. * * * <code>BitmapImage2D.dispose()</code> releases the memory occupied by the * actual bitmap data, immediately(a bitmap can consume up to 64 MB of * memory). After using <code>BitmapImage2D.dispose()</code>, the BitmapImage2D * object is no longer usable and an exception may be thrown if * you call functions on the BitmapImage2D object. However, * <code>BitmapImage2D.dispose()</code> does not garbage collect the BitmapImage2D * object(approximately 128 bytes); the memory occupied by the actual * BitmapImage2D object is released at the time the BitmapImage2D object is * collected by the garbage collector. * */ dispose(): void; getColorBoundsRect(mask: number, color: number, findColor?: boolean): Rectangle; hitTest(firstPoint: Point, firstAlphaThreshold: ui8, secondObject: Point | Rectangle | BitmapImage2D, secondBitmapDataPoint?: Point, secondAlphaThreshold?: ui8): boolean; floodFill(x: number, y: number, color: number): void; /** * Ruffle port of noise * @see https://github.com/ruffle-rs/ruffle/blob/d43b033caa98ed201f37558c25f9ce5f2da189d0/core/src/avm1/object/bitmap_data.rs#L326 */ noise(randomSeed: number, low?: ui8, high?: ui8, channelOptions?: ui8, grayScale?: boolean): void; /** * Ruffle port of perlinNoise * There are not guarantees that it valid =) * RESULT IS NOT EQUAL A FLASH RESULT, SEED IS WRONG!! * @see https://github.com/ruffle-rs/ruffle/blob/d43b033caa98ed201f37558c25f9ce5f2da189d0/core/src/avm1/object/bitmap_data.rs#L713 */ perlinNoise(baseX: number, baseY: number, numOctaves: number, randomSeed: number, stitch: boolean, fractalNoise: boolean, channelOptions?: ui8, grayScale?: boolean, offsets?: Array<number | Point>): void; drawBitmap(source: Uint8ClampedArray, offsetX: number, offsetY: number, width: number, height: number, matrix?: Matrix): void; /** * Fills a rectangular area of pixels with a specified ARGB color. * * @param rect The rectangular area to fill. * @param color The ARGB color value that fills the area. ARGB colors are * often specified in hexadecimal format; for example, * 0xFF336699. * @throws TypeError The rect is null. */ fillRect(rect: Rectangle, color: number, useCPU?: boolean): void; /** * Returns an integer that represents an RGB pixel value from a BitmapImage2D * object at a specific point(x, y). The * <code>getPixel()</code> method returns an unmultiplied pixel value. No * alpha information is returned. * * All pixels in a BitmapImage2D object are stored as premultiplied color * values. A premultiplied image pixel has the red, green, and blue color * channel values already multiplied by the alpha data. For example, if the * alpha value is 0, the values for the RGB channels are also 0, independent * of their unmultiplied values. This loss of data can cause some problems * when you perform operations. All BitmapImage2D methods take and return * unmultiplied values. The internal pixel representation is converted from * premultiplied to unmultiplied before it is returned as a value. During a * set operation, the pixel value is premultiplied before the raw image pixel * is set. * * @param x The x position of the pixel. * @param y The y position of the pixel. * @return A number that represents an RGB pixel value. If the(x, * y) coordinates are outside the bounds of the image, the * method returns 0. */ getPixel(x: any, y: any): number; /** * Returns an ARGB color value that contains alpha channel data and RGB data. * This method is similar to the <code>getPixel()</code> method, which * returns an RGB color without alpha channel data. * * All pixels in a BitmapImage2D object are stored as premultiplied color * values. A premultiplied image pixel has the red, green, and blue color * channel values already multiplied by the alpha data. For example, if the * alpha value is 0, the values for the RGB channels are also 0, independent * of their unmultiplied values. This loss of data can cause some problems * when you perform operations. All BitmapImage2D methods take and return * unmultiplied values. The internal pixel representation is converted from * premultiplied to unmultiplied before it is returned as a value. During a * set operation, the pixel value is premultiplied before the raw image pixel * is set. * * @param x The x position of the pixel. * @param y The y position of the pixel. * @return A number representing an ARGB pixel value. If the(x, * y) coordinates are outside the bounds of the image, 0 is * returned. */ getPixel32(x: any, y: any): number; getPixels(rect: Rectangle): Uint8ClampedArray; getPixelData(x: any, y: any, imagePixel: Uint8ClampedArray): void; setPixelData(x: any, y: any, imagePixel: Uint8ClampedArray): void; /** * Locks an image so that any objects that reference the BitmapImage2D object, * such as Bitmap objects, are not updated when this BitmapImage2D object * changes. To improve performance, use this method along with the * <code>unlock()</code> method before and after numerous calls to the * <code>setPixel()</code> or <code>setPixel32()</code> method. * */ lock(): void; /** * Converts an Array into a rectangular region of pixel data. For each pixel, * an Array element is read and written into the BitmapImage2D pixel. The data * in the Array is expected to be 32-bit ARGB pixel values. * * @param rect Specifies the rectangular region of the BitmapImage2D * object. * @param inputArray An Array that consists of 32-bit unmultiplied pixel * values to be used in the rectangular region. * @throws RangeError The vector array is not large enough to read all the * pixel data. */ setArray(rect: Rectangle, inputArray: Array<number>): void; /** * Sets a single pixel of a BitmapImage2D object. The current alpha channel * value of the image pixel is preserved during this operation. The value of * the RGB color parameter is treated as an unmultiplied color value. * * Note: To increase performance, when you use the * <code>setPixel()</code> or <code>setPixel32()</code> method repeatedly, * call the <code>lock()</code> method before you call the * <code>setPixel()</code> or <code>setPixel32()</code> method, and then call * the <code>unlock()</code> method when you have made all pixel changes. * This process prevents objects that reference this BitmapImage2D instance from * updating until you finish making the pixel changes. * * @param x The x position of the pixel whose value changes. * @param y The y position of the pixel whose value changes. * @param color The resulting RGB color for the pixel. */ setPixel(x: number, y: number, color: number): void; setPixelFromArray(x: number, y: number, colors: number[]): void; /** * Sets the color and alpha transparency values of a single pixel of a * BitmapImage2D object. This method is similar to the <code>setPixel()</code> * method; the main difference is that the <code>setPixel32()</code> method * takes an ARGB color value that contains alpha channel information. * * All pixels in a BitmapImage2D object are stored as premultiplied color * values. A premultiplied image pixel has the red, green, and blue color * channel values already multiplied by the alpha data. For example, if the * alpha value is 0, the values for the RGB channels are also 0, independent * of their unmultiplied values. This loss of data can cause some problems * when you perform operations. All BitmapImage2D methods take and return * unmultiplied values. The internal pixel representation is converted from * premultiplied to unmultiplied before it is returned as a value. During a * set operation, the pixel value is premultiplied before the raw image pixel * is set. * * Note: To increase performance, when you use the * <code>setPixel()</code> or <code>setPixel32()</code> method repeatedly, * call the <code>lock()</code> method before you call the * <code>setPixel()</code> or <code>setPixel32()</code> method, and then call * the <code>unlock()</code> method when you have made all pixel changes. * This process prevents objects that reference this BitmapImage2D instance from * updating until you finish making the pixel changes. * * @param x The x position of the pixel whose value changes. * @param y The y position of the pixel whose value changes. * @param color The resulting ARGB color for the pixel. If the bitmap is * opaque(not transparent), the alpha transparency portion of * this color value is ignored. */ setPixel32(x: number, y: number, color: number): void; /** * Converts a byte array into a rectangular region of pixel data. For each * pixel, the <code>ByteArray.readUnsignedInt()</code> method is called and * the return value is written into the pixel. If the byte array ends before * the full rectangle is written, the function returns. The data in the byte * array is expected to be 32-bit ARGB pixel values. No seeking is performed * on the byte array before or after the pixels are read. * * @param rect Specifies the rectangular region of the BitmapImage2D * object. * @param input A ByteArray object that consists of 32-bit * unmultiplied pixel values to be used in the * rectangular region. * @throws EOFError The <code>inputByteArray</code> object does not include * enough data to fill the area of the <code>rect</code> * rectangle. The method fills as many pixels as possible * before throwing the exception. * @throws TypeError The rect or inputByteArray are null. */ setPixels(rect: Rectangle, input: Uint8ClampedArray): void; applyFilter(source: BitmapImage2D, sourceRect: Rectangle, destPoint: Point, filter: any): boolean; /** * Unlocks an image so that any objects that reference the BitmapImage2D object, * such as Bitmap objects, are updated when this BitmapImage2D object changes. * To improve performance, use this method along with the <code>lock()</code> * method before and after numerous calls to the <code>setPixel()</code> or * <code>setPixel32()</code> method. * * @param changeRect The area of the BitmapImage2D object that has changed. If * you do not specify a value for this parameter, the * entire area of the BitmapImage2D object is considered * changed. */ unlock(): void; /** * @inheritdoc */ set alphaChannel(buff: Uint8Array); /** * * @returns {ImageData} */ get data(): Uint8ClampedArray; /** * * @param width * @param height * @private */ _setSize(width: number, height: number): void; private getDebugCanvas; private getDebugImage; } import { ITextureBase } from '../base/ITextureBase'; import { _Stage_Image2D } from './Image2D'; import { Stage } from '../Stage'; /** * * @class away.pool.ImageObjectBase */ export declare class _Stage_BitmapImage2D extends _Stage_Image2D { private onUnload; init(asset: IAsset, pool: Stage): void; onClear(event: AssetEvent): void; getTexture(): ITextureBase; } export {}; //# sourceMappingURL=BitmapImage2D.d.ts.map