The EchoMap maintains state for the application including WebGPU and Dear ImGui context, encapsulating initialisation, game loop, interaction, and clean-up. More...

#include <EchoMap.hpp>

Inheritance diagram for echomap::EchoMap:

[legend]

Public Member Functions
	EchoMap ()
	Initialise a EchoMap application instance.
virtual void	run_event_loop ()=0
	Runs the platform-dependent event loop to manage and propagate interaction with the EchoMap application.
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
auto	make_common_notification_visitors ()
	Produce an overload set for std::visit for all platform-independent Notification objects.
virtual void	visit_notification (Notification &notification)=0
	Uses std::visit on the given notification to invoke the corresponding handler.
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)
virtual void	handle_result (LoadProjectResult &&result)
virtual void	handle_result (LoadSignalFileResult &&result)

Static Protected Member Functions
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
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
static constexpr auto	operation_timeout = std::numeric_limits<std::uint64_t>::max()

Detailed Description

The EchoMap maintains state for the application including WebGPU and Dear ImGui context, encapsulating initialisation, game loop, interaction, and clean-up.

Definition at line 34 of file EchoMap.hpp.

Constructor & Destructor Documentation

◆ EchoMap()

echomap::EchoMap::EchoMap ( )

Initialise a EchoMap application instance.

Initialisation is a computationally substantial task. Context from all managed frameworks must be initialised (GLFW, WebGPU/Dawn, and Dear ImGui) and their components registered. Once the constructor has completed, the game loop can begin with run_event_loop.

Exceptions

ConfigurationError Some part of initialisation, described in the exception message, did not succeed.

Definition at line 41 of file EchoMap.cpp.

                 :
    window(create_window(
            static_cast<int>(viewport_width),
            static_cast<int>(viewport_height)
    )),
    worker{[] {
#if !defined(__EMSCRIPTEN__) || defined(__DOXYGEN__)
        glfwPostEmptyEvent();
#endif
    }},
    dockspace_id(ImHashStr("MainDockSpace"))
{
    setup_subscriptions();
 
    static constexpr auto timed_wait_any = wgpu::InstanceFeatureName::TimedWaitAny;
    constexpr wgpu::InstanceDescriptor instance_desc{.requiredFeatureCount = 1, .requiredFeatures = &timed_wait_any};
 
    instance = wgpu::CreateInstance(&instance_desc);
 
    int actual_width = 0;
    int actual_height = 0;
    glfwGetFramebufferSize(window, &actual_width, &actual_height);
    assert(actual_width >= 0);
    assert(actual_height >= 0);
    viewport_width = static_cast<std::uint32_t>(actual_width);
    viewport_height = static_cast<std::uint32_t>(actual_height);
 
    surface = SurfaceFactory::create_surface(instance, window);
 
    if (const auto adapter_wait = instance.WaitAny(request_adapter(), operation_timeout);
        adapter_wait != wgpu::WaitStatus::Success || !adapter)
        throw ConfigurationError("WebGPU adapter request did not complete");
 
    if (const auto device_wait = instance.WaitAny(request_device(), operation_timeout);
        device_wait != wgpu::WaitStatus::Success || !device)
        throw ConfigurationError("WebGPU device request did not complete");
 
    surface.GetCapabilities(adapter, &surface_capabilities);
    configure_surface(surface, device, surface_capabilities, viewport_width, viewport_height);
 
    setup_imgui();
 
    panels.push_back(std::make_unique<MenuPanel>());
    panels.push_back(std::make_unique<ProjectPanel>());
    panels.push_back(std::make_unique<SignalWaveformPanel>(&worker, despatcher));
    panels.push_back(std::make_unique<SensorGeometryPanel>(this));
    panels.push_back(std::make_unique<ChannelMappingPanel>(this));
    panels.push_back(std::make_unique<SignalDFTPanel>(&worker, despatcher, this));
}

◆ ~EchoMap()

echomap::EchoMap::~EchoMap ( )

virtualnoexcept

Clean up all persistent state registered by the application instance.

