echomap::EchoMapWeb Class Reference

EchoMap application implementation for WebAssembly/Emscripten platforms. More...

#include <EchoMapWeb.hpp>

Inheritance diagram for echomap::EchoMapWeb:

Public Member Functions
void	run_event_loop () override
	Runs the platform-dependent event loop to manage and propagate interaction with the EchoMap application.
Public Member Functions inherited from echomap::EchoMap
	EchoMap ()
	Initialise a EchoMap application instance.
virtual	~EchoMap () noexcept
	Clean up all persistent state registered by the application instance.
void	change_active_project (std::unique_ptr< Project > new_project) noexcept
void	notify (const Notification &notification)
	Submit a new Notification to the application queue.
void	increment_forced_frames (unsigned int count=4) noexcept
	Indicate to the renderer that the following frames should always be rendered, regardless of whether there are any new events to process.
	EchoMap (const EchoMap &)=delete
EchoMap &	operator= (const EchoMap &)=delete
	EchoMap (EchoMap &&)=delete
EchoMap &	operator= (EchoMap &&)=delete

Protected Member Functions
void	visit_notification (Notification &notification) override
	Uses std::visit on the given notification to invoke the corresponding handler.
void	handle_result (LoadProjectResult &&result) override
void	handle_result (LoadSignalFileResult &&result) override
Protected Member Functions inherited from echomap::EchoMap
auto	make_common_notification_visitors ()
	Produce an overload set for std::visit for all platform-independent Notification objects.
void	render () noexcept
	Perform a render cycle on the configured Surface and Device.
void	setup_subscriptions ()
	Configure the core signals for the application instance.
wgpu::Future	request_adapter () noexcept
	Produce a WebGPU Future for requesting an Adapter.
wgpu::Future	request_device () noexcept
	Produce a WebGPU Future for requesting an accelerator device.
void	setup_imgui ()
	Create a context for Dear ImGui and ImPlot, and configure the plain GLFW and WebGPU backends.
void	setup_dockspace ()
bool	handle_window_resize () noexcept
	Check if the window has been resized compared with the stored dimensions, updating member variables and reconfiguring the WebGPU surface if necessary.
void	process_notifications ()
	Handle any unconsumed Notification objects from the queue.
void	process_worker_results ()
	Handle any unconsumed events from the Worker.
void	raise_error (std::string_view message)
void	raise_error (std::string_view message, const std::runtime_error &exception)
void	handle_notification (const AddChannelMappingNotification &notification) const
void	handle_notification (const ModifySensorColourNotification &notification) const
void	handle_notification (const ModifySensorPositionNotification &notification) const
void	handle_notification (const ProjectSelectionCompleteNotification &notification)
void	handle_notification (const ClearErrorNotification &notification)

Private Member Functions
void	handle_notification (const CancelProjectLoadNotification &notification)
void	handle_notification (const CompleteProjectLoadNotification &notification)
void	handle_notification (RegisterVFSMappingNotification &notification) const

Static Private Member Functions
static void	render_shim (void *echomap_instance)
	Invokes the renderer from a static context given an untyped mutable pointer to the EchoMap object instance.

Private Attributes
std::unique_ptr< PartialProject >	unloaded_project
	Owning container for the unloaded Project.

Additional Inherited Members
Static Protected Member Functions inherited from echomap::EchoMap
static GLFWwindow *	create_window (int width, int height)
	Create a new GLFW window of the specified dimensions from a static context.
static void	configure_surface (const wgpu::Surface &surface, const wgpu::Device &device, const wgpu::SurfaceCapabilities &capabilities, std::uint32_t viewport_width, std::uint32_t viewport_height) noexcept
	Configure a WebGPU Surface from a static context given metadata and Adapter capabilities.
Protected Attributes inherited from echomap::EchoMap
std::uint32_t	viewport_width = 1024
std::uint32_t	viewport_height = 1024
wgpu::Instance	instance
wgpu::Adapter	adapter
wgpu::Device	device
wgpu::Surface	surface
wgpu::SurfaceCapabilities	surface_capabilities
GLFWwindow *	window = nullptr
Worker	worker
	Multi-threaded worker for scheduling heavy computation tasks.
WorkerResultDespatcher	despatcher
	Despatcher to manage Worker result channels.
std::vector< sigc::scoped_connection >	connections
	RAII lifetime manager for signal connections.
std::vector< std::unique_ptr< IProjectPanel > >	panels
	Individual display components.
std::optional< ErrorModal >	error_modal
	Persistent panel to indicate errors over all other panels.
std::vector< Notification >	notification_queue
std::unique_ptr< Project >	project
	Owning container for the active Project.
std::unique_ptr< IPanel >	active_modal
	The current active non-ErrorModal modal panel.
ImGuiID	dockspace_id
bool	dockspace_configured = false
unsigned int	forced_frames = 0
Static Protected Attributes inherited from echomap::EchoMap
static constexpr auto	operation_timeout = std::numeric_limits<std::uint64_t>::max()

Detailed Description

EchoMap application implementation for WebAssembly/Emscripten platforms.

Definition at line 25 of file EchoMapWeb.hpp.

Member Function Documentation

handle_notification() [1/3]

void echomap::EchoMapWeb::handle_notification ( const CancelProjectLoadNotification & notification )

private

Definition at line 103 of file EchoMapWeb.cpp.

{
    notification.verify_project(unloaded_project.get());
 
    active_modal.reset();
    unloaded_project.reset();
}

handle_notification() [2/3]

