starling-framework

import Painter from "../rendering/Painter"; import FragmentFilter from "../filters/FragmentFilter"; import EventDispatcher from "../events/EventDispatcher"; import Event from "../events/Event"; import Stage from "./Stage"; import DisplayObjectContainer from "./DisplayObjectContainer"; import Vector3D from "openfl/geom/Vector3D"; import Rectangle from "openfl/geom/Rectangle"; import Point from "openfl/geom/Point"; import Matrix3D from "openfl/geom/Matrix3D"; import Matrix from "openfl/geom/Matrix"; import BitmapData from "openfl/display/BitmapData"; declare namespace starling.display { /** * Dispatched when an object is added to a parent. */ export class DisplayObject extends EventDispatcher { /** * @private */ protected constructor(); /** * Disposes all resources of the display object. * * GPU buffers are released, event listeners are removed, filters and masks are disposed. */ dispose(): void; /** * Removes the object from its parent, if it has one, and optionally disposes it. */ removeFromParent(dispose?: boolean): void; /** * Creates a matrix that represents the transformation from the local coordinate system * * to another. If you pass an <code>out</code>-matrix, the result will be stored in this matrix * * instead of creating a new object. */ getTransformationMatrix(targetSpace: DisplayObject, out?: Matrix): Matrix; /** * Returns a rectangle that completely encloses the object as it appears in another * * coordinate system. If you pass an <code>out</code>-rectangle, the result will be stored in this * * rectangle instead of creating a new object. */ getBounds(targetSpace: DisplayObject, out?: Rectangle): Rectangle; /** * Returns the object that is found topmost beneath a point in local coordinates, or nil * * if the test fails. Untouchable and invisible objects will cause the test to fail. */ hitTest(localPoint: Point): DisplayObject; /** * Checks if a certain point is inside the display object's mask. If there is no mask, * * this method always returns <code>true</code> (because having no mask is equivalent * * to having one that's infinitely big). */ hitTestMask(localPoint: Point): boolean; /** * Transforms a point from the local coordinate system to global (stage) coordinates. * * If you pass an <code>out</code>-point, the result will be stored in this point instead of * * creating a new object. */ localToGlobal(localPoint: Point, out?: Point): Point; /** * Transforms a point from global (stage) coordinates to the local coordinate system. * * If you pass an <code>out</code>-point, the result will be stored in this point instead of * * creating a new object. */ globalToLocal(globalPoint: Point, out?: Point): Point; /** * Renders the display object with the help of a painter object. Never call this method * * directly, except from within another render method. * * * * @param painter Captures the current render state and provides utility functions * * for rendering. * */ render(painter: Painter): void; /** * Moves the pivot point to a certain position within the local coordinate system * * of the object. If you pass no arguments, it will be centered. */ alignPivot(horizontalAlign?: string, verticalAlign?: string): void; /** * Draws the object into a BitmapData object. * * * * This is achieved by drawing the object into the back buffer and then copying the * * pixels of the back buffer into a texture. Beware: image sizes bigger than the back * * buffer are only supported in AIR version 25 or higher and NOT in Flash Player. * * * * @param out If you pass null, the object will be created for you. * * If you pass a BitmapData object, it should have the size of the * * object bounds, multiplied by the current contentScaleFactor. * * @param color The RGB color value with which the bitmap will be initialized. * * @param alpha The alpha value with which the bitmap will be initialized. * */ drawToBitmapData(out?: BitmapData, color?: number, alpha?: number): BitmapData; /** * Creates a matrix that represents the transformation from the local coordinate system * * to another. This method supports three dimensional objects created via 'Sprite3D'. * * If you pass an <code>out</code>-matrix, the result will be stored in this matrix * * instead of creating a new object. */ getTransformationMatrix3D(targetSpace: DisplayObject, out?: Matrix3D): Matrix3D; /** * Transforms a 3D point from the local coordinate system to global (stage) coordinates. * * This is achieved by projecting the 3D point onto the (2D) view plane. * * * * If you pass an <code>out</code>-point, the result will be stored in this point instead of * * creating a new object. */ local3DToGlobal(localPoint: Vector3D, out?: Point): Point; /** * Transforms a point from global (stage) coordinates to the 3D local coordinate system. * * If you pass an <code>out</code>-vector, the result will be stored in this point instead of * * creating a new object. */ globalToLocal3D(globalPoint: Point, out?: Vector3D): Vector3D; /** * Forces the object to be redrawn in the next frame. * * This will prevent the object to be drawn from the render cache. * * * * This method is called every time the object changes in any way. When creating * * custom mesh styles or any other custom rendering code, call this method if the object * * needs to be redrawn. * * * * If the object needs to be redrawn just because it does not support the render cache, * * call <code>painter.excludeFromCache()</code> in the object's render method instead. * * That way, Starling's <code>skipUnchangedFrames</code> policy won't be disrupted. * */ setRequiresRedraw(): void; /** * Indicates if the object needs to be redrawn in the upcoming frame, i.e. if it has * * changed its location relative to the stage or some other aspect of its appearance * * since it was last rendered. */ get requiresRedraw(): boolean; /** * @private */ override dispatchEvent(event: Event): void; /** * @inheritDoc */ override addEventListener(type: string, listener: Function): void; /** * @inheritDoc */ override removeEventListener(type: string, listener: Function): void; /** * @inheritDoc */ override removeEventListeners(type?: string): void; /** * The transformation matrix of the object relative to its parent. * * * * If you assign a custom transformation matrix, Starling will try to figure out * * suitable values for <code>x, y, scaleX, scaleY,</code> and <code>rotation</code>. * * However, if the matrix was created in a different way, this might not be possible. * * In that case, Starling will apply the matrix, but not update the corresponding * * properties. * * * * CAUTION: not a copy, but the actual object! */ get transformationMatrix(): Matrix; set transformationMatrix(value: Matrix) /** * The 3D transformation matrix of the object relative to its parent. * * * * For 2D objects, this property returns just a 3D version of the 2D transformation * * matrix. Only the 'Sprite3D' class supports real 3D transformations. * * * * CAUTION: not a copy, but the actual object! */ get transformationMatrix3D(): Matrix3D; /** * Indicates if this object or any of its parents is a 'Sprite3D' object. */ get is3D(): boolean; /** * Indicates if the mouse cursor should transform into a hand while it's over the sprite. * * @default false */ get useHandCursor(): boolean; set useHandCursor(value: boolean) /** * The bounds of the object relative to the local coordinates of the parent. */ get bounds(): Rectangle; /** * The width of the object in pixels. * * Note that for objects in a 3D space (connected to a Sprite3D), this value might not * * be accurate until the object is part of the display list. */ get width(): number; set width(value: number) /** * The height of the object in pixels. * * Note that for objects in a 3D space (connected to a Sprite3D), this value might not * * be accurate until the object is part of the display list. */ get height(): number; set height(value: number) /** * The x coordinate of the object relative to the local coordinates of the parent. */ get x(): number; set x(value: number) /** * The y coordinate of the object relative to the local coordinates of the parent. */ get y(): number; set y(value: number) /** * The x coordinate of the object's origin in its own coordinate space (default: 0). */ get pivotX(): number; set pivotX(value: number) /** * The y coordinate of the object's origin in its own coordinate space (default: 0). */ get pivotY(): number; set pivotY(value: number) /** * The horizontal scale factor. '1' means no scale, negative values flip the object. * * @default 1 */ get scaleX(): number; set scaleX(value: number) /** * The vertical scale factor. '1' means no scale, negative values flip the object. * * @default 1 */ get scaleY(): number; set scaleY(value: number) /** * Sets both 'scaleX' and 'scaleY' to the same value. The getter simply returns the * * value of 'scaleX' (even if the scaling values are different). @default 1 */ get scale(): number; set scale(value: number) /** * The horizontal skew angle in radians. */ get skewX(): number; set skewX(value: number) /** * The vertical skew angle in radians. */ get skewY(): number; set skewY(value: number) /** * The rotation of the object in radians. (In Starling, all angles are measured * * in radians.) */ get rotation(): number; set rotation(value: number) /** * The opacity of the object. 0 = transparent, 1 = opaque. @default 1 */ get alpha(): number; set alpha(value: number) /** * The visibility of the object. An invisible object will be untouchable. */ get visible(): boolean; set visible(value: boolean) /** * Indicates if this object (and its children) will receive touch events. */ get touchable(): boolean; set touchable(value: boolean) /** * The blend mode determines how the object is blended with the objects underneath. * * @default auto * * @see starling.display.BlendMode */ get blendMode(): string; set blendMode(value: string) /** * The name of the display object (default: null). Used by 'getChildByName()' of * * display object containers. */ get name(): string; set name(value: string) /** * The filter that is attached to the display object. The <code>starling.filters</code> * * package contains several classes that define specific filters you can use. To combine * * several filters, assign an instance of the <code>FilterChain</code> class; to remove * * all filters, assign <code>null</code>. * * * * Beware that a filter instance may only be used on one object at a time! Furthermore, * * when you remove or replace a filter, it is NOT disposed automatically (since you might * * want to reuse it on a different object). * * * * @default null * * @see starling.filters.FragmentFilter * * @see starling.filters.FilterChain * */ get filter(): FragmentFilter; set filter(value: FragmentFilter) /** * The display object that acts as a mask for the current object. * * Assign <code>null</code> to remove it. * * * * A pixel of the masked display object will only be drawn if it is within one of the * * mask's polygons. Texture pixels and alpha values of the mask are not taken into * * account. The mask object itself is never visible. * * * * If the mask is part of the display list, masking will occur at exactly the * * location it occupies on the stage. If it is not, the mask will be placed in the local * * coordinate system of the target object (as if it was one of its children). * * * * For rectangular masks, you can use simple quads; for other forms (like circles * * or arbitrary shapes) it is recommended to use a 'Canvas' instance. * * * * Note: a mask will typically cause at least two additional draw * * calls: one to draw the mask to the stencil buffer and one to erase it. However, if the * * mask object is an instance of <code>starling.display.Quad</code> and is aligned * * parallel to the stage axes, rendering will be optimized: instead of using the * * stencil buffer, the object will be clipped using the scissor rectangle. That's * * faster and reduces the number of draw calls, so make use of this when possible. * * * * Note: AIR apps require the <code>depthAndStencil</code> node * * in the application descriptor XMLs to be enabled! Otherwise, stencil masking won't * * work. * * * * @see Canvas * * @default null * */ get mask(): DisplayObject; set mask(value: DisplayObject) /** * Indicates if the masked region of this object is set to be inverted. */ get maskInverted(): boolean; set maskInverted(value: boolean) /** * The display object container that contains this display object. */ get parent(): DisplayObjectContainer; /** * The topmost object in the display tree the object is part of. */ get base(): DisplayObject; /** * The root object the display object is connected to (i.e. an instance of the class * * that was passed to the Starling constructor), or null if the object is not connected * * to the stage. */ get root(): DisplayObject; /** * The stage the display object is connected to, or null if it is not connected * * to the stage. */ get stage(): Stage; } } export default starling.display.DisplayObject;