Event handling and registry mutation in EnTT

[Kurtaga]

Hi, I’m building a small engine (for my master’s thesis) using EnTT.

I intentionally model windows as entities in a “main world” registry (inspired by Bevy’s approach).

Currently, I translate platform events (GLFW) into EnTT dispatcher events, for example:

struct WindowCloseEvent
{
    entt::entity window;
};

struct WindowResizeEvent
{
    entt::entity window;
    uint32_t width;
    uint32_t height;
};

This makes me wonder about few more general architectural questions regarding dispatcher and registry:

a) Is entt::dispatcher a good fit for these kind of events?
These events originate outside the ECS, but multiple systems need to react (renderer surface resize, UI layout, shutdown logic, etc.). Using dispatcher feels natural here, but I’m not sure whether this aligns with EnTT’s intended patterns or if there’s a more idiomatic approach.

b) Is it ok for dispatcher handlers to mutate the registry?
For a WindowCloseEvent, I want to destroy the window entity. If I do this in a listener, it means the handler needs access to the registry. The cleanest way I found is storing a handler object in registry.ctx() and connecting a member function. However, this makes a context variable stored inside the registry able to reach back up to the registry, which feels awkward.

c) Is it ok for dispatcher events to be enqueued/triggered in a system and dispatcher.update() to be called inside a system?

d) Would a tag-component approach be more idiomatic?
For example, adding a WindowClosed component and having a system process and remove it.

e) Are entt::observers actually a solution for this kind of problem?

Context:

• currently single-threaded,
• main world and render world are separate registries,
• render world extracts from main each frame (inspired by Bevy).

For reference, this is my current demo:

Details

#pragma once

#include <vector>

#include "platform/Window.hpp"
#include "engine/Engine.hpp"

namespace engine
{

struct WindowResizeEvent
{
	entt::entity entity;

	uint32_t width = 0;
	uint32_t height = 0;
};

struct WindowFocusEvent
{
	entt::entity entity;

	bool isFocus = true;
};

struct WindowCloseEvent
{
	entt::entity entity;
};

struct WindowCloseListener
{
	World& main;

	void on_close(const WindowCloseEvent& event)
	{
		if (main.registry().valid(event.entity))
		{
			main.registry().destroy(event.entity);
		}
	}
};

struct WindowKeyEvent
{
	entt::entity entity;

	platform::Key key = platform::Key::Unknown;
	platform::Action action = platform::Action::Unknown;
};

struct WindowMouseButtonEvent
{
	entt::entity entity;

	platform::MouseButton button = platform::MouseButton::Unknown;
	platform::Action action = platform::Action::Unknown;
};

struct WindowMouseMoveEvent
{
	entt::entity entity;

	double x = 0;
	double y = 0;
};

struct WindowScrollEvent
{
	entt::entity entity;

	double dx = 0;
	double dy = 0;
};

struct PlatformWindow
{
	static constexpr bool in_place_delete = true;

	platform::Window handle;
};

struct Window
{
	static void on_construct(entt::registry& registry,
		const entt::entity entity)
	{
		const Window& window = registry.get<Window>(entity);

		registry.emplace<PlatformWindow>(entity, PlatformWindow{
			.handle = platform::Window{ window.desc }
			});
	}

	static void on_destroy(entt::registry& registry,
		const entt::entity entity)
	{
		registry.remove<PlatformWindow>(entity);
	}

	platform::WindowDesc desc;
};

struct PrimaryWindow
{
};

namespace // anonymous
{

void flush_platform_events(World& main)
{
    auto& dispatcher = main.dispatcher();

    auto view = main.registry().view<PlatformWindow>();

    for (auto [entity, platformWindow] : view.each())
    {
        for (const auto& event : platformWindow.handle.events())
        {
            if (auto* resizeEvent =
				std::get_if<platform::ResizeEvent>(&event))
            {
                dispatcher.enqueue<WindowResizeEvent>({ entity,
					resizeEvent->width, resizeEvent->height });
            }
            else if (auto* focusEvent =
				std::get_if<platform::FocusEvent>(&event))
            {
                dispatcher.enqueue<WindowFocusEvent>({ entity,
					focusEvent->focused });
            }
            else if (auto* closeEvent =
				std::get_if<platform::CloseEvent>(&event))
            {
                dispatcher.enqueue<WindowCloseEvent>({ entity });
            }
			else if (auto* keyEvent =
				std::get_if<platform::KeyEvent>(&event))
			{
				dispatcher.enqueue<WindowKeyEvent>({ entity,
					keyEvent->key, keyEvent->action });
			}
			else if (auto* buttonEvent =
				std::get_if<platform::MouseButtonEvent>(&event))
			{
				dispatcher.enqueue<WindowMouseButtonEvent>({ entity,
					buttonEvent->mouseButton, buttonEvent->action });
			}
			else if (auto* moveEvent =
				std::get_if<platform::MouseMoveEvent>(&event))
			{
				dispatcher.enqueue<WindowMouseMoveEvent>({ entity,
					moveEvent->x, moveEvent->y });
			}
			else if (auto* scrollEvent =
				std::get_if<platform::ScrollEvent>(&event))
			{
				dispatcher.enqueue<WindowScrollEvent>({ entity,
					scrollEvent->dx, scrollEvent->dy });
			}
        }

		platformWindow.handle.clearEvents();
    }
}

} // anonymous namespace

struct WindowPlugin
{
	void build(Engine& engine)
	{
		engine.scheduler().addSystem<Stage::Input>([&engine]()
			{
				flush_platform_events(engine.main());

			});

		engine.scheduler().addSystem<Stage::Cleanup>([&engine]()
			{
				engine.main().dispatcher().update<WindowCloseEvent>();

			});

		auto& closeListener = engine.main().registry().ctx()
			.emplace<WindowCloseListener>(engine.main());

		engine.main().dispatcher().sink<WindowCloseEvent>()
			.connect<&WindowCloseListener::on_close>(closeListener);


	}
};

} // namespace engine

Any guidance would be appreciated.