Definition at line 91 of file EchoMap.cpp.

{
    if (ImGui::GetCurrentContext() != nullptr) {
        ImGui_ImplWGPU_Shutdown();
        ImGui_ImplGlfw_Shutdown();
        ImPlot3D::DestroyContext();
        ImPlot::DestroyContext();
        ImGui::DestroyContext();
    }
 
    if (surface) {
        surface.Unconfigure();
        surface = nullptr;
    }
 
    device = nullptr;
    adapter = nullptr;
    instance = nullptr;
 
    if (window != nullptr) {
        glfwDestroyWindow(window);
        window = nullptr;
    }
 
    glfwTerminate();
}

Member Function Documentation

◆ change_active_project()

void echomap::EchoMap::change_active_project ( std::unique_ptr< Project > new_project )

noexcept

Definition at line 589 of file EchoMap.cpp.

{
    if (new_project == nullptr)
        LOG_DEBUG("Clearing the active project.");
    else
        LOG_F_DEBUG("Changing active project to {}.", new_project->get_name());
 
    for (const auto& panel : panels)
        panel->change_active_project(new_project.get());
 
    project = std::move(new_project);
}

◆ configure_surface()

void echomap::EchoMap::configure_surface	(	const wgpu::Surface &	surface,
		const wgpu::Device &	device,
		const wgpu::SurfaceCapabilities &	capabilities,
		std::uint32_t	viewport_width,
		std::uint32_t	viewport_height )

staticprotectednoexcept

Configure a WebGPU Surface from a static context given metadata and Adapter capabilities.

Note: There is no way to check if the given Surface is already configured from the public WebGPU.h API. Moreover, attempting to Unconfigure an unconfigured Surface will assert. Therefore, callers must ensure that the given Surface is in an unconfigured state prior to invoking this function, as it cannot sanity-check the state of the Surface.

Parameters

surface	The Surface to configure.
device	The WebGPU Device on which the Surface will be displayed.
capabilities	Capabilities of the WebGPU Adapter and Instance.
viewport_width	Initial width of the Surface viewport, in pixels.
viewport_height	Initial height of the Surface viewport, in pixels.

Definition at line 140 of file EchoMap.cpp.

{
    const wgpu::SurfaceConfiguration config{
            .device = device,
            // ReSharper disable once CppDFAConstantConditions
            // ReSharper disable once CppDFAUnreachableCode
            .format = capabilities.formats != nullptr ? *capabilities.formats : wgpu::TextureFormat::RGBA8Snorm,
            .usage = wgpu::TextureUsage::RenderAttachment,
            .width = viewport_width,
            .height = viewport_height,
            // ReSharper disable once CppDFAConstantConditions
            // ReSharper disable once CppDFAUnreachableCode
            .alphaMode =
                    capabilities.alphaModes != nullptr ? *capabilities.alphaModes : wgpu::CompositeAlphaMode::Opaque,
            .presentMode = wgpu::PresentMode::Fifo,
    };
 
    surface.Configure(&config);
}

◆ create_window()

GLFWwindow * echomap::EchoMap::create_window	(	int	width,
		int	height )

staticprotected

Create a new GLFW window of the specified dimensions from a static context.

Parameters

width	Initial width of the window, in pixels.
height	Initial height of the window, in pixels.

Returns: A mutable pointer to the created window, which must be explicitly deleted following use.

Exceptions

ConfigurationError A GLFW initialisation step failed.

Definition at line 118 of file EchoMap.cpp.

{
    if (glfwInit() == 0)
        throw ConfigurationError("glfwInit failed");
 
    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
 
    auto* const window = glfwCreateWindow(width, height, "EchoMap", nullptr, nullptr);
 
    if (window == nullptr) {
        glfwTerminate();
        throw ConfigurationError("glfwCreateWindow failed");
    }
 
    return window;
}

◆ handle_notification() [1/5]

void echomap::EchoMap::handle_notification ( const AddChannelMappingNotification & notification ) const

protected

Definition at line 521 of file EchoMap.cpp.

