还是一堆bug的状态

Qt/bridge/Qt_Event_Adapter.cpp

@@ -0,0 +1,147 @@
+#include "Qt_Event_Adapter.h"
+
+namespace renderive {
+
+Event_Type Qt_Event_Adapter::map_event_type(QEvent::Type type) {
+    switch (type) {
+    case QEvent::MouseMove:
+        return Event_Type::Pointer_Move;
+    case QEvent::MouseButtonPress:
+        return Event_Type::Pointer_Press;
+    case QEvent::MouseButtonRelease:
+        return Event_Type::Pointer_Release;
+    case QEvent::Wheel:
+        return Event_Type::Wheel;
+    case QEvent::KeyPress:
+        return Event_Type::Key_Press;
+    case QEvent::KeyRelease:
+        return Event_Type::Key_Release;
+    case QEvent::Resize:
+        return Event_Type::Resize;
+    case QEvent::Show:
+        return Event_Type::Show;
+    case QEvent::Hide:
+        return Event_Type::Hide;
+    case QEvent::Leave:
+        return Event_Type::Leave;
+    default:
+        return Event_Type::Pointer_Move;
+    }
+}
+
+Pointer_Event Qt_Event_Adapter::to_pointer_event(const QMouseEvent* qt_event, Event_Type type) {
+    Pointer_Event event(type);
+    event.position = to_pointf(qt_event->pos());
+    event.global_position = to_pointf(qt_event->globalPos());
+    event.button = to_mouse_button(qt_event->button());
+    event.buttons = to_mouse_buttons(qt_event->buttons());
+    event.modifiers = to_keyboard_modifiers(qt_event->modifiers());
+    return event;
+}
+
+Wheel_Event Qt_Event_Adapter::to_wheel_event(const QWheelEvent* qt_event) {
+    Wheel_Event event;
+    event.position = to_pointf(qt_event->position());
+    event.global_position = to_pointf(qt_event->globalPosition());
+    event.button = Mouse_Button::None;
+    event.buttons = to_mouse_buttons(qt_event->buttons());
+    event.modifiers = to_keyboard_modifiers(qt_event->modifiers());
+    event.pixel_delta_x = static_cast<double>(qt_event->pixelDelta().x());
+    event.pixel_delta_y = static_cast<double>(qt_event->pixelDelta().y());
+    event.angle_delta_x = static_cast<double>(qt_event->angleDelta().x());
+    event.angle_delta_y = static_cast<double>(qt_event->angleDelta().y());
+    return event;
+}
+
+Key_Event Qt_Event_Adapter::to_key_event(const QKeyEvent* qt_event, Event_Type type) {
+    Key_Event event(type);
+    event.key = to_key(qt_event->key());
+    event.native_key = qt_event->nativeVirtualKey();
+    event.modifiers = to_keyboard_modifiers(qt_event->modifiers());
+    event.auto_repeat = qt_event->isAutoRepeat();
+    return event;
+}
+
+Resize_Event Qt_Event_Adapter::to_resize_event(const QResizeEvent* qt_event) {
+    Resize_Event event;
+    event.old_size = to_size(qt_event->oldSize());
+    event.new_size = to_size(qt_event->size());
+    return event;
+}
+
+PointF Qt_Event_Adapter::to_pointf(const QPointF& p) {
+    return {p.x(), p.y()};
+}
+
+Point Qt_Event_Adapter::to_point(const QPoint& p) {
+    return {p.x(), p.y()};
+}
+
+Size Qt_Event_Adapter::to_size(const QSize& s) {
+    return {s.width(), s.height()};
+}
+
+Mouse_Button Qt_Event_Adapter::to_mouse_button(Qt::MouseButton button) {
+    switch (button) {
+    case Qt::LeftButton:
+        return Mouse_Button::Left;
+    case Qt::RightButton:
+        return Mouse_Button::Right;
+    case Qt::MiddleButton:
+        return Mouse_Button::Middle;
+    default:
+        return Mouse_Button::None;
+    }
+}
+
+std::uint8_t Qt_Event_Adapter::to_mouse_buttons(Qt::MouseButtons buttons) {
+    std::uint8_t result = 0;
+    if (buttons & Qt::LeftButton)
+        result |= 1;
+    if (buttons & Qt::RightButton)
+        result |= 2;
+    if (buttons & Qt::MiddleButton)
+        result |= 4;
+    return result;
+}
+
+Keyboard_Modifier Qt_Event_Adapter::to_keyboard_modifiers(Qt::KeyboardModifiers modifiers) {
+    auto result = static_cast<Keyboard_Modifier>(0);
+    if (modifiers & Qt::ShiftModifier)
+        result = result | Keyboard_Modifier::Shift;
+    if (modifiers & Qt::ControlModifier)
+        result = result | Keyboard_Modifier::Ctrl;
+    if (modifiers & Qt::AltModifier)
+        result = result | Keyboard_Modifier::Alt;
+    if (modifiers & Qt::MetaModifier)
+        result = result | Keyboard_Modifier::Meta;
+    return result;
+}
+
+Key Qt_Event_Adapter::to_key(int qt_key) {
+    switch (qt_key) {
+    case Qt::Key_Escape:
+        return Key::Escape;
+    case Qt::Key_Return:
+    case Qt::Key_Enter:
+        return Key::Enter;
+    case Qt::Key_Space:
+        return Key::Space;
+    case Qt::Key_Delete:
+        return Key::Delete;
+    case Qt::Key_Backspace:
+        return Key::Backspace;
+    case Qt::Key_Left:
+        return Key::Left;
+    case Qt::Key_Right:
+        return Key::Right;
+    case Qt::Key_Up:
+        return Key::Up;
+    case Qt::Key_Down:
+        return Key::Down;
+    default:
+        return Key::Unknown;
+    }
+}
+
+} // namespace renderive

