EchoMap.hpp

Go to the documentation of this file.

 
#ifndef ECHOMAP_ECHOMAP_HPP
#define ECHOMAP_ECHOMAP_HPP
 
#include <GLFW/glfw3.h>
#include <imgui.h>
#include <sigc++/scoped_connection.h>
#include <webgpu/webgpu_cpp.h>
 
#include "async/Worker.hpp"
#include "async/WorkerResultDespatcher.hpp"
#include "notifications/AllNotificationsFwd.hpp"
#include "panels/ErrorModal.hpp"

namespace echomap
{
 
class IProjectPanel;
class Project;

class EchoMap
{
public:
    EchoMap();

    virtual void run_event_loop() = 0;

    virtual ~EchoMap() noexcept;
 
    void change_active_project(std::unique_ptr<Project> new_project) noexcept;

    void notify(const Notification& notification);

    void increment_forced_frames(unsigned int count = 4) noexcept;
 
    EchoMap(const EchoMap&) = delete;
    EchoMap& operator=(const EchoMap&) = delete;
    EchoMap(EchoMap&&) = delete;
    EchoMap& operator=(EchoMap&&) = delete;
 
protected:
    auto make_common_notification_visitors()
    {
        // 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
    }

    virtual void visit_notification(Notification& notification) = 0;

    void render() noexcept;
 
    static constexpr auto operation_timeout = std::numeric_limits<std::uint64_t>::max();

    static GLFWwindow* create_window(
            int width,
            int height
    );

    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;

    void setup_subscriptions();

    wgpu::Future request_adapter() noexcept;

    wgpu::Future request_device() noexcept;

    void setup_imgui();
 
    void setup_dockspace();

    bool handle_window_resize() noexcept;

    void process_notifications();

    void process_worker_results();
 
    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);
 
    // NOLINTBEGIN(*-non-private-member-variables-in-classes)
 
    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;                     
    WorkerResultDespatcher despatcher; 
    std::vector<sigc::scoped_connection> connections; 
 
    std::vector<std::unique_ptr<IProjectPanel>> panels; 
    std::optional<ErrorModal> error_modal;       
    std::vector<Notification> notification_queue;
    std::unique_ptr<Project> project;            
    std::unique_ptr<IPanel> active_modal; 
 
    ImGuiID dockspace_id;
    bool dockspace_configured = false;
    unsigned int forced_frames = 0;
 
    // NOLINTEND(*-non-private-member-variables-in-classes)
};
 
} // namespace echomap
 
#endif // ECHOMAP_ECHOMAP_HPP