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.
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.
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.
Protected_Tracks whether an inline onpointer* attribute is present. The browser itself compiles and
runs these attributes — they are standard GlobalEventHandlers, so setting one replaces
the previous handler and removing it removes the handler, exactly like onclick on any
HTML element. But because they bypass addEventListener, the connect/disconnect
bookkeeping that lets the application lazily attach its canvas pointer handlers must be
kept in sync here.
The attribute name (e.g. 'onpointerdown').
The attribute value, or null when the attribute has been removed.
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 base class for elements that front an engine Entity:
<pc-entity>and<pc-model>, which create one, and<pc-node>, which binds to one inside a model's instantiated hierarchy. It carries what all of them need — theentitycontract, registration with the owning application (which joins picked scene nodes back to elements by identity, never by name), and the pointer listener bookkeeping that lets the application lazily attach its canvas handlers.