Qt/bridge/Qt_Event_Adapter.h

@@ -0,0 +1,33 @@
+#pragma once
+#include "Core/event/Event.h"
+#include "Core/event/Key_Event.h"
+#include "Core/event/Pointer_Event.h"
+#include "Core/event/Resize_Event.h"
+#include "Core/event/Wheel_Event.h"
+#include <QEvent>
+#include <QKeyEvent>
+#include <QMouseEvent>
+#include <QResizeEvent>
+#include <QWheelEvent>
+
+namespace renderive {
+
+struct Qt_Event_Adapter {
+    static Event_Type map_event_type(QEvent::Type type);
+
+    static Pointer_Event to_pointer_event(const QMouseEvent* qt_event, Event_Type type);
+    static Wheel_Event to_wheel_event(const QWheelEvent* qt_event);
+    static Key_Event to_key_event(const QKeyEvent* qt_event, Event_Type type);
+    static Resize_Event to_resize_event(const QResizeEvent* qt_event);
+
+    static PointF to_pointf(const QPointF& p);
+    static Point to_point(const QPoint& p);
+    static Size to_size(const QSize& s);
+
+    static Mouse_Button to_mouse_button(Qt::MouseButton button);
+    static std::uint8_t to_mouse_buttons(Qt::MouseButtons buttons);
+    static Keyboard_Modifier to_keyboard_modifiers(Qt::KeyboardModifiers modifiers);
+    static Key to_key(int qt_key);
+};
+
+} // namespace renderive

Qt/bridge/Qt_Image_Adapter.cpp

@@ -0,0 +1,18 @@
+#include "Qt_Image_Adapter.h"
+
+namespace renderive {
+
+QImage Qt_Image_Adapter::to_qimage(const Image_View& view) {
+    if (view.empty())
+        return {};
+
+    return QImage(
+        reinterpret_cast<const uchar*>(view.data),
+        view.width,
+        view.height,
+        view.stride,
+        QImage::Format_ARGB32_Premultiplied
+    );
+}
+
+} // namespace renderive

Qt/bridge/Qt_Image_Adapter.h

