还是一堆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