{
    notification.verify_project(project.get());
    project->add_association(notification.signal_id, notification.sensor_id);
}

◆ handle_notification() [2/5]

void echomap::EchoMap::handle_notification ( const ClearErrorNotification & notification )

protected

Definition at line 555 of file EchoMap.cpp.

{
    std::ignore = notification;
    error_modal.reset();
}

◆ handle_notification() [3/5]

void echomap::EchoMap::handle_notification ( const ModifySensorColourNotification & notification ) const

protected

Definition at line 529 of file EchoMap.cpp.

{
    notification.verify_project(project.get());
    project->get_mutable_sensor(notification.sensor_id).set_colour(notification.colour);
}

◆ handle_notification() [4/5]

void echomap::EchoMap::handle_notification ( const ModifySensorPositionNotification & notification ) const

protected

Definition at line 537 of file EchoMap.cpp.

{
    notification.verify_project(project.get());
    project->get_mutable_sensor(notification.sensor_id).set_position(notification.position);
}

◆ handle_notification() [5/5]

void echomap::EchoMap::handle_notification ( const ProjectSelectionCompleteNotification & notification )

protected

Definition at line 545 of file EchoMap.cpp.

{
    active_modal.reset();
 
    if (notification.path.has_value())
        worker.submit(std::make_unique<LoadProjectTask>(*notification.path, &worker));
}

◆ handle_result() [1/2]

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

protectedvirtual

Definition at line 563 of file EchoMap.cpp.

{
    if (active_modal != nullptr) {
        LOG_WARN("Ignoring request to change active Project since there is an active modal.");
        return;
    }
 
    change_active_project(std::move(std::move(result).take_project()));
}

◆ handle_result() [2/2]

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

protectedvirtual

Definition at line 575 of file EchoMap.cpp.

{
    if (project == nullptr || result.get_project_id() != project->get_id())
        LOG_F_WARN(
                "Dropping LoadSignalFileResult, which was intended for the unavailable Project with ID {}.",
                result.get_project_id()
        );
    else
        for (auto&& signals = std::move(result).take_signals(); auto signal : signals | std::views::as_rvalue)
            project->add_signal(std::move(signal));
}

◆ handle_window_resize()

bool echomap::EchoMap::handle_window_resize ( )

protectednoexcept

Check if the window has been resized compared with the stored dimensions, updating member variables and reconfiguring the WebGPU surface if necessary.

Returns: Is the window visible?

Definition at line 439 of file EchoMap.cpp.

{
    int fb_width = 0;
    int fb_height = 0;
    glfwGetFramebufferSize(window, &fb_width, &fb_height);
 
    if (fb_width <= 0 || fb_height <= 0)
        // The window is too small or collapsed.
        return false;
 
    const auto new_width = static_cast<std::uint32_t>(fb_width);
    // ReSharper disable once CppTooWideScopeInitStatement
    const auto new_height = static_cast<std::uint32_t>(fb_height);
 
    if (new_width != viewport_width || new_height != viewport_height) {
        // The window has been resized, so update the WebGPU surface.
 
        viewport_width = new_width;
        viewport_height = new_height;
 
        surface.Unconfigure();
        configure_surface(surface, device, surface_capabilities, viewport_width, viewport_height);
 
        // The window size has changed and the surface re-configured accordingly.
        return true;
    }
 
    // The window size is unchanged.
    return true;
}

◆ increment_forced_frames()

void echomap::EchoMap::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.

The forced frame count stacks (as in a source) until the renderer drains it to zero (as in a sink). By default, we force four frames since most Dear ImGui components can fully render a four-frame cycle.

Parameters

count The number of frames to force.

Definition at line 622 of file EchoMap.cpp.

{
    forced_frames += count;
}

◆ make_common_notification_visitors()

auto echomap::EchoMap::make_common_notification_visitors ( )

inlineprotected

Produce an overload set for std::visit for all platform-independent Notification objects.

Returns: The overload set.

