guillaume 2026.6.1
A C++ UI framework designed for modern desktop and extended reality (XR) applications.
Loading...
Searching...
No Matches
guillaume::ecs Namespace Reference

The entity-component-system core, independent of any widget. More...

Classes

class  Component
 Base class of every component: a piece of state attached to an entity, plus a "changed" flag. More...
class  EntityComponentNotFoundException
 Thrown by ComponentRegistry::getComponent when the entity has no component of the requested type. More...
class  ComponentRegistry
 Stores every component of a scene, per component type and per entity identifier, and knows which ones changed this frame. More...
class  ComponentRegistryFiller
 A ComponentRegistry whose storages for a fixed list of component types exist from construction. More...
class  IComponentStorage
 What ComponentRegistry can do with a component storage without knowing which component type it holds. More...
class  ComponentStorage
 Holds every component of one type, indexed by entity identifier. More...
class  ComponentTypeLimitExceededException
 Thrown by ComponentTypeId::get when a program uses more than MaxComponentTypes component types. More...
class  ComponentTypeId
 Gives each component type a small number: its bit position in an Entity::Signature. More...
class  Entity
 One thing in the UI: an identifier, a signature and a place in the tree. It holds no state of its own. More...
class  EntityBuilder
 Base class of the widget builders: remembers in which registries the entities it creates go. More...
class  EntityBuilderManager
 Holds one builder per builder type and hands them out by type. More...
class  EntityBuilderManagerFiller
 An EntityBuilderManager that creates one builder of each listed type when it is constructed. More...
class  EntityFiller
 The base class of a widget without children: an Entity that creates its components when it is constructed. More...
class  EntityRegistry
 Owns entities and gives the systems the list of entities to visit. More...
class  EntityRegistryContainer
 An EntityRegistry that is not itself an entity: the top of an ownership tree. More...
class  EntityTreeTraveler
 Decides in which order the entities of a scene are visited. More...
class  LevelOrderTraveler
 Visits owners before what they own: the entities owned by the scene first, then the entities those own, and so on. More...
class  ParentEntity
 An entity that owns child entities: both an Entity and an EntityRegistry. More...
class  ParentEntityFiller
 The base class of a widget with children: an EntityFiller that is also a ParentEntity. More...
class  ReverseLevelOrderTraveler
 Visits owned entities before their owners: the deepest entities first, the entities owned by the scene last. More...
class  System
 Base class of every system: a rule applied each frame to every entity that has a given set of components. More...
class  SystemFiller
 The base class to derive a system from: a System whose signature is the list of component types given as template arguments. More...
class  SystemPhase
 Ties a Phase to the order in which its systems visit the entities. More...
class  SystemRegistry
 Owns the systems of an application, grouped by phase and kept in registration order. More...

Concepts

concept  InheritFromComponent
 Constrains a template parameter to a type derived from Component (or Component itself).
concept  InheritFromComponentRegistry
 Constrains a template parameter to a type derived from ComponentRegistry (or ComponentRegistry itself).
concept  InheritFromEntity
 Constrains a template parameter to a type derived from Entity (or Entity itself).
concept  InheritFromEntityBuilder
 Constrains a template parameter to a type derived from EntityBuilder.
concept  InheritFromEntityTreeTraveler
 Constrains a template parameter to a type derived from EntityTreeTraveler.
concept  InheritFromSystem
 Constrains a template parameter to a type derived from System.

Typedefs

using EventPhase = SystemPhase<Phase::Event, ReverseLevelOrderTraveler>
 The Event phase: entities are visited children before parents.
using MeasurePhase = SystemPhase<Phase::Measure, ReverseLevelOrderTraveler>
 The Measure phase: entities are visited children before parents, so a parent is sized after its children.
using LayoutPhase = SystemPhase<Phase::Layout, LevelOrderTraveler>
 The Layout phase: entities are visited parents before children, so a parent is placed before it places its children.
using RenderPhase = SystemPhase<Phase::Render, LevelOrderTraveler>
 The Render phase: entities are visited parents before children.
using SystemPhaseList
 Every phase, in the order a frame runs them: Event, Measure, Layout, Render.

Enumerations

enum class  Phase : std::size_t {
  Event , Measure , Layout , Render ,
  Count
}
 The four steps of a frame. Every system belongs to one of them. More...

Variables

constexpr std::size_t MaxComponentTypes = 128
 Maximum number of distinct component types in one program.

Detailed Description

The entity-component-system core, independent of any widget.

See also
guillaume::ecs::System::routine for what happens each frame.

Typedef Documentation

◆ EventPhase

The Event phase: entities are visited children before parents.

Definition at line 116 of file system_phase.hpp.

◆ LayoutPhase

The Layout phase: entities are visited parents before children, so a parent is placed before it places its children.

Definition at line 128 of file system_phase.hpp.

◆ MeasurePhase

The Measure phase: entities are visited children before parents, so a parent is sized after its children.

Definition at line 122 of file system_phase.hpp.

◆ RenderPhase

The Render phase: entities are visited parents before children.

Definition at line 133 of file system_phase.hpp.

◆ SystemPhaseList

Initial value:
std::tuple<EventPhase, MeasurePhase, LayoutPhase, RenderPhase>

Every phase, in the order a frame runs them: Event, Measure, Layout, Render.

Definition at line 139 of file system_phase.hpp.

Enumeration Type Documentation

◆ Phase

enum class guillaume::ecs::Phase : std::size_t
strong

The four steps of a frame. Every system belongs to one of them.

Application::routine runs the phases in the order of the enumerators, once per frame. Within a phase, the systems run one after the other in the order they were registered, each one over the whole scene. A system therefore sees what the systems of the earlier phases wrote in the same frame, and what the later ones wrote in the previous frame.

Pick the phase of a system by what it produces: state driven by input goes in Event, an intrinsic size in Measure, positions and style in Layout, engine calls in Render.

See also
System
SystemPhaseList
Enumerator
Event 

Turn input (mouse, hands, keyboard) into component state and call the user's handlers

Measure 

Compute intrinsic sizes (text, glyphs), children before parents

Layout 

Place children and style widgets, parents before children

Render 

Hand the geometry to the engine, parents before children

Count 

Number of phases; not a phase.

Definition at line 52 of file system_phase.hpp.

Variable Documentation

◆ MaxComponentTypes

std::size_t guillaume::ecs::MaxComponentTypes = 128
constexpr

Maximum number of distinct component types in one program.

It is the number of bits of Entity::Signature: each component type owns one bit, handed out by ComponentTypeId.

Definition at line 38 of file component_type_id.hpp.