EchoMap.cpp

Go to the documentation of this file.

 
#include "EchoMap.hpp"
 
#include <imgui_impl_glfw.h>
#include <imgui_impl_wgpu.h>
#include <imgui_internal.h>
#include <implot.h>
#include <implot3d.h>
#include <sigc++/adaptors/bind.h>
 
#include "RobotoMedium.hpp"
#include "async/tasks/LoadProjectTask.hpp"
#include "errors/ConfigurationError.hpp"
#include "errors/IgnoredWarning.hpp"
#include "notifications/AllNotifications.hpp"
#include "objects/Project.hpp"
#include "objects/Sensor.hpp"
#include "objects/Signal.hpp"
#include "panels/ChannelMappingPanel.hpp"
#include "panels/MenuPanel.hpp"
#include "panels/ProjectPanel.hpp"
#include "panels/SensorGeometryPanel.hpp"
#include "panels/SignalDFTPanel.hpp"
#include "panels/SignalWaveformPanel.hpp"
#include "platform/SurfaceFactory.hpp"
#include "utility/Logger.hpp"
 
#ifdef __EMSCRIPTEN__
#include "objects/web/PartialProject.hpp"
#endif
 
namespace echomap
{
 
EchoMap::EchoMap() :
    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() noexcept
{
    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();
}
 
GLFWwindow* EchoMap::create_window(
        // ReSharper disable once CppDFAConstantParameter
        const int width,
        // ReSharper disable once CppDFAConstantParameter
        const int height
)
{
    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;
}
 
void EchoMap::configure_surface(
        const wgpu::Surface& surface,
        const wgpu::Device& device,
        const wgpu::SurfaceCapabilities& capabilities,
        const std::uint32_t viewport_width,
        const std::uint32_t viewport_height
) noexcept
{
    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);
}
 
void EchoMap::setup_subscriptions()
{
    // 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());
    }));
}
 
wgpu::Future EchoMap::request_adapter() noexcept
{
    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);
            }
    );
}
 
wgpu::Future EchoMap::request_device() noexcept
{
    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);
            }
    );
}
 
void EchoMap::render() noexcept
{
    // 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
}
 
// ReSharper disable once CppMemberFunctionMayBeConst - Not semantically constant
void EchoMap::setup_imgui()
{
    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
}
 
void EchoMap::setup_dockspace()
{
    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);
}
 
// ReSharper disable once CppDFAUnreachableFunctionCall
bool EchoMap::handle_window_resize() noexcept
{
    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;
}
 
void EchoMap::process_notifications()
{
    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();
    }
}
 
void EchoMap::process_worker_results()
{
    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());
        }
}
 
void EchoMap::raise_error(
        const std::string_view message
)
{
    error_modal.emplace(message, [this] {
        notify(ClearErrorNotification{});
    });
}
 
void EchoMap::raise_error(
        const std::string_view message,
        const std::runtime_error& exception
)
{
    error_modal.emplace(message, exception, [this] {
        notify(ClearErrorNotification{});
    });
}
 
void EchoMap::handle_notification(
        const AddChannelMappingNotification& notification
) const
{
    notification.verify_project(project.get());
    project->add_association(notification.signal_id, notification.sensor_id);
}
 
void EchoMap::handle_notification(
        const ModifySensorColourNotification& notification
) const
{
    notification.verify_project(project.get());
    project->get_mutable_sensor(notification.sensor_id).set_colour(notification.colour);
}
 
void EchoMap::handle_notification(
        const ModifySensorPositionNotification& notification
) const
{
    notification.verify_project(project.get());
    project->get_mutable_sensor(notification.sensor_id).set_position(notification.position);
}
 
void EchoMap::handle_notification(
        const ProjectSelectionCompleteNotification& notification
)
{
    active_modal.reset();
 
    if (notification.path.has_value())
        worker.submit(std::make_unique<LoadProjectTask>(*notification.path, &worker));
}
 
void EchoMap::handle_notification(
        const ClearErrorNotification& notification
)
{
    std::ignore = notification;
    error_modal.reset();
}
 
void EchoMap::handle_result(
        LoadProjectResult&& result
)
{
    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()));
}
 
void EchoMap::handle_result(
        LoadSignalFileResult&& result
)
{
    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));
}
 
void EchoMap::change_active_project(
        std::unique_ptr<Project> new_project
) noexcept
{
    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);
}
 
void EchoMap::notify(
        const Notification& notification
)
{
    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
    );
}
 
void EchoMap::increment_forced_frames(
        const unsigned int count
) noexcept
{
    forced_frames += count;
}
 
} // namespace echomap