Definition at line 94 of file EchoMap.hpp.

    {
        // clang-format off
        return variant_helpers::Overloaded{
            [this](const AddChannelMappingNotification& n) { handle_notification(n); },
            [this](const ModifySensorColourNotification& n) { handle_notification(n); },
            [this](const ModifySensorPositionNotification& n) { handle_notification(n); },
            [this](const ProjectSelectionCompleteNotification& n) { handle_notification(n); },
            [this](const ClearErrorNotification& n) { handle_notification(n); },
        };
        // clang-format on
    }

◆ notify()

void echomap::EchoMap::notify ( const Notification & notification )

Submit a new Notification to the application queue.

Notifications are processed at the beginning of render cycles in a first-come first-served ordering.

Parameters

notification The Notification to schedule.

Definition at line 604 of file EchoMap.cpp.

{
    notification_queue.emplace_back(notification);
 
    /*
     * The address is just a "hint" (as opposed to an ID) because the queue might be re-allocated. It's a best-guess
     * effort to quickly discriminate o notification without adding bloat to their structures.
     */
    LOG_F_DEBUG(
            "Scheduling {} with hint {} at position {}.",
            NotificationNames::indexed_names[notification_queue.back().index()],
            static_cast<void*>(&notification_queue.back()),
            notification_queue.size() - 1
    );
}

◆ process_notifications()

void echomap::EchoMap::process_notifications ( )

protected

Handle any unconsumed Notification objects from the queue.

Definition at line 470 of file EchoMap.cpp.

{
    while (!notification_queue.empty()) {
        auto& notification = notification_queue.back();
        const auto type_name = NotificationNames::indexed_names[notification.index()];
        auto* const hint = static_cast<void*>(&notification);
 
        LOG_F_DEBUG("Consuming {} with hint {}.", type_name, hint);
 
        try {
            visit_notification(notification);
        } catch (const IgnoredWarning& warning) {
            LOG_F_WARN("{} with hint {} was dropped: {}", type_name, hint, warning.what());
        } catch (const std::exception& exception) {
            raise_error(exception.what());
            LOG_F_ERROR("{} with hint {} was responsible for error: {}", type_name, hint, exception.what());
        }
 
        notification_queue.pop_back();
    }
}

◆ process_worker_results()

void echomap::EchoMap::process_worker_results ( )

protected

Handle any unconsumed events from the Worker.

Definition at line 492 of file EchoMap.cpp.

{
    while (auto result = worker.try_get_result())
        try {
            despatcher.publish(std::move(*result));
        } catch (const std::exception& exception) {
            Logger::log(Logger::Level::Error, exception.what(), std::source_location::current());
        }
}

◆ raise_error() [1/2]

void echomap::EchoMap::raise_error ( std::string_view message )

protected

Definition at line 502 of file EchoMap.cpp.

{
    error_modal.emplace(message, [this] {
        notify(ClearErrorNotification{});
    });
}

◆ raise_error() [2/2]

void echomap::EchoMap::raise_error	(	std::string_view	message,
		const std::runtime_error &	exception )

protected

Definition at line 511 of file EchoMap.cpp.

{
    error_modal.emplace(message, exception, [this] {
        notify(ClearErrorNotification{});
    });
}

◆ render()

void echomap::EchoMap::render ( )

protectednoexcept

Perform a render cycle on the configured Surface and Device.

A single render cycle requests all panels to render their state to the Surface, and provides an opportunity to submit any work to the GPU. Events are also received from GLFW and processed as required.

Definition at line 256 of file EchoMap.cpp.

{
    // Process any events that have arrived since the last cycle.
    process_notifications();
    process_worker_results();
 
    // Handle system/graphics changes.
    if (!handle_window_resize())
        return;
 
    wgpu::SurfaceTexture surface_texture{};
    surface.GetCurrentTexture(&surface_texture);
 
    switch (surface_texture.status) {
    case wgpu::SurfaceGetCurrentTextureStatus::Error:
    case wgpu::SurfaceGetCurrentTextureStatus::Lost:
    case wgpu::SurfaceGetCurrentTextureStatus::Outdated:
        surface.Unconfigure();
        configure_surface(surface, device, surface_capabilities, viewport_width, viewport_height);
        return;
 
    case wgpu::SurfaceGetCurrentTextureStatus::Timeout:
        return;
 
    case wgpu::SurfaceGetCurrentTextureStatus::SuccessOptimal:
    case wgpu::SurfaceGetCurrentTextureStatus::SuccessSuboptimal:
        break;
    }
 
    const wgpu::TextureView surface_view = surface_texture.texture.CreateView();
 
    ImGui_ImplWGPU_NewFrame();
    ImGui_ImplGlfw_NewFrame();
    ImGui::NewFrame();
 
    setup_dockspace();
 
    // Draw the panels and express any applicable error state.
    for (const auto& panel : panels)
        panel->draw();
 
    if (active_modal != nullptr)
        active_modal->draw();
 
    if (error_modal.has_value())
        error_modal->draw();
 
    ImGui::Render();
 
    // Set up a command encoder for the render and allow Dear ImGui panels to provide work.
    const wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
 
    // TODO no panels use GPU yet.
 
    // Provide the framebuffer to the WebGPU driver.
    wgpu::RenderPassColorAttachment const attachment{
            .view = surface_view,
            .loadOp = wgpu::LoadOp::Clear,
            .storeOp = wgpu::StoreOp::Store,
            .clearValue = {.r = 0.1, .g = 0.1, .b = 0.1, .a = 1.0},
    };
 
    const wgpu::RenderPassDescriptor pass_descriptor{.colorAttachmentCount = 1, .colorAttachments = &attachment};
    const wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&pass_descriptor);
 
    ImGui_ImplWGPU_RenderDrawData(ImGui::GetDrawData(), pass.Get());
    pass.End();
 
    const wgpu::CommandBuffer commands = encoder.Finish();
 
    // Submit batched work to the GPU.
    device.GetQueue().Submit(1, &commands);
 
#if !defined(__EMSCRIPTEN__) || defined(__DOXYGEN__)
    // ReSharper disable once CppExpressionWithoutSideEffects
    surface.Present();
#endif
}

◆ request_adapter()

wgpu::Future echomap::EchoMap::request_adapter ( )

protectednoexcept

Produce a WebGPU Future for requesting an Adapter.

Returns: A Future to request an Adapter that is suitable for the Surface member from the WebGPU driver.

Definition at line 186 of file EchoMap.cpp.

{
    const wgpu::RequestAdapterOptions options{.compatibleSurface = surface};
 
    return instance.RequestAdapter(
            &options,
            wgpu::CallbackMode::WaitAnyOnly,
            [this](const wgpu::RequestAdapterStatus status, wgpu::Adapter new_adapter, const wgpu::StringView message) {
                if (status != wgpu::RequestAdapterStatus::Success)
                    Logger::log_f(
                            Logger::Level::Error,
                            std::source_location::current(),
                            "WebGPU adapter request failed {}: {}.",
                            std::to_underlying(status),
                            std::string_view(message)
                    );
                else
                    adapter = std::move(new_adapter);
            }
    );
}

◆ request_device()

wgpu::Future echomap::EchoMap::request_device ( )

protectednoexcept

Produce a WebGPU Future for requesting an accelerator device.

Returns: A Future to request a Device from the WebGPU driver.

Definition at line 208 of file EchoMap.cpp.

