guillaume 2026.6.1
A C++ UI framework designed for modern desktop and extended reality (XR) applications.
Loading...
Searching...
No Matches
guillaume::systems::HandEventSystem< InteractionType, EventType > Class Template Reference

Base of the XR hand input systems: the wiring they share. More...

#include <headers/guillaume/systems/hand_event_system.hpp>

Inheritance diagram for guillaume::systems::HandEventSystem< InteractionType, EventType >:
Collaboration diagram for guillaume::systems::HandEventSystem< InteractionType, EventType >:

Public Member Functions

 HandEventSystem (event::EventBus &eventBus)
 Create the system, in the Event phase, and subscribe it to events of type EventType.
 ~HandEventSystem (void) override=default
 Default destructor.
void prepare (void) override
 Take the next pending event, once per frame.
void cleanup (void) override
 Does nothing.
void update (const ecs::Entity::Identifier &entityIdentifier) override
 React to the current event for one entity. Does nothing here; a derived system overrides it.
Public Member Functions inherited from guillaume::ecs::SystemFiller< InteractionType, components::Transform, components::Bound >
 SystemFiller (Phase phase)
 Create the system and set its signature from ComponentTypes.
virtual ~SystemFiller (void)=default
 Virtual destructor.
Public Member Functions inherited from guillaume::ecs::System
 System (Phase phase)
 Create a system that runs in a given phase, with an empty signature.
virtual ~System (void)=default
 Virtual destructor.
Phase getPhase (void) const noexcept
 Get the phase of the frame in which the system runs.
Entity::Signature getSignature (void) const noexcept
 Get the component types an entity must declare to be visited by this system.
void routine (ecs::ComponentRegistry &componentRegistry, ecs::EntityRegistry &entityRegistry, const ecs::EntityTreeTraveler &traveler)
 Run the system once over a scene: prepare(), update() on each matching entity, cleanup().
void bindComponentRegistry (ecs::ComponentRegistry &componentRegistry)
 Bind a component registry so update() can be called directly, without routine().
void unbindComponentRegistry (void)
 Drop the binding made by bindComponentRegistry().
Public Member Functions inherited from guillaume::event::EventManager< EventType >
 EventManager (EventBus &eventBus)
 Subscribe to a bus; events of type EventType published after this call are queued.
virtual ~EventManager (void)=default
 Virtual destructor.
bool hasPendingEvents (void) const
 Tell whether at least one event is queued, waiting for consumeNextEvent().

Additional Inherited Members

Protected Member Functions inherited from guillaume::ecs::System
template<InheritFromComponent... ComponentTypes>
void setSignature (void)
 Replace the signature by the one made of the given component types.
ecs::EntityRegistry & getEntityRegistry (void)
 Get the entity registry of the scene being processed.
const ecs::EntityRegistry & getEntityRegistry (void) const
 Get the entity registry of the scene being processed, read-only.
ecs::ComponentRegistry & getComponentRegistry (void)
 Get the component registry of the scene being processed.
const ecs::ComponentRegistry & getComponentRegistry (void) const
 Get the component registry of the scene being processed, read-only.
template<InheritFromComponent ComponentType>
bool hasComponent (const ecs::Entity::Identifier &entityIdentifier) const
 Tell whether an entity has a component, in the bound registry.
template<InheritFromComponent ComponentType>
ComponentType & getComponent (const ecs::Entity::Identifier &entityIdentifier)
 Get a component of an entity from the bound registry, to read or modify it.
template<InheritFromComponent ComponentType>
const ComponentType & getComponent (const ecs::Entity::Identifier &entityIdentifier) const
 Get a component of an entity from the bound registry, read-only.
template<InheritFromComponent ComponentType>
bool requireComponent (const ecs::Entity::Identifier &entityIdentifier)
 Tell whether an entity has a component, and log a warning naming the entity and the component when it does not.
Protected Member Functions inherited from guillaume::event::EventManager< EventType >
void consumeNextEvent (void)
 Take the oldest queued event and make it the last event.
std::shared_ptr< EventType > getLastEvent (void)
 Get the event taken by the most recent consumeNextEvent() that found one.

Detailed Description

template<ecs::InheritFromComponent InteractionType, utility::event::InheritFromEvent EventType>
class guillaume::systems::HandEventSystem< InteractionType, EventType >

Base of the XR hand input systems: the wiring they share.

A hand input system pairs one hand event type with one interaction component. This base runs in the Event phase on entities that have that component, a Transform and a Bound, and takes one event of its type per frame. What is done with the event is left to update(), which does nothing here: systems::HandSqueeze, HandThumbRest, HandThumbStick and HandTrigger use the base as is and therefore only subscribe to their event.

public HandEventSystem<components::HandSqueezeInteraction,
utility::event::HandSqueezeEvent>
{
// constructor forwarding the event bus
};
HandEventSystem(event::EventBus &eventBus)
Create the system, in the Event phase, and subscribe it to events of type EventType.
Receives XR hand squeeze events (the grip of a controller).
Template Parameters
InteractionTypeThe interaction component an entity must have to be visited.
EventTypeThe hand event the system subscribes to.
See also
systems::HandRaySystem

Definition at line 64 of file hand_event_system.hpp.

Constructor & Destructor Documentation

◆ HandEventSystem()

template<ecs::InheritFromComponent InteractionType, utility::event::InheritFromEvent EventType>
guillaume::systems::HandEventSystem< InteractionType, EventType >::HandEventSystem ( event::EventBus & eventBus)
explicit

Create the system, in the Event phase, and subscribe it to events of type EventType.

Parameters
eventBusThe event bus delivering the hand events.

Member Function Documentation

◆ cleanup()

template<ecs::InheritFromComponent InteractionType, utility::event::InheritFromEvent EventType>
void guillaume::systems::HandEventSystem< InteractionType, EventType >::cleanup ( void )
overridevirtual

Does nothing.

Reimplemented from guillaume::ecs::System.

◆ prepare()

template<ecs::InheritFromComponent InteractionType, utility::event::InheritFromEvent EventType>
void guillaume::systems::HandEventSystem< InteractionType, EventType >::prepare ( void )
overridevirtual

Take the next pending event, once per frame.

When none is pending, the previous event stays the current one.

Reimplemented from guillaume::ecs::System.

◆ update()

template<ecs::InheritFromComponent InteractionType, utility::event::InheritFromEvent EventType>
void guillaume::systems::HandEventSystem< InteractionType, EventType >::update ( const ecs::Entity::Identifier & entityIdentifier)
overridevirtual

React to the current event for one entity. Does nothing here; a derived system overrides it.

Parameters
entityIdentifierThe entity holding the interaction component.

Implements guillaume::ecs::System.

Reimplemented in guillaume::systems::HandRaySystem< InteractionType, EventType >, guillaume::systems::HandRaySystem< components::HandPinchInteraction, utility::event::HandPinchEvent >, and guillaume::systems::HandRaySystem< components::HandPokeInteraction, utility::event::HandPokeEvent >.


The documentation for this class was generated from the following file: