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