{
    wgpu::DeviceDescriptor desc{};
    desc.SetDeviceLostCallback(
            wgpu::CallbackMode::AllowSpontaneous,
            [](const wgpu::Device&, const wgpu::DeviceLostReason reason, const wgpu::StringView message) {
                if (reason == wgpu::DeviceLostReason::Destroyed)
                    return;
 
                Logger::log_f(
                        Logger::Level::Warning,
                        std::source_location::current(),
                        "Device lost because of reason {}: {}.",
                        std::to_underlying(reason),
                        std::string_view(message)
                );
            }
    );
 
    desc.SetUncapturedErrorCallback(
            [](const wgpu::Device&, const wgpu::ErrorType error_type, const wgpu::StringView message) {
                Logger::log_f(
                        Logger::Level::Error,
                        std::source_location::current(),
                        "WebGPU error {}: {}",
                        std::to_underlying(error_type),
                        std::string_view(message)
                );
            }
    );
 
    return adapter.RequestDevice(
            &desc,
            wgpu::CallbackMode::WaitAnyOnly,
            [this](const wgpu::RequestDeviceStatus status, wgpu::Device new_device, const wgpu::StringView message) {
                if (status != wgpu::RequestDeviceStatus::Success)
                    Logger::log_f(
                            Logger::Level::Error,
                            std::source_location::current(),
                            "WebGPU device request failed: {}",
                            std::string_view(message)
                    );
                else
                    device = std::move(new_device);
            }
    );
}

◆ run_event_loop()

virtual void echomap::EchoMap::run_event_loop ( )

pure virtual

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.

Implemented in echomap::EchoMapNative, and echomap::EchoMapWeb.

◆ setup_dockspace()

void echomap::EchoMap::setup_dockspace ( )

protected

Definition at line 382 of file EchoMap.cpp.

{
    const auto* const viewport = ImGui::GetMainViewport();
 
    if (!dockspace_configured) {
        dockspace_configured = true;
 
        if (ImGui::DockBuilderGetNode(dockspace_id) == nullptr) {
            // Root dockspace node.
            ImGui::DockBuilderAddNode(dockspace_id, ImGuiDockNodeFlags_DockSpace);
            ImGui::DockBuilderSetNodeSize(dockspace_id, viewport->Size);
 
            // Left (narrow project explorer pane) and main workspace.
            ImGuiID dock_id_left = 0;
            ImGuiID dock_id_main = 0;
            ImGui::DockBuilderSplitNode(dockspace_id, ImGuiDir_Left, .15f, &dock_id_left, &dock_id_main);
            ImGui::DockBuilderDockWindow(ProjectPanel::get_imgui_stable_name(), dock_id_left);
 
            // Upper/lower
            ImGuiID dock_id_main_upper = 0;
            ImGuiID dock_id_main_lower = 0;
            ImGui::DockBuilderSplitNode(dock_id_main, ImGuiDir_Up, .33f, &dock_id_main_upper, &dock_id_main_lower);
 
            // Upper left/right
            ImGuiID dock_id_main_upper_left = 0;
            ImGuiID dock_id_main_upper_right = 0;
            ImGui::DockBuilderSplitNode(
                    dock_id_main_upper,
                    ImGuiDir_Left,
                    .5f,
                    &dock_id_main_upper_left,
                    &dock_id_main_upper_right
            );
            ImGui::DockBuilderDockWindow(ChannelMappingPanel::get_imgui_stable_name(), dock_id_main_upper_left);
            ImGui::DockBuilderDockWindow(SensorGeometryPanel::get_imgui_stable_name(), dock_id_main_upper_right);
 
            // Lower left/right
            ImGuiID dock_id_main_lower_left = 0;
            ImGuiID dock_id_main_lower_right = 0;
            ImGui::DockBuilderSplitNode(
                    dock_id_main_lower,
                    ImGuiDir_Left,
                    .5f,
                    &dock_id_main_lower_left,
                    &dock_id_main_lower_right
            );
            ImGui::DockBuilderDockWindow(SignalWaveformPanel::get_imgui_stable_name(), dock_id_main_lower_left);
            ImGui::DockBuilderDockWindow(SignalDFTPanel::get_imgui_stable_name(), dock_id_main_lower_right);
 
            ImGui::DockBuilderFinish(dockspace_id);
        }
    }
 
    ImGui::DockSpaceOverViewport(dockspace_id, viewport, ImGuiDockNodeFlags_PassthruCentralNode);
}

◆ setup_imgui()

void echomap::EchoMap::setup_imgui ( )

protected

Create a context for Dear ImGui and ImPlot, and configure the plain GLFW and WebGPU backends.

Exceptions

ConfigurationError A Dear ImGui backend could not be initialised.