@@ -0,0 +1,11 @@
+#pragma once
+#include "Core/render/Image_View.h"
+#include <QImage>
+
+namespace renderive {
+
+struct Qt_Image_Adapter {
+    static QImage to_qimage(const Image_View& view);
+};
+
+} // namespace renderive

Qt/bridge/Qt_Presentation_Sink.cpp

@@ -0,0 +1,33 @@
+#include "Qt_Presentation_Sink.h"
+#include <QMetaObject>
+#include <QWidget>
+
+namespace renderive {
+
+struct Qt_Presentation_Sink::Private {
+    QPointer<QWidget> widget;
+};
+
+Qt_Presentation_Sink::Qt_Presentation_Sink(QWidget* widget)
+    : d(std::make_unique<Private>()) {
+    d->widget = widget;
+}
+
+Qt_Presentation_Sink::~Qt_Presentation_Sink() = default;
+
+void Qt_Presentation_Sink::request_present(Rect dirty_rect) {
+    (void)dirty_rect;
+    if (!d->widget)
+        return;
+
+    QMetaObject::invokeMethod(
+        d->widget.data(),
+        [w = QPointer<QWidget>(d->widget)]() {
+            if (w)
+                w->update();
+        },
+        Qt::QueuedConnection
+    );
+}
+
+} // namespace renderive

Qt/bridge/Qt_Presentation_Sink.h

@@ -0,0 +1,22 @@
+#pragma once
+#include "Core/plot/Presentation_Sink.h"
+#include <QPointer>
+#include <memory>
+
+class QWidget;
+
+namespace renderive {
+
+class Qt_Presentation_Sink final : public Presentation_Sink {
+public:
+    explicit Qt_Presentation_Sink(QWidget* widget);
+    ~Qt_Presentation_Sink() override;
+
+    void request_present(Rect dirty_rect) override;
+
+private:
+    struct Private;
+    std::unique_ptr<Private> d;
+};
+
+} // namespace renderive

Qt/plot/Explicit_Plot.cpp

@@ -0,0 +1,21 @@
+#include "Explicit_Plot_p.h"
+
+namespace renderive {
+
+Explicit_Plot_Private::Explicit_Plot_Private()
+    : Abs_Plot_Private(std::make_unique<Explicit_Refresh_Strategy>()) {
+    explicit_strategy = static_cast<Explicit_Refresh_Strategy*>(strategy);
+}
+
+Explicit_Plot::Explicit_Plot()
+    : Abs_Plot(new Explicit_Plot_Private()) {}
+
+void Explicit_Plot::replot() {
+    auto* data = static_cast<Explicit_Plot_Private*>(d);
+    if (data->explicit_strategy) {
+        data->explicit_strategy->request_render();
+        data->core->request_manual_refresh();
+    }
+}
+
+} // namespace renderive

Qt/plot/Explicit_Plot.h

@@ -0,0 +1,10 @@
+#pragma once
+#include "Plot.h"
+namespace renderive {
+class LIB_DECL Explicit_Plot : public Abs_Plot {
+public:
+    Explicit_Plot();
+    ~Explicit_Plot() override = default;
+    void replot();
+};
+} // namespace renderive

Qt/plot/Explicit_Plot_p.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "Explicit_Plot.h"
+#include "Plot_p.h"
+#include "Core/plot/Explicit_Refresh_Strategy.h"
+
+namespace renderive {
+
+struct Explicit_Plot_Private : Abs_Plot_Private {
+    Explicit_Plot_Private();
+    Explicit_Refresh_Strategy* explicit_strategy{};
+};
+
+} // namespace renderive

Qt/plot/Latency_Eager_Plot.cpp

