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 objects implemented in PixiJS

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

Transforms

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.

Bounds

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.

calculateBounds

[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.

Alpha

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.

Renderable vs Visible

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.

Memberof

PIXI

interface IDisplayObjectExtended {
    _accessibleActive?: boolean;
    _accessibleDiv?: IAccessibleHTMLElement;
    _bounds: Bounds;
    _cacheAsBitmap: boolean;
    _cacheAsBitmapMultisample: MSAA_QUALITY;
    _cacheAsBitmapResolution: number;
    _cacheData: CacheData;
    _internalEventMode: EventMode;
    _internalInteractive: boolean;
    _localBounds: Bounds;
    _texture?: Texture<Resource>;
    _textures?: Texture<Resource>[];
    accessible?: boolean;
    accessibleChildren?: boolean;
    accessibleHint?: string;
    accessiblePointerEvents?: PointerEvents;
    accessibleTitle?: string;
    accessibleType?: string;
    alpha: number;
    cacheAsBitmap: boolean;
    cacheAsBitmapMultisample: MSAA_QUALITY;
    cacheAsBitmapResolution: number;
    children?: readonly FederatedEventTarget[];
    cullArea: Rectangle;
    cullable: boolean;
    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<DisplayObject>;
    renderId?: number;
    renderable: boolean;
    sortDirty: boolean;
    style?: Pixi.TextStyle | Partial<Pixi.TextStyle>;
    tabIndex?: number;
    transform: Transform;
    visible: boolean;
    worldAlpha: number;
    angle: number;
    get destroyed(): boolean;
    get localTransform(): Matrix;
    mask: null | Container<DisplayObject> | MaskData;
    pivot: ObservablePoint<any>;
    position: ObservablePoint<any>;
    rotation: number;
    scale: ObservablePoint<any>;
    skew: ObservablePoint<any>;
    get worldTransform(): Matrix;
    get worldVisible(): boolean;
    x: number;
    y: number;
    zIndex: number;
    _cacheAsBitmapDestroy(options?): void;
    _calculateCachedBounds(): void;
    _destroyCachedDisplayObject(): void;
    _getCachedLocalBounds(): Rectangle;
    _initCachedDisplayObject(renderer): void;
    _initCachedDisplayObjectCanvas(renderer): void;
    _renderCached(renderer): void;
    _renderCachedCanvas(renderer): void;
    addEventListener<K>(type, listener, options?): void;
    addEventListener(type, listener, options?): void;
    addListener<T>(event, fn, context?): this;
    calculateBounds(): void;
    destroy(_options?): void;
    disableTempParent(cacheParent): void;
    dispatchEvent(event): boolean;
    dispatchEvent(event): boolean;
    emit<T>(event, ...args): boolean;
    enableTempParent(): Container<DisplayObject>;
    eventNames(): (keyof DisplayObjectEvents)[];
    getBounds(skipUpdate?, rect?): Rectangle;
    getGlobalPosition(point?, skipUpdate?): Point;
    getLocalBounds(rect?): Rectangle;
    listenerCount(event): number;
    listeners<T>(event): ((...args) => void)[];
    off<T>(event, fn?, context?, once?): this;
    on<T>(event, fn, context?): this;
    once<T>(event, fn, context?): this;
    removeAllListeners(event?): this;
    removeChild(child): void;
    removeEventListener<K>(type, listener, options?): void;
    removeEventListener(type, listener, options?): void;
    removeFromParent(): void;
    removeListener<T>(event, fn?, context?, once?): this;
    render(renderer): void;
    setParent(container): Container<DisplayObject>;
    setTransform(x?, y?, scaleX?, scaleY?, rotation?, skewX?, skewY?, pivotX?, pivotY?): this;
    toGlobal<P>(position, point?, skipUpdate?): P;
    toLocal<P>(position, from?, point?, skipUpdate?): P;
    updateTransform(): void;
}

Hierarchy (view full)

Properties

Accessors

Methods

Properties

_accessibleActive?: boolean
_accessibleDiv?: IAccessibleHTMLElement
_bounds: Bounds

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

_cacheAsBitmap: boolean
_cacheAsBitmapMultisample: MSAA_QUALITY
_cacheAsBitmapResolution: number
_cacheData: CacheData
_internalEventMode: EventMode
_internalInteractive: boolean
_localBounds: Bounds

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

_texture?: Texture<Resource>
_textures?: Texture<Resource>[]
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.

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.

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.

cursor: string

The cursor preferred when the mouse pointer is hovering over.

displayObjectUpdateTransform: (() => void)

Type declaration

    • (): void
    • Returns 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'

Type declaration

    • (): boolean
    • Returns boolean

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

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

Handler for 'mousedown' event

Handler for 'mouseenter' event

Handler for 'mouseleave' event

Handler for 'mousemove' event

Handler for 'mouseout' event

Handler for 'mouseover' event

Handler for 'mouseup' event

Handler for 'mouseupoutside' event

Handler for 'pointercancel' event

Handler for 'pointerdown' event

Handler for 'pointerenter' event

Handler for 'pointerleave' event

Handler for 'pointermove' event

Handler for 'pointerout' event

Handler for 'pointerover' event

Handler for 'pointertap' event

Handler for 'pointerup' event

onpointerupoutside: null | FederatedEventHandler<FederatedPointerEvent>

Handler for 'pointerupoutside' event

Handler for 'rightclick' event

Handler for 'rightdown' event

Handler for 'rightup' event

Handler for 'rightupoutside' event

Handler for 'tap' event

Handler for 'touchcancel' event

Handler for 'touchend' event

ontouchendoutside: null | FederatedEventHandler<FederatedPointerEvent>

Handler for 'touchendoutside' event

Handler for 'touchmove' event

Handler for 'touchstart' event

Handler for 'wheel' event

The display object container that contains this display object.

renderId?: number
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.

sortDirty: boolean
style?: Pixi.TextStyle | Partial<Pixi.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

  • 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): 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

    Example

    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;

    Todo

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

  • set mask(value): void
  • Parameters

    Returns void

  • get pivot(): ObservablePoint<any>
  • 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<any>

    Since

    4.0.0

  • set pivot(value): void
  • Parameters

    Returns void

  • get position(): ObservablePoint<any>
  • The coordinate of the object relative to the local coordinates of the parent.

    Returns ObservablePoint<any>

    Since

    4.0.0

  • set position(value): 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): void
  • Parameters

    • value: number

    Returns void

  • get scale(): ObservablePoint<any>
  • The scale factors of this object along the local coordinate axes.

    The default scale is (1, 1).

    Returns ObservablePoint<any>

    Since

    4.0.0

  • set scale(value): void
  • Parameters

    Returns void

  • get skew(): ObservablePoint<any>
  • The skew factor for the object in radians.

    Returns ObservablePoint<any>

    Since

    4.0.0

  • set skew(value): 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): 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): 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

    See

    PIXI.Container#sortableChildren

  • set zIndex(value): void
  • Parameters

    • value: number

    Returns void

