Protected_The application element this entity is registered with, cached at registration time so the entity can be unregistered even once this element has left the DOM.
Protected_Whether the hierarchy has been built for this entity — set once _buildHierarchy has
parented it. Read by subclasses that gate work on the entity being in the scene graph.
The nearest ancestor <pc-app> element, or null if this element has no <pc-app>
ancestor. The search starts at the parent, so an element never resolves to itself.
The closest app element, or null.
The nearest ancestor element that fronts an entity — <pc-entity>, <pc-model> or
<pc-node> — or null if this element has no such ancestor. The search starts at the
parent, so an element never resolves to itself.
The closest entity-fronting element, or null.
Gets the enabled state of the entity.
Whether the entity is enabled.
Sets the enabled state of the entity.
Whether the entity is enabled.
Gets the name of the entity.
The name of the entity.
Sets the name of the entity.
The name of the entity.
Gets the tags of the entity.
The tags of the entity.
Sets the tags of the entity.
The tags of the entity.
Protected_Called by _buildHierarchy once the backing entity has been parented — exactly once
per build cycle. The default announces readiness, which is what a parented <pc-entity>
means; <pc-model> overrides it to start loading content instead, because its readiness
tracks the content settling rather than the host entering the scene graph.
Protected_Handles the destruction of the backing entity. Resets the element so a later re-insertion
starts clean: _built must be cleared alongside _entity, or _buildHierarchy would bail
and a re-created entity would never be parented. Readiness is re-armed for the same
reason — with the entity gone, a resolved ready promise would resume its awaiters against
a null entity.
The entity that was destroyed.
Protected_Called when the element is fully initialized and ready. Subclasses should call this when
they're ready. Resolves the ready promise and dispatches a bubbling, composed ready
event. Signals at most once per readiness cycle: a repeat call before _resetReady
has re-armed the promise does nothing.
Protected_Registers entity as this element's backing entity with the owning application, which
joins engine nodes back to elements by identity (never by name).
The entity to register.
Protected_Returns the ready promise to its pending state. Subclasses should call this when the
resource their readiness announced is torn down (typically from disconnectedCallback),
so that a later re-initialization can signal readiness again. Does nothing while the
promise is still pending — an in-flight waiter carries over to the next readiness cycle
rather than being stranded on a promise nothing will ever resolve.
Protected_Removes the registration for entity.
The entity to unregister.
Returns a promise that resolves with this element when it's ready. This is the low-level primitive underlying whenReady, which is the recommended way to wait for elements.
Readiness tracks the element's current lifecycle: once a ready element is torn down (for example by removing it from the document), this returns a fresh promise that resolves when the element is next ready. A promise obtained earlier stays resolved — call this again after re-inserting an element rather than reusing a promise from before its removal.
A promise that resolves with this element when it's ready.
The EntityElement interface provides properties and methods for manipulating
<pc-entity>elements. The EntityElement interface also inherits the properties and methods of the HTMLElement interface.The pointer events below are dispatched by the containing
<pc-app>element when the pointer is over this entity's geometry, and behave like the DOM's own pointer events: each targets the element fronting the deepest node under the pointer and propagates up the element tree, so a listener on an ancestor entity, or on<pc-scene>, also receives the events of the entities below it.pointerenterandpointerleavedo not bubble - they are dispatched to each element the pointer moves onto or off.<pc-app>picks the scene for an event type while a listener for it is registered on an entity element or on<pc-scene>; itspickingattribute covers listeners it cannot see, such as a framework's delegated handlers.Attribute
enabled - The enabled state of the entity.
Attribute
name - The name of the entity.
Attribute
position - The position of the entity.
Attribute
rotation - The rotation of the entity.
Attribute
scale - The scale of the entity.
Attribute
tags - The tags of the entity.
Attribute
onpointerover - Script to run when the pointer moves onto the entity, or onto an entity below it.
Attribute
onpointerenter - Script to run when the pointer moves onto the entity or an entity below it, having been over none of them.
Attribute
onpointermove - Script to run when the pointer moves over the entity.
Attribute
onpointerdown - Script to run when a pointer button is pressed over the entity.
Attribute
onpointerup - Script to run when a pointer button is released over the entity.
Attribute
onpointercancel - Script to run when the browser cancels a press that began over the entity, for example because a touch became a scroll.
Attribute
onpointerout - Script to run when the pointer moves off the entity, or off an entity below it.
Attribute
onpointerleave - Script to run when the pointer moves off the entity and every entity below it.
Attribute
onclick - Script to run when the entity is clicked: a primary pointer button pressed and then released over it.
Fires
pointerover - Fired when the pointer moves onto the entity. Bubbles;
relatedTargetis the element the pointer came from, which is<pc-app>when it came from the background.Fires
pointerenter - Fired when the pointer moves onto the entity or an entity below it, having been over none of them. Does not bubble.
Fires
pointermove - Fired when the pointer moves over the entity.
Fires
pointerdown - Fired when a pointer button is pressed over the entity.
Fires
pointerup - Fired when a pointer button is released over the entity.
Fires
pointercancel - Fired on the entity a press began over when the browser cancels that press, for example because a touch became a scroll. No click follows.
Fires
pointerout - Fired when the pointer moves off the entity. Bubbles;
relatedTargetis the element the pointer went to, which is<pc-app>when it went to the background.Fires
pointerleave - Fired when the pointer moves off the entity and every entity below it. Does not bubble.
Fires
click - Fired when a primary pointer button is pressed and then released over the entity. A press and release that picked different elements fires on their nearest common ancestor instead, as in the DOM.
detailcarries the click count, so a double click arrives as a click whosedetailis 2.