@@ -0,0 +1,36 @@
+#include "Latency_Eager_Plot_p.h"
+
+namespace renderive {
+
+Latency_Eager_Plot_Private::Latency_Eager_Plot_Private()
+    : Abs_Plot_Private(std::make_unique<Latency_Eager_Refresh_Strategy>()) {
+    latency_strategy = static_cast<Latency_Eager_Refresh_Strategy*>(strategy);
+}
+
+Latency_Eager_Plot::Latency_Eager_Plot()
+    : Abs_Plot(new Latency_Eager_Plot_Private()) {}
+
+double Latency_Eager_Plot::get_max_render_fps() const {
+    auto* data = static_cast<Latency_Eager_Plot_Private*>(d);
+    return data->latency_strategy ? data->latency_strategy->max_render_fps() : 0.0;
+}
+
+void Latency_Eager_Plot::set_max_render_fps(double fps) {
+    auto* data = static_cast<Latency_Eager_Plot_Private*>(d);
+    if (data->latency_strategy) {
+        data->latency_strategy->set_max_render_fps(fps);
+        data->core->mark_render_state_dirty();
+    }
+}
+
+Refresh_Control_Snapshot Latency_Eager_Plot::get_frame_feedback_state() const {
+    auto* data = static_cast<Latency_Eager_Plot_Private*>(d);
+    return data->latency_strategy ? data->latency_strategy->feedback_state() : Refresh_Control_Snapshot{};
+}
+
+void Latency_Eager_Plot::start_render(int max_render_fps) {
+    set_max_render_fps(max_render_fps);
+    Abs_Plot::start_render();
+}
+
+} // namespace renderive

Qt/plot/Latency_Eager_Plot.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "Plot.h"
+namespace renderive {
+class LIB_DECL Latency_Eager_Plot : public Abs_Plot {
+public:
+    Latency_Eager_Plot();
+    ~Latency_Eager_Plot() override = default;
+    [[nodiscard]] double get_max_render_fps() const;
+    void set_max_render_fps(double fps);
+    [[nodiscard]] Refresh_Control_Snapshot get_frame_feedback_state() const;
+    void start_render(int max_render_fps);
+};
+} // namespace renderive

Qt/plot/Latency_Eager_Plot_p.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "Latency_Eager_Plot.h"
+#include "Plot_p.h"
+#include "Core/plot/Latency_Eager_Refresh_Strategy.h"
+
+namespace renderive {
+
+struct Latency_Eager_Plot_Private : Abs_Plot_Private {
+    Latency_Eager_Plot_Private();
+    Latency_Eager_Refresh_Strategy* latency_strategy{};
+};
+
+} // namespace renderive

Qt/plot/Plot.cpp