void echomap::EchoMapWeb::handle_notification ( const CompleteProjectLoadNotification & notification )

private

Definition at line 113 of file EchoMapWeb.cpp.

{
    notification.verify_project(unloaded_project.get());
 
    // For each group, create a worker notification to load the corresponding file.
 
    for (auto&& [vfs_path, factories] : unloaded_project->take_unloaded_factories()) {
 
        if (!vfs_path.has_value())
            throw std::runtime_error("Refusing CompleteProjectLoadNotification due to an incomplete VFS mapping.");
 
        // Once these notifications return, if everything is loaded correctly, we'll change the active project.
        worker.submit(
                std::make_unique<LoadSignalFileTask>(unloaded_project->get_id(), *vfs_path, std::move(factories))
        );
    }
 
    active_modal.reset();
}

handle_notification() [3/3]

void echomap::EchoMapWeb::handle_notification ( RegisterVFSMappingNotification & notification ) const

private

Definition at line 135 of file EchoMapWeb.cpp.

{
    notification.verify_project(unloaded_project.get());
 
    try {
        unloaded_project->add_vfs_mapping_for_unavailable_signal(
                notification.external,
                std::move(notification.internal)
        );
    } catch (const std::runtime_error&) {
        throw IgnoredWarning(
                std::format(
                        "Dropping RegisterVFSMappingNotification since we don't need a mapping for {}.",
                        notification.external.c_str()
                )
        );
    }
}

handle_result() [1/2]

void echomap::EchoMapWeb::handle_result ( LoadProjectResult && result )

overrideprotectedvirtual

Reimplemented from echomap::EchoMap.

Definition at line 51 of file EchoMapWeb.cpp.

{
    if (active_modal != nullptr) {
        LOG_WARN("Ignoring request to change active Project since there is an active modal.");
        return;
    }
 
    auto&& new_project = std::move(result).take_project();
 
    if (!new_project->observe_unloaded_signals().empty()) {
        // Raise the modal to query for the sources.
        active_modal = std::make_unique<MapSourcesModal>(this, new_project.get());
        unloaded_project = std::move(new_project);
    } else
        change_active_project(std::move(new_project));
}

handle_result() [2/2]

void echomap::EchoMapWeb::handle_result ( LoadSignalFileResult && result )

overrideprotectedvirtual

Reimplemented from echomap::EchoMap.

Definition at line 70 of file EchoMapWeb.cpp.

{
    Project* target = nullptr;
 
    // Determine whether the result relates to a Signal bound to the active Project or the unloaded Project.
 
    if (project != nullptr && result.get_project_id() == project->get_id())
        target = project.get();
    else if (unloaded_project != nullptr && result.get_project_id() == unloaded_project->get_id())
        target = unloaded_project.get();
 
    if (target == nullptr) {
        LOG_F_WARN(
                "Dropping LoadSignalFileResult, which was intended for the unavailable Project with ID {}.",
                result.get_project_id()
        );
 
        return;
    }
 
    // Add the signals to the target Project.
 
    for (auto&& signals = std::move(result).take_signals(); auto signal : signals | std::views::as_rvalue)
        target->add_signal(std::move(signal));
 
    // If it was an unloaded Project, and all signals are now loaded, it can become the active Project.
 
    if (target == unloaded_project.get() && unloaded_project->observe_unloaded_signals().empty())
        change_active_project(std::move(unloaded_project));
}

render_shim()

void echomap::EchoMapWeb::render_shim ( void * echomap_instance )

staticprivate

Invokes the renderer from a static context given an untyped mutable pointer to the EchoMap object instance.

This function is intended to be used as a callback from the Emscripten C API.

Parameters

echomap_instance

The EchoMapWeb application instance on which to invoke the renderer.

Definition at line 156 of file EchoMapWeb.cpp.

{
    auto* instance = static_cast<EchoMapWeb*>(echomap_instance);
    instance->render();
}

run_event_loop()

void echomap::EchoMapWeb::run_event_loop ( )

overridevirtual

Runs the platform-dependent event loop to manage and propagate interaction with the EchoMap application.

This function returns only once GLFW indicates that the window should close. Following closure, the event loop could be re-run, or the application could clean up by calling the destructor.

Implements echomap::EchoMap.

Definition at line 164 of file EchoMapWeb.cpp.

{
    emscripten_set_main_loop_arg(&EchoMapWeb::render_shim, this, 0, true);
}

visit_notification()

void echomap::EchoMapWeb::visit_notification ( Notification & notification )

overrideprotectedvirtual

Uses std::visit on the given notification to invoke the corresponding handler.

This function is virtual, since the overload set can be platform-dependent in addition to the base handlers provided by make_common_notification_visitors.

Parameters

notification

The notification to visit.

Implements echomap::EchoMap.

Definition at line 32 of file EchoMapWeb.cpp.

{
    std::visit(
            // clang-format off
 
            variant_helpers::Overloaded{
                make_common_notification_visitors(),
                [this](const CancelProjectLoadNotification& n) { handle_notification(n); },
                [this](const CompleteProjectLoadNotification& n) { handle_notification(n); },
                [this](RegisterVFSMappingNotification& n) { handle_notification(n); },
            },
 
            // clang-format on
            notification
    );
}

Member Data Documentation

unloaded_project

std::unique_ptr<PartialProject> echomap::EchoMapWeb::unloaded_project

private

Owning container for the unloaded Project.

Definition at line 53 of file EchoMapWeb.hpp.

---

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

• src/platform/EchoMapWeb.hpp
• src/platform/EchoMapWeb.cpp