Definition at line 336 of file EchoMap.cpp.

{
    if (!device)
        throw ConfigurationError("Cannot initialise ImGui: WebGPU device is null");
 
    // Bring up the Dear ImGui context and initialise the GLFW backend.
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImPlot::CreateContext();
    ImPlot3D::CreateContext();
 
    auto& io = ImGui::GetIO();
    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // NOLINT(*-signed-bitwise) - Required by ImGui API.
    io.Fonts->AddFontFromMemoryCompressedTTF(
            // ReSharper disable once CppRedundantCastExpression
            static_cast<const void*>(data::RobotoMedium_compressed_data),
            std::size(data::RobotoMedium_compressed_data),
            14
    );
    ImGui::StyleColorsLight();
 
    if (!ImGui_ImplGlfw_InitForOther(window, true))
        throw ConfigurationError("ImGui_ImplGlfw_InitForOther failed");
 
    // Configure the WebGPU backend for Dear ImGui.
    ImGui_ImplWGPU_InitInfo init_info{};
    init_info.Device = device.Get();
    // ReSharper disable once CppDFAConstantConditions
    // ReSharper disable once CppDFAUnreachableCode
    init_info.RenderTargetFormat = static_cast<WGPUTextureFormat>(std::to_underlying(
            (surface_capabilities.formats != nullptr) ? *surface_capabilities.formats : wgpu::TextureFormat::RGBA8Snorm
    ));
 
    if (!ImGui_ImplWGPU_Init(&init_info))
        throw ConfigurationError("ImGui_ImplWGPU_Init failed");
 
#if defined(__EMSCRIPTEN__) || defined(__DOXYGEN__)
    /*
     * If we're targeting WebAssembly, the window dimensions reported by GLFW should match the size of the canvas
     * identified by the CSS selector <code>#canvas</code>. Dear ImGui provides the helper
     * ImGui_ImplGlfw_InstallEmscriptenCallbacks to interface with the DOM and trigger re-draws as needed.
     */
    ImGui_ImplGlfw_InstallEmscriptenCallbacks(window, "#canvas");
#endif
}

◆ setup_subscriptions()

void echomap::EchoMap::setup_subscriptions ( )

protected

Configure the core signals for the application instance.

This should be invoked during construction prior to any IPanel invocations as it takes the exclusive consumer role for several critical message classes.

Definition at line 166 of file EchoMap.cpp.

{
    // NOLINTBEGIN(*-redundant-casting) - False positive; casts are required for libsigcpp to resolve overloads.
    connections.emplace_back(
            despatcher.load_project_finished_channel.nominate_consumer(
            sigc::mem_fun(*this, static_cast<void (EchoMap::*)(LoadProjectResult&&)>(&EchoMap::handle_result))
    ));
 
    connections.emplace_back(
            despatcher.load_signal_file_channel.nominate_consumer(
            sigc::mem_fun(*this, static_cast<void (EchoMap::*)(LoadSignalFileResult&&)>(&EchoMap::handle_result))
    ));
    // NOLINTEND(*-redundant-casting)
 
    connections.emplace_back(despatcher.error_channel.observe([this](const ErrorResult& error) {
        raise_error(error.what());
        LOG_F_ERROR("Error modal raised due to error: {}", error.what());
    }));
}

◆ visit_notification()

virtual void echomap::EchoMap::visit_notification ( Notification & notification )

protectedpure virtual

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.

Implemented in echomap::EchoMapNative, and echomap::EchoMapWeb.

Member Data Documentation

◆ active_modal

std::unique_ptr<IPanel> echomap::EchoMap::active_modal

protected

The current active non-ErrorModal modal panel.

Definition at line 246 of file EchoMap.hpp.

◆ adapter

wgpu::Adapter echomap::EchoMap::adapter

protected

Definition at line 232 of file EchoMap.hpp.

◆ connections

std::vector<sigc::scoped_connection> echomap::EchoMap::connections

protected

RAII lifetime manager for signal connections.

