Optional options: Live2DModelOptionsProtected _autoThe bounds object, this is used to calculate and store the bounds of the displayObject.
Protected _boundsIDFlags the cached bounds as dirty.
Protected _boundsCache of this display-object's bounds-rectangle.
Protected _destroyedIf the object has been destroyed via destroy(). If true, it should not be used.
Protected _enabledCurrently enabled filters.
Protected _heightProtected _lastWhich 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.
Local bounds object, swapped with _bounds when using getLocalBounds().
Protected _localCache of this display-object's local-bounds rectangle.
Protected _maskThe original, cached mask of the object.
Protected _widthProtected _zThe zIndex of the displayObject. A higher value will mean it will be rendered on top of other displayObjects within the same container.
The opacity of the object.
The anchor behaves like the one in PIXI.Sprite, where (0, 0) means the top left
and (1, 1) means the bottom right.
Readonly childrenThe array of children of this container.
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.
Should this object be rendered if the bounds of this object are out of frame?
Culling has no effect on whether updateTransform is called.
Elapsed time in milliseconds from last frame to this frame.
Elapsed time in milliseconds since created.
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.
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'.
Protected glAn ID of Gl context that syncs with renderer.CONTEXT_UID. Used to check if the GL context has changed.
Optional interactionLocal reference used to clean up the event listeners when destroying the model.
The internal model. Though typed as non-nullable, it'll be undefined until the "ready" event is emitted.
Does any other displayObject use this object as a mask?
Used to fast check if a sprite is.. a sprite!
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.
Should children be sorted by zIndex at the next updateTransform call.
Will get automatically set to true if a new child is added, or if a child's zIndex changes.
If set to true, the container will sort its children by zIndex value when updateTransform() is called, or manually if sortChildren() is called.
This actually changes the order of elements in the array, so should be treated as a basic solution that is not performant compared to other solutions, such as
https://github.com/pixijs/pixi-display
Also be aware of that this may not work nicely with the addChildAt() function, as the zIndex sorting may cause the child to automatically sorted to another position.
PIXI.settings.SORTABLE_CHILDREN
Tag for logging.
Pixi textures.
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.
Readonly worldThe multiplied alpha of the displayObject.
Static prefixedProtected
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.
Enables automatic interaction. Only takes effect if Pixi's interaction
feature has been enabled (by registering the PIXI.InteractionManager into PIXI.Renderer).
Enables automatic updating. Requires registerTicker or the global window.PIXI.Ticker.
Readonly flag for destroyed display objects.
The height of the Container, setting this will actually modify the scale to achieve the value set.
Current transform of the object based on local factors: position, scale, other stuff.
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.
const graphics = new PIXI.Graphics();
graphics.beginFill(0xFF3300);
graphics.drawRect(50, 250, 100, 100);
graphics.endFill();
const sprite = new PIXI.Sprite(texture);
sprite.mask = graphics;
At the moment, PIXI.CanvasRenderer doesn't support PIXI.Sprite as mask.
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).
4.0.0
The coordinate of the object relative to the local coordinates of the parent.
4.0.0
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.
The scale factors of this object along the local coordinate axes.
The default scale is (1, 1).
4.0.0
The skew factor for the object in radians.
4.0.0
The width of the Container, setting this will actually modify the scale to achieve the value set.
Current transform of the object based on world (parent) factors.
Indicates if the object is globally visible.
The position of the displayObject on the x axis relative to the local coordinates of the parent. An alias to position.x
The position of the displayObject on the y axis relative to the local coordinates of the parent. An alias to position.y
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.
PIXI.Container#sortableChildren
Protected _calculateProtected _recursiveProtected _renderAdds one or more children to the container.
Multiple items can be added like so: myContainer.addChild(thingOne, thingTwo, thingThree)
Rest ...children: TThe DisplayObject(s) to add to the container
Adds a child to the container at a specified index. If the index is out of bounds an error will be thrown
The child that was added.
The child to add
The index to place the child in
Optional context: anyDestroys the model and all related resources. This takes the same options and also
behaves the same as PIXI.Container#destroy.
Optional options: { baseTexture?: boolean; children?: boolean; texture?: boolean }Options parameter. A boolean will act as if all options have been set to that value
Optional baseOnly used for child Sprites if options.children is set to true Should it destroy the base texture of the child sprite
Optional children?: booleanif set to true, all the children will have their destroy method called as well. 'options' will be passed on to those calls.
Optional texture?: booleanOnly used for child Sprites if options.children is set to true Should it destroy the texture of the child sprite
Shorthand to set an expression.
Promise that resolves with true if succeeded, with false otherwise.
Optional id: string | numberEither the index, or the name of the expression. If not presented, a random expression will be set.
Updates the focus position. This will not cause the model to immediately look at the position, instead the movement will be interpolated.
Position in world space.
Position in world space.
Should the focus position be instantly applied.
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.
Optional skipUpdate: booleanSetting 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: RectangleOptional rectangle to store the result of the bounds calculation.
Retrieves the local bounds of the displayObject as a rectangle object.
Calling getLocalBounds may invalidate the _bounds of the whole subtree below. If using it inside a render()
call, it is advised to call getBounds() immediately after to recalculate the world bounds of the subtree.
Optional rect: RectangleOptional rectangle to store the result of the bounds calculation.
Optional skipChildrenUpdate: booleanSetting to true will stop re-calculation of children transforms,
it was default behaviour of pixi 4.0-5.2 and caused many problems to users.
Protected initA handler of the "modelLoaded" event, invoked when the internal model has been loaded.
Optional options: Live2DModelOptionsShorthand to start a motion.
Promise that resolves with true if the motion is successfully started, with false otherwise.
The motion group.
Optional index: numberThe index in this group. If not presented, a random motion will be started.
Optional priority: MotionPriorityThe motion priority. Defaults to MotionPriority.NORMAL.
Optional fn: ListenerFnOptional context: anyOptional once: booleanAdd a listener for a given event.
Optional context: anyProtected onA callback that observes anchor, invoked when the anchor's values have been changed.
Protected onAdd a one-time listener for a given event.
Optional context: anyRegisters interaction by subscribing to the PIXI.InteractionManager.
Optional manager: InteractionManagerRemove all listeners, or those of the specified event.
Optional event: string | symbolRemoves all children from this container that are within the begin and end indexes.
Optional beginIndex: numberThe beginning position.
Optional endIndex: numberThe ending position. Default value is size of the container.
Remove the listeners of a given event.
Optional fn: ListenerFnOptional context: anyOptional once: booleanRenders the object using the WebGL renderer.
The [_render]PIXI.Container#_render method is be overriden for rendering the contents of the
container itself. This render method will invoke it, and also invoke the render methods of all
children afterward.
If renderable or visible is false or if worldAlpha is not positive or if cullable is true and
the bounds of this object are out of frame, this implementation will entirely skip rendering.
See PIXI.DisplayObject for choosing between renderable or visible. Generally,
setting alpha to zero is not recommended for purely skipping rendering.
When your scene becomes large (especially when it is larger than can be viewed in a single screen), it is advised to employ culling to automatically skip rendering objects outside of the current screen. See [cullable]PIXI.DisplayObject#cullable and [cullArea]PIXI.DisplayObject#cullArea. Other culling methods might be better suited for a large number static objects; see [@pixi-essentials/cull]https://www.npmjs.com/package/@pixi-essentials/cull and [pixi-cull]https://www.npmjs.com/package/pixi-cull.
The [renderAdvanced]PIXI.Container#renderAdvanced method is internally used when when masking or filtering is applied on a container. This does, however, break batching and can affect performance when masking and filtering is applied extensively throughout the scene graph.
The renderer
Protected renderChanges the position of an existing child in the display object container
The child DisplayObject instance for which you want to change the index number
The resulting index number for the child display object
Convenience function to set the position, scale, skew and pivot at once.
Optional x: numberThe X position
Optional y: numberThe Y position
Optional scaleX: numberThe X scale value
Optional scaleY: numberThe Y scale value
Optional rotation: numberThe rotation
Optional skewX: numberThe X skew value
Optional skewY: numberThe Y skew value
Optional pivotX: numberThe X pivot value
Optional pivotY: numberThe Y pivot value
Calculates the global position of the display object.
The world origin to calculate from.
Optional point: PA Point object in which to store the value, optional (otherwise will create a new Point).
Optional skipUpdate: booleanShould we skip the update transform.
Calculates the local position of the display object relative to another point.
The world origin to calculate from.
Optional from: DisplayObjectThe DisplayObject to calculate the global position from.
Optional point: PA Point object in which to store the value, optional (otherwise will create a new Point).
Optional skipUpdate: booleanShould we skip the update transform
Calculates the position in the canvas of original, unscaled Live2D model.
The Point in model canvas space.
A Point in world space.
A Point to store the new value. Defaults to a new Point.
Optional skipUpdate: booleanTrue to skip the update transform.
Unregisters interaction.
Static fromCreates a Live2DModel from given source.
Promise that resolves with the Live2DModel.
Can be one of: settings file URL, settings JSON object, ModelSettings instance.
Optional options: Live2DFactoryOptionsOptions for the creation.
Static fromSynchronous version of Live2DModel.from(). This method immediately returns a Live2DModel instance,
whose resources have not been loaded. Therefore this model can't be manipulated or rendered
until the "load" event has been emitted.
// no `await` here as it's not a Promise
const model = Live2DModel.fromSync('shizuku.model.json');
// these will cause errors!
// app.stage.addChild(model);
// model.motion('tap_body');
model.once('load', () => {
// now it's safe
app.stage.addChild(model);
model.motion('tap_body');
});
Optional options: Live2DFactoryOptionsStatic mixinStatic registerGenerated using TypeDoc
A wrapper that allows the Live2D model to be used as a DisplayObject in PixiJS.
Emits
Live2DModelEvents