Methods

  • Parameters

    Returns void

  • Type Parameters

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

    Parameters

    • type: K
    • listener: ((e) => any)
    • Optional options: AddListenerOptions

    Returns void

  • Parameters

    • type: string
    • listener: EventListenerOrEventListenerObject
    • Optional options: 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

    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

  • 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<DisplayObject>

    • 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

    • Optional skipUpdate: 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.

    • Optional rect: 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.
  • Parameters

    • Optional point: Point
    • Optional skipUpdate: boolean

    Returns Point

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

    Parameters

    • Optional rect: Rectangle

      Optional rectangle to store the result of the bounds calculation.

    Returns Rectangle

    • The rectangular bounding area.
  • Return the number of listeners listening to a given event.

    Parameters

    Returns number

  • Return the listeners registered for a given event.

    Type Parameters

    Parameters

    • event: T

    Returns ((...args) => void)[]

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

    Parameters

    • Optional event: keyof DisplayObjectEvents

    Returns this

  • Type Parameters

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

    Parameters

    • type: K
    • listener: ((e) => any)
    • Optional options: RemoveListenerOptions

    Returns void

  • Parameters

    • type: string
    • listener: EventListenerOrEventListenerObject
    • Optional options: 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

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

    Parameters

    • Optional x: number

      The X position

    • Optional y: number

      The Y position

    • Optional scaleX: number

      The X scale value

    • Optional scaleY: number

      The Y scale value

    • Optional rotation: number

      The rotation

    • Optional skewX: number

      The X skew value

    • Optional skewY: number

      The Y skew value

    • Optional pivotX: number

      The X pivot value

    • Optional pivotY: 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.

    • Optional point: P

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

    • Optional skipUpdate: 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.

    • Optional from: DisplayObject

      The DisplayObject to calculate the global position from.

    • Optional point: P

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

    • Optional skipUpdate: 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

Generated using TypeDoc