gameforge - v0.1.12
    Preparing search index...

    Interface IDisplayObjectExtended

    The base class for all objects that are rendered on the screen.

    This is an abstract class and can not be used on its own; rather it should be extended.

    Display Object Description
    PIXI.Container Adds support for children to DisplayObject
    PIXI.Graphics Shape-drawing display object similar to the Canvas API
    PIXI.Sprite Draws textures (i.e. images)
    PIXI.Text Draws text using the Canvas API internally
    PIXI.BitmapText More scaleable solution for text rendering, reusing glyph textures
    PIXI.TilingSprite Draws textures/images in a tiled fashion
    PIXI.AnimatedSprite Draws an animation of multiple images
    PIXI.Mesh Provides a lower-level API for drawing meshes with custom data
    PIXI.NineSlicePlane Mesh-related
    PIXI.SimpleMesh v4-compatible mesh
    PIXI.SimplePlane Mesh-related
    PIXI.SimpleRope Mesh-related

    The [transform]PIXI.DisplayObject#transform of a display object describes the projection from its local coordinate space to its parent's local coordinate space. The following properties are derived from the transform:

    Property Description
    [pivot]PIXI.DisplayObject#pivot Invariant under rotation, scaling, and skewing. The projection of into the parent's space of the pivot is equal to position, regardless of the other three transformations. In other words, It is the center of rotation, scaling, and skewing.
    [position]PIXI.DisplayObject#position Translation. This is the position of the [pivot]PIXI.DisplayObject#pivot in the parent's local space. The default value of the pivot is the origin (0,0). If the top-left corner of your display object is (0,0) in its local space, then the position will be its top-left corner in the parent's local space.
    [scale]PIXI.DisplayObject#scale Scaling. This will stretch (or compress) the display object's projection. The scale factors are along the local coordinate axes. In other words, the display object is scaled before rotated or skewed. The center of scaling is the [pivot]PIXI.DisplayObject#pivot.
    [rotation]PIXI.DisplayObject#rotation Rotation. This will rotate the display object's projection by this angle (in radians).
    [skew]PIXI.DisplayObject#skew

    Skewing. This can be used to deform a rectangular display object into a parallelogram.

    In PixiJS, skew has a slightly different behaviour than the conventional meaning. It can be thought of the net rotation applied to the coordinate axes (separately). For example, if "skew.x" is ⍺ and "skew.y" is β, then the line x = 0 will be rotated by ⍺ (y = -x*cot⍺) and the line y = 0 will be rotated by β (y = x*tanβ). A line y = x*tanϴ (i.e. a line at angle ϴ to the x-axis in local-space) will be rotated by an angle between ⍺ and β.

    It can be observed that if skew is applied equally to both axes, then it will be equivalent to applying a rotation. Indeed, if "skew.x" = -ϴ and "skew.y" = ϴ, it will produce an equivalent of "rotation" = ϴ.

    Another quite interesting observation is that "skew.x", "skew.y", rotation are commutative operations. Indeed, because rotation is essentially a careful combination of the two.

    angle Rotation. This is an alias for [rotation]PIXI.DisplayObject#rotation, but in degrees.
    x Translation. This is an alias for position.x!
    y Translation. This is an alias for position.y!
    width Implemented in [Container]PIXI.Container. Scaling. The width property calculates scale.x by dividing the "requested" width by the local bounding box width. It is indirectly an abstraction over scale.x, and there is no concept of user-defined width.
    height Implemented in [Container]PIXI.Container. Scaling. The height property calculates scale.y by dividing the "requested" height by the local bounding box height. It is indirectly an abstraction over scale.y, and there is no concept of user-defined height.

    The bounds of a display object is defined by the minimum axis-aligned rectangle in world space that can fit around it. The abstract calculateBounds method is responsible for providing it (and it should use the worldTransform to calculate in world space).

    There are a few additional types of bounding boxes:

    Bounds Description
    World Bounds This is synonymous is the regular bounds described above. See getBounds().
    Local Bounds This the axis-aligned bounding box in the parent's local space. See getLocalBounds().
    Render Bounds The bounds, but including extra rendering effects like filter padding.
    Projected Bounds The bounds of the projected display object onto the screen. Usually equals world bounds.
    Relative Bounds The bounds of a display object when projected onto a ancestor's (or parent's) space.
    Natural Bounds The bounds of an object in its own local space (not parent's space, like in local bounds)
    Content Bounds The natural bounds when excluding all children of a Container.

    [Container]PIXI.Container already implements calculateBounds in a manner that includes children.

    But for a non-Container display object, the calculateBounds method must be overridden in order for getBounds and getLocalBounds to work. This method must write the bounds into this._bounds.

    Generally, the following technique works for most simple cases: take the list of points forming the "hull" of the object (i.e. outline of the object's shape), and then add them using PIXI.Bounds#addPointMatrix.

    calculateBounds()
    {
        const points = [...];

        for (let i = 0, j = points.length; i < j; i++)
        {
            this._bounds.addPointMatrix(this.worldTransform, points[i]);
        }
    }

    You can optimize this for a large number of points by using PIXI.Bounds#addVerticesMatrix to pass them in one array together.

    This alpha sets a display object's relative opacity w.r.t its parent. For example, if the alpha of a display object is 0.5 and its parent's alpha is 0.5, then it will be rendered with 25% opacity (assuming alpha is not applied on any ancestor further up the chain).

    The alpha with which the display object will be rendered is called the [worldAlpha]PIXI.DisplayObject#worldAlpha.

    The renderable and visible properties can be used to prevent a display object from being rendered to the screen. However, there is a subtle difference between the two. When using renderable, the transforms of the display object (and its children subtree) will continue to be calculated. When using visible, the transforms will not be calculated.

    For culling purposes, it is recommended that applications use the [cullable]PIXI.DisplayObject#cullable property.

    Otherwise, to prevent an object from rendering in the general-purpose sense - visible is the property to use. This one is also better in terms of performance.

    PIXI

    interface IDisplayObjectExtended {
        _accessibleActive?: boolean;
        _accessibleDiv?: IAccessibleHTMLElement;
        _bounds: Bounds;
        _boundsID: number;
        _boundsRect: Rectangle;
        _cacheAsBitmap: boolean;
        _cacheAsBitmapMultisample: MSAA_QUALITY;
        _cacheAsBitmapResolution: number;
        _cacheData: CacheData;
        _destroyed: boolean;
        _enabledFilters: Pixi.Filter[];
        _internalEventMode: EventMode;
        _internalInteractive: boolean;
        _lastSortedIndex: number;
        _localBounds: Bounds;
        _localBoundsRect: Rectangle;
        _mask: Container<DisplayObject> | MaskData;
        _texture?: Texture<Resource>;
        _textures?: Texture<Resource>[];
        _zIndex: number;
        accessible?: boolean;
        accessibleChildren?: boolean;
        accessibleHint?: string;
        accessiblePointerEvents?: PointerEvents;
        accessibleTitle?: string;
        accessibleType?: string;
        alpha: number;
        cacheAsBitmap: boolean;
        cacheAsBitmapMultisample: MSAA_QUALITY;
        cacheAsBitmapResolution: number;
        children?: readonly FederatedEventTarget[];
        cullable: boolean;
        cullArea: Rectangle;
        cursor: string;
        displayObjectUpdateTransform: () => void;
        eventMode: EventMode;
        filterArea: Rectangle;
        filters: null | Pixi.Filter[];
        hitArea: null | IHitArea;
        interactive: boolean;
        interactiveChildren: boolean;
        isInteractive: () => boolean;
        isMask: boolean;
        isSprite: boolean;
        name: null | string;
        onclick: null | FederatedEventHandler<FederatedPointerEvent>;
        onglobalmousemove: null | FederatedEventHandler<FederatedPointerEvent>;
        onglobalpointermove: null | FederatedEventHandler<FederatedPointerEvent>;
        onglobaltouchmove: null | FederatedEventHandler<FederatedPointerEvent>;
        onmousedown: null | FederatedEventHandler<FederatedPointerEvent>;
        onmouseenter: null | FederatedEventHandler<FederatedPointerEvent>;
        onmouseleave: null | FederatedEventHandler<FederatedPointerEvent>;
        onmousemove: null | FederatedEventHandler<FederatedPointerEvent>;
        onmouseout: null | FederatedEventHandler<FederatedPointerEvent>;
        onmouseover: null | FederatedEventHandler<FederatedPointerEvent>;
        onmouseup: null | FederatedEventHandler<FederatedPointerEvent>;
        onmouseupoutside: null | FederatedEventHandler<FederatedPointerEvent>;
        onpointercancel: null | FederatedEventHandler<FederatedPointerEvent>;
        onpointerdown: null | FederatedEventHandler<FederatedPointerEvent>;
        onpointerenter: null | FederatedEventHandler<FederatedPointerEvent>;
        onpointerleave: null | FederatedEventHandler<FederatedPointerEvent>;
        onpointermove: null | FederatedEventHandler<FederatedPointerEvent>;
        onpointerout: null | FederatedEventHandler<FederatedPointerEvent>;
        onpointerover: null | FederatedEventHandler<FederatedPointerEvent>;
        onpointertap: null | FederatedEventHandler<FederatedPointerEvent>;
        onpointerup: null | FederatedEventHandler<FederatedPointerEvent>;
        onpointerupoutside: null | FederatedEventHandler<FederatedPointerEvent>;
        onrightclick: null | FederatedEventHandler<FederatedPointerEvent>;
        onrightdown: null | FederatedEventHandler<FederatedPointerEvent>;
        onrightup: null | FederatedEventHandler<FederatedPointerEvent>;
        onrightupoutside: null | FederatedEventHandler<FederatedPointerEvent>;
        ontap: null | FederatedEventHandler<FederatedPointerEvent>;
        ontouchcancel: null | FederatedEventHandler<FederatedPointerEvent>;
        ontouchend: null | FederatedEventHandler<FederatedPointerEvent>;
        ontouchendoutside: null | FederatedEventHandler<FederatedPointerEvent>;
        ontouchmove: null | FederatedEventHandler<FederatedPointerEvent>;
        ontouchstart: null | FederatedEventHandler<FederatedPointerEvent>;
        onwheel: null | FederatedEventHandler<FederatedWheelEvent>;
        parent: Container;
        renderable: boolean;
        renderId?: number;
        sortDirty: boolean;
        style?: TextStyle | Partial<TextStyle>;
        tabIndex?: number;
        transform: Transform;
        visible: boolean;
        worldAlpha: number;
        get _tempDisplayObjectParent(): TemporaryDisplayObject;
        get angle(): number;
        set angle(value: number): void;
        get destroyed(): boolean;
        get localTransform(): Matrix;
        get mask(): null | Container<DisplayObject> | MaskData;
        set mask(value: null | Container<DisplayObject> | MaskData): void;
        get pivot(): ObservablePoint;
        set pivot(value: IPointData): void;
        get position(): ObservablePoint;
        set position(value: IPointData): void;
        get rotation(): number;
        set rotation(value: number): void;
        get scale(): ObservablePoint;
        set scale(value: IPointData): void;
        get skew(): ObservablePoint;
        set skew(value: IPointData): void;
        get worldTransform(): Matrix;
        get worldVisible(): boolean;
        get x(): number;
        set x(value: number): void;
        get y(): number;
        set y(value: number): void;
        get zIndex(): number;
        set zIndex(value: number): void;
        _cacheAsBitmapDestroy(options?: boolean | IDestroyOptions): void;
        _calculateCachedBounds(): void;
        _destroyCachedDisplayObject(): void;
        _getCachedLocalBounds(): Rectangle;
        _initCachedDisplayObject(renderer: Renderer): void;
        _initCachedDisplayObjectCanvas(renderer: IRenderer<ICanvas>): void;
        _recursivePostUpdateTransform(): void;
        _renderCached(renderer: Renderer): void;
        _renderCachedCanvas(renderer: IRenderer<ICanvas>): void;
        addEventListener<
            K extends (keyof FederatedEventMap)
            | (keyof GlobalFederatedEventMap),
        >(
            type: K,
            listener: (e: AllFederatedEventMap[K]) => any,
            options?: AddListenerOptions,
        ): void;
        addEventListener(
            type: string,
            listener: EventListenerOrEventListenerObject,
            options?: AddListenerOptions,
        ): void;
        addListener<T extends keyof DisplayObjectEvents>(
            event: T,
            fn: (
                ...args: ArgumentMap<DisplayObjectEvents>[Extract<
                    T,
                    keyof DisplayObjectEvents,
                >],
            ) => void,
            context?: any,
        ): this;
        calculateBounds(): void;
        destroy(_options?: boolean | IDestroyOptions): void;
        disableTempParent(cacheParent: Container): void;
        dispatchEvent(event: Event): boolean;
        emit<T extends keyof DisplayObjectEvents>(
            event: T,
            ...args: ArgumentMap<DisplayObjectEvents>[Extract<
                T,
                keyof DisplayObjectEvents,
            >],
        ): boolean;
        enableTempParent(): Container;
        eventNames(): (keyof DisplayObjectEvents)[];
        getBounds(skipUpdate?: boolean, rect?: Rectangle): Rectangle;
        getGlobalPosition(point?: Point, skipUpdate?: boolean): Point;
        getLocalBounds(rect?: Rectangle): Rectangle;
        listenerCount(event: keyof DisplayObjectEvents): number;
        listeners<T extends keyof DisplayObjectEvents>(
            event: T,
        ): (
            (
                ...args: ArgumentMap<DisplayObjectEvents>[Extract<
                    T,
                    keyof DisplayObjectEvents,
                >],
            ) => void
        )[];
        off<T extends keyof DisplayObjectEvents>(
            event: T,
            fn?: (
                ...args: ArgumentMap<DisplayObjectEvents>[Extract<
                    T,
                    keyof DisplayObjectEvents,
                >],
            ) => void,
            context?: any,
            once?: boolean,
        ): this;
        on<T extends keyof DisplayObjectEvents>(
            event: T,
            fn: (
                ...args: ArgumentMap<DisplayObjectEvents>[Extract<
                    T,
                    keyof DisplayObjectEvents,
                >],
            ) => void,
            context?: any,
        ): this;
        once<T extends keyof DisplayObjectEvents>(
            event: T,
            fn: (
                ...args: ArgumentMap<DisplayObjectEvents>[Extract<
                    T,
                    keyof DisplayObjectEvents,
                >],
            ) => void,
            context?: any,
        ): this;
        removeAllListeners(event?: keyof DisplayObjectEvents): this;
        removeChild(child: DisplayObject): void;
        removeEventListener<
            K extends (keyof FederatedEventMap)
            | (keyof GlobalFederatedEventMap),
        >(
            type: K,
            listener: (e: AllFederatedEventMap[K]) => any,
            options?: RemoveListenerOptions,
        ): void;
        removeEventListener(
            type: string,
            listener: EventListenerOrEventListenerObject,
            options?: RemoveListenerOptions,
        ): void;
        removeFromParent(): void;
        removeListener<T extends keyof DisplayObjectEvents>(
            event: T,
            fn?: (
                ...args: ArgumentMap<DisplayObjectEvents>[Extract<
                    T,
                    keyof DisplayObjectEvents,
                >],
            ) => void,
            context?: any,
            once?: boolean,
        ): this;
        render(renderer: Renderer): void;
        setParent(container: Container): Container;
        setTransform(
            x?: number,
            y?: number,
            scaleX?: number,
            scaleY?: number,
            rotation?: number,
            skewX?: number,
            skewY?: number,
            pivotX?: number,
            pivotY?: number,
        ): this;
        toGlobal<P extends IPointData = Point>(
            position: IPointData,
            point?: P,
            skipUpdate?: boolean,
        ): P;
        toLocal<P extends IPointData = Point>(
            position: IPointData,
            from?: DisplayObject,
            point?: P,
            skipUpdate?: boolean,
        ): P;
        updateTransform(): void;
    }

    Hierarchy (View Summary)

    Index

    Properties

    _accessibleActive? _accessibleDiv? _bounds _boundsID _boundsRect _cacheAsBitmap _cacheAsBitmapMultisample _cacheAsBitmapResolution _cacheData _destroyed _enabledFilters _internalEventMode _internalInteractive _lastSortedIndex _localBounds _localBoundsRect _mask _texture? _textures? _zIndex accessible? accessibleChildren? accessibleHint? accessiblePointerEvents? accessibleTitle? accessibleType? alpha cacheAsBitmap cacheAsBitmapMultisample cacheAsBitmapResolution children? cullable cullArea cursor displayObjectUpdateTransform eventMode filterArea filters hitArea interactive interactiveChildren isInteractive isMask isSprite name onclick onglobalmousemove onglobalpointermove onglobaltouchmove onmousedown onmouseenter onmouseleave onmousemove onmouseout onmouseover onmouseup onmouseupoutside onpointercancel onpointerdown onpointerenter onpointerleave onpointermove onpointerout onpointerover onpointertap onpointerup onpointerupoutside onrightclick onrightdown onrightup onrightupoutside ontap ontouchcancel ontouchend ontouchendoutside ontouchmove ontouchstart onwheel parent renderable renderId? sortDirty style? tabIndex? transform visible worldAlpha

    Accessors

    _tempDisplayObjectParent angle destroyed localTransform mask pivot position rotation scale skew worldTransform worldVisible x y zIndex

    Methods

    _cacheAsBitmapDestroy _calculateCachedBounds _destroyCachedDisplayObject _getCachedLocalBounds _initCachedDisplayObject _initCachedDisplayObjectCanvas _recursivePostUpdateTransform _renderCached _renderCachedCanvas addEventListener addListener calculateBounds destroy disableTempParent dispatchEvent emit enableTempParent eventNames getBounds getGlobalPosition getLocalBounds listenerCount listeners off on once removeAllListeners removeChild removeEventListener removeFromParent removeListener render setParent setTransform toGlobal toLocal updateTransform

    Properties

    Optional_accessibleActive

    _accessibleActive?: boolean

    Optional_accessibleDiv

    _accessibleDiv?: IAccessibleHTMLElement

    _bounds

    _bounds: Bounds

    The bounds object, this is used to calculate and store the bounds of the displayObject.

    Protected_boundsID

    _boundsID: number

    Flags the cached bounds as dirty.

    Protected_boundsRect

    _boundsRect: Rectangle

    Cache of this display-object's bounds-rectangle.

    _cacheAsBitmap

    _cacheAsBitmap: boolean

    _cacheAsBitmapMultisample

    _cacheAsBitmapMultisample: MSAA_QUALITY

    _cacheAsBitmapResolution

    _cacheAsBitmapResolution: number

    _cacheData

    _cacheData: CacheData

    Protected_destroyed

    _destroyed: boolean

    If the object has been destroyed via destroy(). If true, it should not be used.

    Protected_enabledFilters

    _enabledFilters: Pixi.Filter[]

    Currently enabled filters.

    _internalEventMode

    _internalEventMode: EventMode

    _internalInteractive

    _internalInteractive: boolean

    Protected_lastSortedIndex

    _lastSortedIndex: number

    Which index in the children array the display component was before the previous zIndex sort. Used by containers to help sort objects with the same zIndex, by using previous array index as the decider.

    _localBounds

    _localBounds: Bounds

    Local bounds object, swapped with _bounds when using getLocalBounds().

    Protected_localBoundsRect

    _localBoundsRect: Rectangle

    Cache of this display-object's local-bounds rectangle.

    Protected_mask

    _mask: Container<DisplayObject> | MaskData

    The original, cached mask of the object.

    Optional_texture

    _texture?: Texture<Resource>

    Optional_textures

    _textures?: Texture<Resource>[]

    Protected_zIndex

    _zIndex: number

    The zIndex of the displayObject. A higher value will mean it will be rendered on top of other displayObjects within the same container.

    accessible?: boolean
    accessibleChildren?: boolean
    accessibleHint?: string
    accessiblePointerEvents?: PointerEvents
    accessibleTitle?: string
    accessibleType?: string
    alpha: number

    The opacity of the object.

    cacheAsBitmap: boolean
    cacheAsBitmapMultisample: MSAA_QUALITY
    cacheAsBitmapResolution: number
    children?: readonly FederatedEventTarget[]

    The children of this event target.

    cullable: boolean

    Should this object be rendered if the bounds of this object are out of frame?

    Culling has no effect on whether updateTransform is called.

    cullArea: Rectangle

    If set, this shape is used for culling instead of the bounds of this object. It can improve the culling performance of objects with many children. The culling area is defined in local space.

    cursor: string

    The cursor preferred when the mouse pointer is hovering over.

    displayObjectUpdateTransform: () => void
    eventMode: EventMode

    The mode of interaction for this object

    filterArea: Rectangle

    The area the filter is applied to. This is used as more of an optimization rather than figuring out the dimensions of the displayObject each frame you can set this rectangle.

    Also works as an interaction mask.

    filters: null | Pixi.Filter[]

    Sets the filters for the displayObject. IMPORTANT: This is a WebGL only feature and will be ignored by the canvas renderer. To remove filters simply set this property to 'null'.

    hitArea: null | IHitArea

    The hit-area specifies the area for which pointer events should be captured by this event target.

    interactive: boolean

    Whether this event target should fire UI events.

    interactiveChildren: boolean

    Whether this event target has any children that need UI events. This can be used optimize event propagation.

    isInteractive: () => boolean

    Returns true if the DisplayObject has interactive 'static' or 'dynamic'

    isMask: boolean

    Does any other displayObject use this object as a mask?

    isSprite: boolean

    Used to fast check if a sprite is.. a sprite!

    name: null | string
    onclick: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'click' event

    onglobalmousemove: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'globalmousemove' event

    onglobalpointermove: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'globalpointermove' event

    onglobaltouchmove: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'globaltouchmove' event

    onmousedown: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'mousedown' event

    onmouseenter: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'mouseenter' event

    onmouseleave: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'mouseleave' event

    onmousemove: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'mousemove' event

    onmouseout: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'mouseout' event

    onmouseover: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'mouseover' event

    onmouseup: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'mouseup' event

    onmouseupoutside: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'mouseupoutside' event

    onpointercancel: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'pointercancel' event

    onpointerdown: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'pointerdown' event

    onpointerenter: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'pointerenter' event

    onpointerleave: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'pointerleave' event

    onpointermove: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'pointermove' event

    onpointerout: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'pointerout' event

    onpointerover: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'pointerover' event

    onpointertap: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'pointertap' event

    onpointerup: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'pointerup' event

    onpointerupoutside: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'pointerupoutside' event

    onrightclick: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'rightclick' event

    onrightdown: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'rightdown' event

    onrightup: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'rightup' event

    onrightupoutside: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'rightupoutside' event

    ontap: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'tap' event

    ontouchcancel: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'touchcancel' event

    ontouchend: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'touchend' event

    ontouchendoutside: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'touchendoutside' event

    ontouchmove: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'touchmove' event

    ontouchstart: null | FederatedEventHandler<FederatedPointerEvent>

    Handler for 'touchstart' event

    onwheel: null | FederatedEventHandler<FederatedWheelEvent>

    Handler for 'wheel' event

    parent: Container

    The display object container that contains this display object.

    renderable: boolean

    Can this object be rendered, if false the object will not be drawn but the updateTransform methods will still be called.

    Only affects recursive calls from parent. You can ask for bounds manually.

    renderId?: number
    sortDirty: boolean
    style?: TextStyle | Partial<TextStyle>
    tabIndex?: number
    transform: Transform

    World transform and local transform of this object. This will become read-only later, please do not assign anything there unless you know what are you doing.

    visible: boolean

    The visibility of the object. If false the object will not be drawn, and the updateTransform function will not be called.

    Only affects recursive calls from parent. You can ask for bounds or call updateTransform manually.

    worldAlpha: number

    The multiplied alpha of the displayObject.

    Accessors

    _tempDisplayObjectParent

    • get _tempDisplayObjectParent(): TemporaryDisplayObject
      Protected

      Returns TemporaryDisplayObject

    • get angle(): number

      The angle of the object in degrees. 'rotation' and 'angle' have the same effect on a display object; rotation is in radians, angle is in degrees.

      Returns number

    • set angle(value: number): void

      Parameters

      • value: number

      Returns void

    • get destroyed(): boolean

      Readonly flag for destroyed display objects.

      Returns boolean

    • get localTransform(): Matrix

      Current transform of the object based on local factors: position, scale, other stuff.

      Returns Matrix

    • get mask(): null | Container<DisplayObject> | MaskData

      Sets a mask for the displayObject. A mask is an object that limits the visibility of an object to the shape of the mask applied to it. In PixiJS a regular mask must be a PIXI.Graphics or a PIXI.Sprite object. This allows for much faster masking in canvas as it utilities shape clipping. Furthermore, a mask of an object must be in the subtree of its parent. Otherwise, getLocalBounds may calculate incorrect bounds, which makes the container's width and height wrong. To remove a mask, set this property to null.

      For sprite mask both alpha and red channel are used. Black mask is the same as transparent mask.

      Returns null | Container<DisplayObject> | MaskData

      import { Graphics, Sprite } from 'pixi.js';

      const graphics = new Graphics();
      graphics.beginFill(0xFF3300);
      graphics.drawRect(50, 250, 100, 100);
      graphics.endFill();

      const sprite = new Sprite(texture);
      sprite.mask = graphics;

      At the moment, CanvasRenderer doesn't support Sprite as mask.

    • set mask(value: null | Container<DisplayObject> | MaskData): void

      Parameters

      Returns void

    • get pivot(): ObservablePoint

      The center of rotation, scaling, and skewing for this display object in its local space. The position is the projection of pivot in the parent's local space.

      By default, the pivot is the origin (0, 0).

      Returns ObservablePoint

      4.0.0

    • set pivot(value: IPointData): void

      Parameters

      Returns void

    • get position(): ObservablePoint

      The coordinate of the object relative to the local coordinates of the parent.

      Returns ObservablePoint

      4.0.0

    • set position(value: IPointData): void

      Parameters

      Returns void

    • get rotation(): number

      The rotation of the object in radians. 'rotation' and 'angle' have the same effect on a display object; rotation is in radians, angle is in degrees.

      Returns number

    • set rotation(value: number): void

      Parameters

      • value: number

      Returns void

    • get scale(): ObservablePoint

      The scale factors of this object along the local coordinate axes.

      The default scale is (1, 1).

      Returns ObservablePoint

      4.0.0

    • set scale(value: IPointData): void

      Parameters

      Returns void

    • get skew(): ObservablePoint

      The skew factor for the object in radians.

      Returns ObservablePoint

      4.0.0

    • set skew(value: IPointData): void

      Parameters

      Returns void

    • get worldTransform(): Matrix

      Current transform of the object based on world (parent) factors.

      Returns Matrix

    • get worldVisible(): boolean

      Indicates if the object is globally visible.

      Returns boolean

    • get x(): number

      The position of the displayObject on the x axis relative to the local coordinates of the parent. An alias to position.x

      Returns number

    • set x(value: number): void

      Parameters

      • value: number

      Returns void

    • get y(): number

      The position of the displayObject on the y axis relative to the local coordinates of the parent. An alias to position.y

      Returns number

    • set y(value: number): void

      Parameters

      • value: number

      Returns void

    • get zIndex(): number

      The zIndex of the displayObject.

      If a container has the sortableChildren property set to true, children will be automatically sorted by zIndex value; a higher value will mean it will be moved towards the end of the array, and thus rendered on top of other display objects within the same container.

      Returns number

      PIXI.Container#sortableChildren

    • set zIndex(value: number): void

      Parameters

      • value: number

      Returns void

    Methods

    _cacheAsBitmapDestroy

    _calculateCachedBounds

    _destroyCachedDisplayObject

    _getCachedLocalBounds

    _initCachedDisplayObject

    _initCachedDisplayObjectCanvas

    Protected_recursivePostUpdateTransform

    • _recursivePostUpdateTransform(): void

      Recursively updates transform of all objects from the root to this one internal function for toLocal()

      Returns void

    _renderCached

    _renderCachedCanvas

    • Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.

      The options argument sets listener-specific options. For compatibility this can be a boolean, in which case the method behaves exactly as if the value was specified as options's capture.

      When set to true, options's capture prevents callback from being invoked when the event's eventPhase attribute value is BUBBLING_PHASE. When false (or not present), callback will not be invoked when event's eventPhase attribute value is CAPTURING_PHASE. Either way, callback will be invoked if event's eventPhase attribute value is AT_TARGET.

      When set to true, options's passive indicates that the callback will not cancel the event by invoking preventDefault(). This is used to enable performance optimizations described in § 2.8 Observing event listeners.

      When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.

      If an AbortSignal is passed for options's signal, then the event listener will be removed when signal is aborted.

      The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.

      MDN Reference

      Type Parameters

      • K extends (keyof FederatedEventMap) | (keyof GlobalFederatedEventMap)

      Parameters

      Returns void

    • Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.

      The options argument sets listener-specific options. For compatibility this can be a boolean, in which case the method behaves exactly as if the value was specified as options's capture.

      When set to true, options's capture prevents callback from being invoked when the event's eventPhase attribute value is BUBBLING_PHASE. When false (or not present), callback will not be invoked when event's eventPhase attribute value is CAPTURING_PHASE. Either way, callback will be invoked if event's eventPhase attribute value is AT_TARGET.

      When set to true, options's passive indicates that the callback will not cancel the event by invoking preventDefault(). This is used to enable performance optimizations described in § 2.8 Observing event listeners.

      When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.

      If an AbortSignal is passed for options's signal, then the event listener will be removed when signal is aborted.

      The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.

      MDN Reference

      Parameters

      • type: string
      • listener: EventListenerOrEventListenerObject
      • Optionaloptions: AddListenerOptions

      Returns void

    • Recalculates the bounds of the display object.

      Returns void

    • Base destroy method for generic display objects. This will automatically remove the display object from its parent Container as well as remove all current event listeners and internal references. Do not use a DisplayObject after calling destroy().

      Parameters

      Returns void

    • Pair method for enableTempParent

      Parameters

      • cacheParent: Container

        Actual parent of element

      Returns void

    • Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.

      MDN Reference

      Parameters

      • event: Event

      Returns boolean

    • Used in Renderer, cacheAsBitmap and other places where you call an updateTransform on root.

      const cacheParent = elem.enableTempParent();
      elem.updateTransform();
      elem.disableTempParent(cacheParent);

      Returns Container

      • Current parent

    • Calculates and returns the (world) bounds of the display object as a [Rectangle]PIXI.Rectangle.

      This method is expensive on containers with a large subtree (like the stage). This is because the bounds of a container depend on its children's bounds, which recursively causes all bounds in the subtree to be recalculated. The upside, however, is that calling getBounds once on a container will indeed update the bounds of all children (the whole subtree, in fact). This side effect should be exploited by using displayObject._bounds.getRectangle() when traversing through all the bounds in a scene graph. Otherwise, calling getBounds on each object in a subtree will cause the total cost to increase quadratically as its height increases.

      The transforms of all objects in a container's subtree and of all ancestors are updated. The world bounds of all display objects in a container's subtree will also be recalculated.

      The _bounds object stores the last calculation of the bounds. You can use to entirely skip bounds calculation if needed.

      const lastCalculatedBounds = displayObject._bounds.getRectangle(optionalRect);

      Do know that usage of getLocalBounds can corrupt the _bounds of children (the whole subtree, actually). This is a known issue that has not been solved. See [getLocalBounds]PIXI.DisplayObject#getLocalBounds for more details.

      getBounds should be called with skipUpdate equal to true in a render() call. This is because the transforms are guaranteed to be update-to-date. In fact, recalculating inside a render() call may cause corruption in certain cases.

      Parameters

      • OptionalskipUpdate: boolean

        Setting to true will stop the transforms of the scene graph from being updated. This means the calculation returned MAY be out of date BUT will give you a nice performance boost.

      • Optionalrect: Rectangle

        Optional rectangle to store the result of the bounds calculation.

      Returns Rectangle

      • The minimum axis-aligned rectangle in world space that fits around this object.

    • Retrieves the local bounds of the displayObject as a rectangle object.

      Parameters

      • Optionalrect: Rectangle

        Optional rectangle to store the result of the bounds calculation.

      Returns Rectangle

      • The rectangular bounding area.

    • Remove all listeners, or those of the specified event.

      Parameters

      • Optionalevent: keyof DisplayObjectEvents

      Returns this

    • Removes the event listener in target's event listener list with the same type, callback, and options.

      MDN Reference

      Type Parameters

      • K extends (keyof FederatedEventMap) | (keyof GlobalFederatedEventMap)

      Parameters

      Returns void

    • Removes the event listener in target's event listener list with the same type, callback, and options.

      MDN Reference

      Parameters

      • type: string
      • listener: EventListenerOrEventListenerObject
      • Optionaloptions: RemoveListenerOptions

      Returns void

    • Remove the DisplayObject from its parent Container. If the DisplayObject has no parent, do nothing.

      Returns void

    • Renders the object using the WebGL renderer.

      Parameters

      Returns void

    • Set the parent Container of this DisplayObject.

      Parameters

      • container: Container

        The Container to add this DisplayObject to.

      Returns Container

      • The Container that this DisplayObject was added to.

    • Convenience function to set the position, scale, skew and pivot at once.

      Parameters

      • Optionalx: number

        The X position

      • Optionaly: number

        The Y position

      • OptionalscaleX: number

        The X scale value

      • OptionalscaleY: number

        The Y scale value

      • Optionalrotation: number

        The rotation

      • OptionalskewX: number

        The X skew value

      • OptionalskewY: number

        The Y skew value

      • OptionalpivotX: number

        The X pivot value

      • OptionalpivotY: number

        The Y pivot value

      Returns this

      • The DisplayObject instance

    • Calculates the global position of the display object.

      Type Parameters

      Parameters

      • position: IPointData

        The world origin to calculate from.

      • Optionalpoint: P

        A Point object in which to store the value, optional (otherwise will create a new Point).

      • OptionalskipUpdate: boolean

        Should we skip the update transform.

      Returns P

      • A point object representing the position of this object.

    • Calculates the local position of the display object relative to another point.

      Type Parameters

      Parameters

      • position: IPointData

        The world origin to calculate from.

      • Optionalfrom: DisplayObject

        The DisplayObject to calculate the global position from.

      • Optionalpoint: P

        A Point object in which to store the value, optional (otherwise will create a new Point).

      • OptionalskipUpdate: boolean

        Should we skip the update transform

      Returns P

      • A point object representing the position of this object

    • Updates the object transform for rendering. TODO - Optimization pass!

      Returns void

    Settings

    Member Visibility

    On This Page

    Display objects implemented in PixiJSTransformsBoundsAlphaRenderable vs Visible
    Properties
    _accessibleActive_accessibleDiv_bounds_boundsID_boundsRect_cacheAsBitmap_cacheAsBitmapMultisample_cacheAsBitmapResolution_cacheData_destroyed_enabledFilters_internalEventMode_internalInteractive_lastSortedIndex_localBounds_localBoundsRect_mask_texture_textures_zIndexaccessibleaccessibleChildrenaccessibleHintaccessiblePointerEventsaccessibleTitleaccessibleTypealphacacheAsBitmapcacheAsBitmapMultisamplecacheAsBitmapResolutionchildrencullablecullAreacursordisplayObjectUpdateTransformeventModefilterAreafiltershitAreainteractiveinteractiveChildrenisInteractiveisMaskisSpritenameonclickonglobalmousemoveonglobalpointermoveonglobaltouchmoveonmousedownonmouseenteronmouseleaveonmousemoveonmouseoutonmouseoveronmouseuponmouseupoutsideonpointercancelonpointerdownonpointerenteronpointerleaveonpointermoveonpointeroutonpointeroveronpointertaponpointeruponpointerupoutsideonrightclickonrightdownonrightuponrightupoutsideontapontouchcancelontouchendontouchendoutsideontouchmoveontouchstartonwheelparentrenderablerenderIdsortDirtystyletabIndextransformvisibleworldAlpha
    Accessors
    Methods