Definition at line 240 of file EchoMap.hpp.

◆ despatcher

WorkerResultDespatcher echomap::EchoMap::despatcher

protected

Despatcher to manage Worker result channels.

Definition at line 239 of file EchoMap.hpp.

◆ device

wgpu::Device echomap::EchoMap::device

protected

Definition at line 233 of file EchoMap.hpp.

◆ dockspace_configured

bool echomap::EchoMap::dockspace_configured = false

protected

Definition at line 249 of file EchoMap.hpp.

◆ dockspace_id

ImGuiID echomap::EchoMap::dockspace_id

protected

Definition at line 248 of file EchoMap.hpp.

◆ error_modal

std::optional<ErrorModal> echomap::EchoMap::error_modal

protected

Persistent panel to indicate errors over all other panels.

Definition at line 243 of file EchoMap.hpp.

◆ forced_frames

unsigned int echomap::EchoMap::forced_frames = 0

protected

Definition at line 250 of file EchoMap.hpp.

◆ instance

wgpu::Instance echomap::EchoMap::instance

protected

Definition at line 231 of file EchoMap.hpp.

◆ notification_queue

std::vector<Notification> echomap::EchoMap::notification_queue

protected

Definition at line 244 of file EchoMap.hpp.

◆ operation_timeout

auto echomap::EchoMap::operation_timeout = std::numeric_limits<std::uint64_t>::max()

staticconstexprprotected

Definition at line 125 of file EchoMap.hpp.

◆ panels

std::vector<std::unique_ptr<IProjectPanel> > echomap::EchoMap::panels

protected

Individual display components.

Definition at line 242 of file EchoMap.hpp.

◆ project

std::unique_ptr<Project> echomap::EchoMap::project

protected

Owning container for the active Project.

Definition at line 245 of file EchoMap.hpp.

◆ surface

wgpu::Surface echomap::EchoMap::surface

protected

Definition at line 234 of file EchoMap.hpp.

◆ surface_capabilities

wgpu::SurfaceCapabilities echomap::EchoMap::surface_capabilities

protected

Definition at line 235 of file EchoMap.hpp.

◆ viewport_height

std::uint32_t echomap::EchoMap::viewport_height = 1024

protected

Definition at line 229 of file EchoMap.hpp.

◆ viewport_width

std::uint32_t echomap::EchoMap::viewport_width = 1024

protected

Definition at line 228 of file EchoMap.hpp.

◆ window

GLFWwindow* echomap::EchoMap::window = nullptr

protected

Definition at line 236 of file EchoMap.hpp.

◆ worker

Worker echomap::EchoMap::worker

protected

Multi-threaded worker for scheduling heavy computation tasks.

Definition at line 238 of file EchoMap.hpp.

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

src/EchoMap.hpp
src/EchoMap.cpp

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ EchoMap()

◆ ~EchoMap()

Member Function Documentation

◆ change_active_project()

◆ configure_surface()

◆ create_window()

◆ handle_notification() [1/5]

◆ handle_notification() [2/5]

◆ handle_notification() [3/5]

◆ handle_notification() [4/5]

◆ handle_notification() [5/5]

◆ handle_result() [1/2]

◆ handle_result() [2/2]

◆ handle_window_resize()

◆ increment_forced_frames()

◆ make_common_notification_visitors()

◆ notify()

◆ process_notifications()

◆ process_worker_results()

◆ raise_error() [1/2]

◆ raise_error() [2/2]

◆ render()

◆ request_adapter()

◆ request_device()

◆ run_event_loop()

◆ setup_dockspace()

◆ setup_imgui()

◆ setup_subscriptions()

◆ visit_notification()

Member Data Documentation

◆ active_modal

◆ adapter

◆ connections

◆ despatcher

◆ device

◆ dockspace_configured

◆ dockspace_id

◆ error_modal

◆ forced_frames

◆ instance

◆ notification_queue

◆ operation_timeout

◆ panels

◆ project

◆ surface

◆ surface_capabilities

◆ viewport_height

◆ viewport_width

◆ window

◆ worker