import { ColorTransform, Matrix, Rectangle, Point } from '@awayjs/core';
import { BitmapImage2D } from './BitmapImage2D';
import { ImageCube } from './ImageCube';
/**
* The BitmapImage2D export class lets you work with the data(pixels) of a Bitmap
* object. You can use the methods of the BitmapImage2D export class to create
* arbitrarily sized transparent or opaque bitmap images and manipulate them
* in various ways at runtime. You can also access the BitmapImage2D for a bitmap
* image that you load with the flash.Assets or
* flash.display.Loader classes.
*
*
This export class lets you separate bitmap rendering operations from the * internal display updating routines of flash. By manipulating a * BitmapImage2D object directly, you can create complex images without incurring * the per-frame overhead of constantly redrawing the content from vector * data.
* *The methods of the BitmapImage2D export class support effects that are not * available through the filters available to non-bitmap display objects.
* *A BitmapImage2D object contains an array of pixel data. This data can * represent either a fully opaque bitmap or a transparent bitmap that * contains alpha channel data. Either type of BitmapImage2D object is stored as * a buffer of 32-bit integers. Each 32-bit integer determines the properties * of a single pixel in the bitmap.
* *Each 32-bit integer is a combination of four 8-bit channel values(from * 0 to 255) that describe the alpha transparency and the red, green, and blue * (ARGB) values of the pixel.(For ARGB values, the most significant byte * represents the alpha channel value, followed by red, green, and blue.)
* *The four channels(alpha, red, green, and blue) are represented as
* numbers when you use them with the BitmapImage2D.copyChannel()
* method or the DisplacementMapFilter.componentX and
* DisplacementMapFilter.componentY properties, and these numbers
* are represented by the following constants in the BitmapImage2DChannel
* class:
BitmapImage2DChannel.ALPHABitmapImage2DChannel.REDBitmapImage2DChannel.GREENBitmapImage2DChannel.BLUEYou can attach BitmapImage2D objects to a Bitmap object by using the
* bitmapData property of the Bitmap object.
You can use a BitmapImage2D object to fill a Graphics object by using the
* Graphics.beginBitmapFill() method.
You can also use a BitmapImage2D object to perform batch tile rendering
* using the flash.display.Tilesheet class.
In Flash Player 10, the maximum size for a BitmapImage2D object * is 8,191 pixels in width or height, and the total number of pixels cannot * exceed 16,777,215 pixels.(So, if a BitmapImage2D object is 8,191 pixels wide, * it can only be 2,048 pixels high.) In Flash Player 9 and earlier, the limitation * is 2,880 pixels in height and 2,880 in width.
*/ export declare class BitmapImageCube extends ImageCube { static assetType: string; static posX: number; static negX: number; static posY: number; static negY: number; static posZ: number; static negZ: number; private _data; private _transparent; private _locked; /** * * @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 *true for the transparent 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 transparent property is true.
*/
get transparent(): boolean;
set transparent(value: boolean);
/**
* Creates a BitmapImage2D object with a specified width and height. If you
* specify a value for the fillColor parameter, every pixel in
* the bitmap is set to that color.
*
* By default, the bitmap is created as transparent, unless you pass
* the value false 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.
true
* (transparent). To create a fully transparent bitmap,
* set the value of the transparent
* parameter to true and the value of the
* fillColor parameter to 0x00000000(or to
* 0). Setting the transparent property to
* false 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(size: number, transparent?: boolean, fillColor?: number);
/**
* 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(): BitmapImageCube;
/**
* Adjusts the color values in a specified area of a bitmap image by using a
* ColorTransform 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(side: number, 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:
* *BitmapImage2DChannel.REDBitmapImage2DChannel.GREENBitmapImage2DChannel.BLUEBitmapImage2DChannel.ALPHABitmapImage2DChannel.RED,
* BitmapImage2DChannel.BLUE,
* BitmapImage2DChannel.GREEN,
* BitmapImage2DChannel.ALPHA).
* @param destChannel The destination channel. Use a value from the
* BitmapImage2DChannel class
* (BitmapImage2DChannel.RED,
* BitmapImage2DChannel.BLUE,
* BitmapImage2DChannel.GREEN,
* BitmapImage2DChannel.ALPHA).
* @throws TypeError The sourceBitmapImage2D, sourceRect or destPoint are null.
*/
copyChannel(side: number, sourceBitmap: BitmapImage2D, sourceRect: Rectangle, destPoint: Point, sourceChannel: number, destChannel: number): void;
/**
* Frees memory that is used to store the BitmapImage2D object.
*
* When the dispose() 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.
*
BitmapImage2D.dispose() releases the memory occupied by the
* actual bitmap data, immediately(a bitmap can consume up to 64 MB of
* memory). After using BitmapImage2D.dispose(), the BitmapImage2D
* object is no longer usable and an exception may be thrown if
* you call functions on the BitmapImage2D object. However,
* BitmapImage2D.dispose() 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.
source display object onto the bitmap image, using
* the NME software renderer. You can specify matrix,
* colorTransform, blendMode, and a destination
* clipRect parameter to control how the rendering performs.
* Optionally, you can specify whether the bitmap should be smoothed when
* scaled(this works only if the source object is a BitmapImage2D object).
*
* The source display object does not use any of its applied
* transformations for this call. It is treated as it exists in the library
* or file, with no matrix transform, no color transform, and no blend mode.
* To draw a display object(such as a movie clip) by using its own transform
* properties, you can copy its transform property object to the
* transform property of the Bitmap object that uses the
* BitmapImage2D object.
new Matrix() constructor, or
* pass a null value.
* @param colorTransform A ColorTransform object that you use to adjust the
* color values of the bitmap. If no object is
* supplied, the bitmap image's colors are not
* transformed. If you must pass this parameter but you
* do not want to transform the image, set this
* parameter to a ColorTransform object created with
* the default new ColorTransform()
* constructor.
* @param blendMode A string value, from the flash.display.BlendMode
* class, specifying the blend mode to be applied to
* the resulting bitmap.
* @param clipRect A Rectangle object that defines the area of the
* source object to draw. If you do not supply this
* value, no clipping occurs and the entire source
* object is drawn.
* @param smoothing A Boolean value that determines whether a BitmapImage2D
* object is smoothed when scaled or rotated, due to a
* scaling or rotation in the matrix
* parameter. The smoothing parameter only
* applies if the source parameter is a
* BitmapImage2D object. With smoothing set
* to false, the rotated or scaled
* BitmapImage2D image can appear pixelated or jagged. For
* example, the following two images use the same
* BitmapImage2D object for the source
* parameter, but the smoothing parameter
* is set to true on the left and
* false on the right:
*
* Drawing a bitmap with smoothing set
* to true takes longer than doing so with
* smoothing set to
* false.
source parameter is not a
* BitmapImage2D or DisplayObject object.
* @throws ArgumentError The source is null or not a valid IBitmapDrawable
* object.
* @throws SecurityError The source object and(in the case of a
* Sprite or MovieClip object) all of its child objects
* do not come from the same domain as the caller, or
* are not in a content that is accessible to the
* caller by having called the
* Security.allowDomain() method. This
* restriction does not apply to AIR content in the
* application security sandbox.
*/
drawBitmap(side: number, 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(side: number, rect: Rectangle, color: number): void;
/**
* Returns an integer that represents an RGB pixel value from a BitmapImage2D
* object at a specific point(x, y). The
* getPixel() 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(side: number, x: any, y: any): number; /** * Returns an ARGB color value that contains alpha channel data and RGB data. * This method is similar to thegetPixel() 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(side: number, x: any, y: any): number; /** * 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 *unlock() method before and after numerous calls to the
* setPixel() or setPixel32() 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(side: number, rect: Rectangle, inputArray: ArrayNote: To increase performance, when you use the
* setPixel() or setPixel32() method repeatedly,
* call the lock() method before you call the
* setPixel() or setPixel32() method, and then call
* the unlock() 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.
setPixel()
* method; the main difference is that the setPixel32() 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
* setPixel() or setPixel32() method repeatedly,
* call the lock() method before you call the
* setPixel() or setPixel32() method, and then call
* the unlock() 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.
ByteArray.readUnsignedInt() 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 inputByteArray A ByteArray object that consists of 32-bit
* unmultiplied pixel values to be used in the
* rectangular region.
* @throws EOFError The inputByteArray object does not include
* enough data to fill the area of the rect
* rectangle. The method fills as many pixels as possible
* before throwing the exception.
* @throws TypeError The rect or inputByteArray are null.
*/
setPixels(side: number, rect: Rectangle, input: Uint8ClampedArray): void;
/**
* 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 lock()
* method before and after numerous calls to the setPixel() or
* setPixel32() 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;
/**
*
* @returns {ImageData}
*/
get data(): Uint8ClampedArray[];
/**
*
* @param width
* @param height
* @private
*/
_setSize(size: number): void;
}
import { ITextureBase } from '../base/ITextureBase';
import { _Stage_ImageCube } from './ImageCube';
/**
*
* @class away.pool.ImageObjectBase
*/
export declare class _Stage_BitmapImageCube extends _Stage_ImageCube {
getTexture(): ITextureBase;
}
//# sourceMappingURL=BitmapImageCube.d.ts.map