@@ -0,0 +1,190 @@
+#include "Plot_p.h"
+#include "../bridge/Qt_Event_Adapter.h"
+#include "../bridge/Qt_Image_Adapter.h"
+#include "../bridge/Qt_Presentation_Sink.h"
+#include "Core/architecture/Render_Time.h"
+#include "Core/base/global.h"
+#include <QPainter>
+#include <QResizeEvent>
+
+namespace renderive {
+
+namespace {
+
+Color from_qcolor(const QColor& color) {
+    return {
+        static_cast<std::uint8_t>(color.red()),
+        static_cast<std::uint8_t>(color.green()),
+        static_cast<std::uint8_t>(color.blue()),
+        static_cast<std::uint8_t>(color.alpha())
+    };
+}
+
+QColor to_qcolor(Color color) {
+    return QColor(color.red, color.green, color.blue, color.alpha);
+}
+
+std::string to_utf8_string(const QString& text) {
+    QByteArray bytes = text.toUtf8();
+    return std::string(bytes.constData(), static_cast<std::size_t>(bytes.size()));
+}
+
+} // namespace
+
+void start_render_scheduler() {
+    Global::instance()->start_render_scheduler();
+}
+
+Abs_Plot_Private::Abs_Plot_Private(std::unique_ptr<Refresh_Strategy> refresh_strategy)
+    : strategy(refresh_strategy.get()),
+      core(std::make_unique<Plot_Core>(std::move(refresh_strategy))) {}
+
+Abs_Plot_Private::~Abs_Plot_Private() = default;
+
+void Abs_Plot_Private::attach_widget(Abs_Plot* plot) {
+    presentation_sink = std::make_shared<Qt_Presentation_Sink>(plot);
+    core->set_presentation_sink(presentation_sink);
+}
+
+Abs_Plot::Abs_Plot(Abs_Plot_Private* private_data)
+    : d(private_data) {
+    d->attach_widget(this);
+    setAttribute(Qt::WA_OpaquePaintEvent, true);
+    setMouseTracking(true);
+    setFocusPolicy(Qt::NoFocus);
+}
+
+Abs_Plot::~Abs_Plot() {
+    if (d) {
+        d->core->pause_render();
+        delete d;
+        d = nullptr;
+    }
+}
+
+void Abs_Plot::init() {
+    init_renderable_tree();
+}
+
+void Abs_Plot::init_renderable_tree() {
+    d->core->init();
+}
+
+Plot_Core* Abs_Plot::core() const {
+    return d ? d->core.get() : nullptr;
+}
+
+std::shared_ptr<Renderable> Abs_Plot::get_root_renderable() const {
+    return d->core->root_renderable();
+}
+
+std::shared_ptr<Renderable> Abs_Plot::create_renderable_node(const std::shared_ptr<Renderable>& parent, const QString& object_name) const {
+    return d->core->create_renderable_node(parent, to_utf8_string(object_name));
+}
+
+void Abs_Plot::remove_renderable(const std::shared_ptr<Renderable>& able) {
+    d->core->remove_renderable(able);
+}
+
+bool Abs_Plot::is_rendering() {
+    return d->core->is_rendering();
+}
+
+void Abs_Plot::start_render() {
+    d->core->start_render();
+}
+
+void Abs_Plot::pause_render() {
+    d->core->pause_render();
+}
+
+QColor Abs_Plot::background_color() {
+    return to_qcolor(d->core->background_color());
+}
+
+void Abs_Plot::set_background_color(const QColor& color) {
+    d->core->set_background_color(from_qcolor(color));
+}
+
+void Abs_Plot::mark_render_state_dirty() {
+    d->core->mark_render_state_dirty();
+}
+
+void Abs_Plot::paintEvent(QPaintEvent* event) {
+    d->paint_event(this, event);
+}
+
+bool Abs_Plot::event(QEvent* event) {
+    bool base_result = QWidget::event(event);
+    return d->event(this, event, base_result);
+}
+
+void Abs_Plot_Private::paint_event(Abs_Plot* plot, QPaintEvent* event) {
+    (void)event;
+    std::uint64_t paint_begin_time = steady_now_ns();
+    auto frame = core->begin_present();
+
+    QPainter painter(plot);
+    if (frame && !frame.image().empty()) {
+        QImage image = Qt_Image_Adapter::to_qimage(frame.image());
+        painter.drawImage(QPoint(0, 0), image);
+    }
+    else {
+        painter.fillRect(plot->rect(), plot->background_color());
+    }
+    painter.end();
+
+    core->end_present(std::move(frame), paint_begin_time, steady_now_ns());
+}
+
+bool Abs_Plot_Private::event(Abs_Plot* plot, QEvent* event, bool base_result) {
+    switch (event->type()) {
+    case QEvent::Resize: {
+        auto* resize_event = static_cast<QResizeEvent*>(event);
+        core->set_viewport_size(Qt_Event_Adapter::to_size(resize_event->size()));
+        core->dispatch_event(Qt_Event_Adapter::to_resize_event(resize_event));
+        core->mark_render_state_dirty();
+        break;
+    }
+    case QEvent::Show: {
+        Event show_event(Event_Type::Show);
+        core->dispatch_event(show_event);
+        core->start_render();
+        break;
+    }
+    case QEvent::Hide: {
+        Event hide_event(Event_Type::Hide);
+        core->dispatch_event(hide_event);
+        core->pause_render();
+        break;
+    }
+    case QEvent::Leave: {
+        Event leave_event(Event_Type::Leave);
+        core->dispatch_event(leave_event);
+        break;
+    }
+    case QEvent::Wheel:
+        core->dispatch_event(Qt_Event_Adapter::to_wheel_event(static_cast<QWheelEvent*>(event)));
+        break;
+    case QEvent::MouseMove:
+        core->dispatch_event(Qt_Event_Adapter::to_pointer_event(static_cast<QMouseEvent*>(event), Event_Type::Pointer_Move));
+        break;
+    case QEvent::MouseButtonPress:
+        core->dispatch_event(Qt_Event_Adapter::to_pointer_event(static_cast<QMouseEvent*>(event), Event_Type::Pointer_Press));
+        break;
+    case QEvent::MouseButtonRelease:
+        core->dispatch_event(Qt_Event_Adapter::to_pointer_event(static_cast<QMouseEvent*>(event), Event_Type::Pointer_Release));
+        break;
+    case QEvent::KeyPress:
+        core->dispatch_event(Qt_Event_Adapter::to_key_event(static_cast<QKeyEvent*>(event), Event_Type::Key_Press));
+        break;
+    case QEvent::KeyRelease:
+        core->dispatch_event(Qt_Event_Adapter::to_key_event(static_cast<QKeyEvent*>(event), Event_Type::Key_Release));
+        break;
+    default:
+        break;
+    }
+    return base_result;
+}
+
+} // namespace renderive

Qt/plot/Plot.h

@@ -0,0 +1,46 @@
+#pragma once
+#include "Core/architecture/global.h"
+#include "Core/architecture/Renderable.h"
+#include <QColor>
+#include <QEvent>
+#include <QPaintEvent>
+#include <QString>
+#include <QWidget>
+#include <memory>
+
+namespace renderive {
+
+void LIB_DECL start_render_scheduler();
+
+struct Abs_Plot_Private;
+class Plot_Core;
+class Performance_Shower;
+class Latency_Eager_Plot;
+class Explicit_Plot;
+
+class LIB_DECL Abs_Plot : public QWidget {
+    Q_OBJECT
+public:
+    virtual void init();
+    QColor background_color();
+    [[nodiscard]] Plot_Core* core() const;
+    [[nodiscard]] std::shared_ptr<Renderable> get_root_renderable() const;
+    [[nodiscard]] std::shared_ptr<Renderable> create_renderable_node(const std::shared_ptr<Renderable>& parent, const QString& object_name = {}) const;
+    QString object_name;
+    void set_background_color(const QColor& color);
+    void mark_render_state_dirty();
+    void remove_renderable(const std::shared_ptr<Renderable>& able);
+    virtual void init_renderable_tree();
+    bool is_rendering();
+    void start_render();
+    void pause_render();
+    ~Abs_Plot() override;
+
+protected:
+    explicit Abs_Plot(Abs_Plot_Private* private_data);
+    bool event(QEvent* event) final;
+    void paintEvent(QPaintEvent* event) final;
+    Abs_Plot_Private* d{};
+};
+
+} // namespace renderive

Qt/plot/Plot_p.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "Plot.h"
+#include "Core/plot/Plot_Core.h"
+#include "Core/plot/Refresh_Strategy.h"
+#include <memory>
+
+namespace renderive {
+
+class Qt_Presentation_Sink;
+
+struct Abs_Plot_Private {
+    explicit Abs_Plot_Private(std::unique_ptr<Refresh_Strategy> refresh_strategy);
+    virtual ~Abs_Plot_Private();
+
+    void attach_widget(Abs_Plot* plot);
+    bool event(Abs_Plot* plot, QEvent* event, bool base_result);
+    void paint_event(Abs_Plot* plot, QPaintEvent* event);
+
+    Refresh_Strategy* strategy{};
+    std::unique_ptr<Plot_Core> core;
+    std::shared_ptr<Qt_Presentation_Sink> presentation_sink;
+};
+
+} // namespace renderive

Qt/plot/export.h

@@ -0,0 +1,3 @@
+#pragma once
+#include "Explicit_Plot.h"
+#include "../plot/Latency_Eager_Plot.h"