Merge branch 'qt' of https://github.com/jgilje/86Box into qt

src/qt/CMakeLists.txt

@@ -20,8 +20,13 @@ add_library(ui STATIC
     qt_machinestatus.hpp
     qt_mediamenu.cpp
     qt_mediamenu.hpp
-    qt_gleswidget.cpp
-    qt_gleswidget.hpp
+    qt_rendererstack.cpp
+    qt_rendererstack.hpp
+    qt_rendererstack.ui
+    qt_softwarerenderer.cpp
+    qt_softwarerenderer.hpp
+    qt_hardwarerenderer.cpp
+    qt_hardwarerenderer.hpp
 
     qt_settings.cpp
     qt_settings.hpp

src/qt/qt_gleswidget.hpp

@@ -1,70 +0,0 @@
-#pragma once
-
-#include <QOpenGLFunctions>
-#include <QOpenGLWidget>
-#include <QPainter>
-#include <QEvent>
-#include <QKeyEvent>
-
-#include <atomic>
-#include <mutex>
-#include <QApplication>
-
-#ifdef WAYLAND
-#include "wl_mouse.hpp"
-#endif
-
-class GLESWidget : public QOpenGLWidget, protected QOpenGLFunctions
-{
-	Q_OBJECT
-
-private:
-    QImage m_image{QSize(2048 + 64, 2048 + 64), QImage::Format_RGB32};
-    std::mutex image_mx;
-    int x, y, w, h, sx, sy, sw, sh;
-    bool wayland = false;
-public:
-    void resizeGL(int w, int h) override;
-    void initializeGL() override;
-    void paintGL() override;
-    GLESWidget(QWidget* parent = nullptr)
-    : QOpenGLWidget(parent), QOpenGLFunctions()
-    {
-        setMinimumSize(16, 16);
-#ifdef WAYLAND
-        if (QApplication::platformName().contains("wayland")) {
-            wayland = true;
-            wl_init();
-        }
-#endif
-    }
-    ~GLESWidget()
-    {
-        makeCurrent();
-    }
-    void mousePressEvent(QMouseEvent* event) override;
-    void mouseReleaseEvent(QMouseEvent* event) override;
-    void mouseMoveEvent(QMouseEvent* event) override;
-    void wheelEvent(QWheelEvent *event) override;
-    void keyPressEvent(QKeyEvent* event) override
-    {
-        event->ignore();
-    }
-    void keyReleaseEvent(QKeyEvent* event) override
-    {
-        event->ignore();
-    }
-signals:
-    void reqUpdate();
-
-public slots:
-	void qt_real_blit(int x, int y, int w, int h);
-    void qt_mouse_poll();
-
-private:
-    struct mouseinputdata {
-        int deltax, deltay, deltaz;
-        int mousebuttons;
-    };
-    mouseinputdata mousedata;
-};

src/qt/qt_hardwarerenderer.cpp

@@ -0,0 +1,44 @@
+#include "qt_hardwarerenderer.hpp"
+
+void HardwareRenderer::resizeGL(int w, int h)
+{
+    glViewport(0, 0, w, h);
+}
+
+void HardwareRenderer::initializeGL()
+{
+    initializeOpenGLFunctions();
+}
+
+void HardwareRenderer::paintGL()
+{
+    QPainter painter(this);
+    painter.drawImage(QRect(0, 0, width(), height()), image, QRect(sx, sy, sw, sh));
+    // "release" image, reducing it's refcount, so renderstack::blit()
+    // won't have to reallocate
+    image = QImage();
+}
+
+void HardwareRenderer::setRenderType(RenderType type) {
+    QSurfaceFormat format;
+    switch (type) {
+    case RenderType::OpenGL:
+        setTextureFormat(GL_RGB);
+        format.setRenderableType(QSurfaceFormat::OpenGL);
+        break;
+    case RenderType::OpenGLES:
+        setTextureFormat(GL_RGBA);
+        format.setRenderableType(QSurfaceFormat::OpenGLES);
+        break;
+    }
+    setFormat(format);
+}
+
+void HardwareRenderer::onBlit(const QImage& img, int x, int y, int w, int h) {
+    image = img;
+    sx = x;
+    sy = y;
+    sw = w;
+    sh = h;
+    update();
+}

src/qt/qt_hardwarerenderer.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <QOpenGLFunctions>
+#include <QOpenGLWidget>
+#include <QPainter>
+#include <QEvent>
+#include <QKeyEvent>
+
+#include <atomic>
+#include <mutex>
+#include <QApplication>
+
+#ifdef WAYLAND
+#include "wl_mouse.hpp"
+#endif
+
+class HardwareRenderer : public QOpenGLWidget, protected QOpenGLFunctions
+{
+	Q_OBJECT
+
+private:
+    bool wayland = false;
+public:
+    void resizeGL(int w, int h) override;
+    void initializeGL() override;
+    void paintGL() override;
+    HardwareRenderer(QWidget* parent = nullptr)
+    : QOpenGLWidget(parent), QOpenGLFunctions()
+    {
+        setMinimumSize(16, 16);
+#ifdef WAYLAND
+        if (QApplication::platformName().contains("wayland")) {
+            wayland = true;
+            wl_init();
+        }
+#endif
+    }
+    ~HardwareRenderer()
+    {
+        makeCurrent();
+    }
+
+    enum class RenderType {
+        OpenGL,
+        OpenGLES,
+    };
+    void setRenderType(RenderType type);
+
+public slots:
+    void onBlit(const QImage& img, int, int, int, int);
+
+private:
+    QImage image;
+    int sx, sy, sw, sh;
+};

src/qt/qt_mainwindow.cpp

@@ -22,7 +22,6 @@ extern "C" {
 #include <array>
 
 #include "qt_settings.hpp"
-#include "qt_gleswidget.hpp"
 #include "qt_machinestatus.hpp"
 #include "qt_mediamenu.hpp"
 
@@ -31,7 +30,6 @@ extern "C" {
 #include <X11/keysym.h>
 #endif
 
-extern void qt_mouse_poll();
 extern void qt_mouse_capture(int);
 extern "C" void qt_blit(int x, int y, int w, int h);
 
@@ -45,28 +43,29 @@ MainWindow::MainWindow(QWidget *parent) :
     MediaMenu::ptr = mm;
 
     ui->setupUi(this);
-    video_setblit(qt_blit);
-    ui->glesWidget->setMouseTracking(true);
+    ui->stackedWidget->setMouseTracking(true);
+    ui->ogl->setRenderType(HardwareRenderer::RenderType::OpenGL);
+    ui->gles->setRenderType(HardwareRenderer::RenderType::OpenGLES);
 
     connect(this, &MainWindow::showMessageForNonQtThread, this, &MainWindow::showMessage_, Qt::BlockingQueuedConnection);
 
     connect(this, &MainWindow::setTitleForNonQtThread, this, &MainWindow::setTitle_, Qt::BlockingQueuedConnection);
     connect(this, &MainWindow::getTitleForNonQtThread, this, &MainWindow::getTitle_, Qt::BlockingQueuedConnection);
 
-    connect(this, &MainWindow::pollMouse, ui->glesWidget, &GLESWidget::qt_mouse_poll);
+    connect(this, &MainWindow::pollMouse, ui->stackedWidget, &RendererStack::mousePoll);
 
     connect(this, &MainWindow::setMouseCapture, this, [this](bool state) {
         mouse_capture = state ? 1 : 0;
         qt_mouse_capture(mouse_capture);
         if (mouse_capture) {
-            ui->glesWidget->grabMouse();
+            ui->stackedWidget->grabMouse();
 #ifdef WAYLAND
             if (QGuiApplication::platformName().contains("wayland")) {
                 wl_mouse_capture(this->windowHandle());
             }
 #endif
         } else {
-            ui->glesWidget->releaseMouse();
+            ui->stackedWidget->releaseMouse();
 #ifdef WAYLAND
             if (QGuiApplication::platformName().contains("wayland")) {
                 wl_mouse_uncapture();
@@ -76,7 +75,7 @@ MainWindow::MainWindow(QWidget *parent) :
     });
 
     connect(this, &MainWindow::resizeContents, this, [this](int w, int h) {
-        ui->glesWidget->resize(w, h);
+        ui->stackedWidget->resize(w, h);
         resize(w, h + menuBar()->height() + statusBar()->height());
     });
 
@@ -94,12 +93,11 @@ MainWindow::MainWindow(QWidget *parent) :
 
     ui->actionKeyboard_requires_capture->setChecked(kbd_req_capture);
     ui->actionRight_CTRL_is_left_ALT->setChecked(rctrl_is_lalt);
+
+    video_setblit(qt_blit);
 }
 
 MainWindow::~MainWindow() {
-    //sdl_close();
-    startblit();
-    //delete hw_widget;
     delete ui;
 }
 
@@ -723,7 +721,7 @@ void MainWindow::keyPressEvent(QKeyEvent* event)
 
 void MainWindow::blitToWidget(int x, int y, int w, int h)
 {
-    ui->glesWidget->qt_real_blit(x, y, w, h);
+    ui->stackedWidget->blit(x, y, w, h);
 }
 
 void MainWindow::keyReleaseEvent(QKeyEvent* event)
@@ -734,3 +732,15 @@ void MainWindow::keyReleaseEvent(QKeyEvent* event)
     keyboard_input(0, x11_keycode_to_keysym(event->nativeScanCode()));
 #endif
 }
+
+void MainWindow::on_actionSoftware_Renderer_triggered() {
+    ui->stackedWidget->setCurrentIndex(0);
+}
+
+void MainWindow::on_actionHardware_Renderer_OpenGL_triggered() {
+    ui->stackedWidget->setCurrentIndex(1);
+}
+
+void MainWindow::on_actionHardware_Renderer_OpenGL_ES_triggered() {
+    ui->stackedWidget->setCurrentIndex(2);
+}

src/qt/qt_mainwindow.hpp

@@ -52,6 +52,9 @@ private slots:
     void on_actionHard_Reset_triggered();
     void on_actionRight_CTRL_is_left_ALT_triggered();
     void on_actionKeyboard_requires_capture_triggered();
+    void on_actionHardware_Renderer_OpenGL_ES_triggered();
+    void on_actionHardware_Renderer_OpenGL_triggered();
+    void on_actionSoftware_Renderer_triggered();
 
     void refreshMediaMenu();
     void showMessage_(const QString& header, const QString& message);
@@ -60,6 +63,7 @@ private slots:
 protected:
     void keyPressEvent(QKeyEvent* event) override;
     void keyReleaseEvent(QKeyEvent* event) override;
+
 private:
     Ui::MainWindow *ui;
     std::unique_ptr<MachineStatus> status;

src/qt/qt_mainwindow.ui

@@ -37,7 +37,14 @@
      <number>0</number>
     </property>
     <item>
-     <widget class="GLESWidget" name="glesWidget"/>
+     <widget class="RendererStack" name="stackedWidget">
+      <property name="currentIndex">
+       <number>0</number>
+      </property>
+      <widget class="SoftwareRenderer" name="sw"/>
+      <widget class="HardwareRenderer" name="ogl"/>
+      <widget class="HardwareRenderer" name="gles"/>
+     </widget>
     </item>
    </layout>
   </widget>
@@ -77,6 +84,9 @@
      <string>View</string>
     </property>
     <addaction name="actionFullscreen"/>
+    <addaction name="actionSoftware_Renderer"/>
+    <addaction name="actionHardware_Renderer_OpenGL"/>
+    <addaction name="actionHardware_Renderer_OpenGL_ES"/>
    </widget>
    <widget class="QMenu" name="menuMedia">
     <property name="title">
@@ -146,12 +156,39 @@
     <string>Ctrl+Alt+PgUp</string>
    </property>
   </action>
+  <action name="actionSoftware_Renderer">
+   <property name="text">
+    <string>Software Renderer</string>
+   </property>
+  </action>
+  <action name="actionHardware_Renderer_OpenGL">
+   <property name="text">
+    <string>Hardware Renderer (OpenGL)</string>
+   </property>
+  </action>
+  <action name="actionHardware_Renderer_OpenGL_ES">
+   <property name="text">
+    <string>Hardware Renderer (OpenGL ES)</string>
+   </property>
+  </action>
  </widget>
  <customwidgets>
   <customwidget>
-   <class>GLESWidget</class>
+   <class>HardwareRenderer</class>
    <extends>QOpenGLWidget</extends>
-   <header>qt_gleswidget.hpp</header>
+   <header>qt_hardwarerenderer.hpp</header>
+  </customwidget>
+  <customwidget>
+   <class>SoftwareRenderer</class>
+   <extends>QWidget</extends>
+   <header>qt_softwarerenderer.hpp</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>RendererStack</class>
+   <extends>QStackedWidget</extends>
+   <header>qt_rendererstack.hpp</header>
+   <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>

src/qt/qt_rendererstack.cpp

@@ -1,8 +1,9 @@
-#include <QApplication>
-#include <QImage>
-#include <QGuiApplication>
-#include <qnamespace.h>
-#include "qt_gleswidget.hpp"
+#include "qt_rendererstack.hpp"
+#include "ui_qt_rendererstack.h"
+
+#include "qt_softwarerenderer.hpp"
+#include "qt_hardwarerenderer.hpp"
+
 #ifdef __APPLE__
 #include <CoreGraphics/CoreGraphics.h>
 #endif
@@ -14,6 +15,21 @@ extern "C"
 #include <86box/video.h>
 }
 
+RendererStack::RendererStack(QWidget *parent) :
+    QStackedWidget(parent),
+    ui(new Ui::RendererStack)
+{
+    ui->setupUi(this);
+    imagebufs = QVector<QImage>(2);
+    imagebufs[0] = QImage{QSize(2048 + 64, 2048 + 64), QImage::Format_RGB32};
+    imagebufs[1] = QImage{QSize(2048 + 64, 2048 + 64), QImage::Format_RGB32};
+}
+
+RendererStack::~RendererStack()
+{
+    delete ui;
+}
+
 extern "C" void macos_poll_mouse();
 void
 qt_mouse_capture(int on)
@@ -35,7 +51,7 @@ qt_mouse_capture(int on)
     return;
 }
 
-void GLESWidget::qt_mouse_poll()
+void RendererStack::mousePoll()
 {
 #ifdef __APPLE__
     return macos_poll_mouse();
@@ -52,25 +68,7 @@ void GLESWidget::qt_mouse_poll()
 #endif
 }
 
-void GLESWidget::resizeGL(int w, int h)
-{
-    glViewport(0, 0, w, h);
-}
-
-void GLESWidget::initializeGL()
-{
-    initializeOpenGLFunctions();
-    connect(this, &GLESWidget::reqUpdate, this, static_cast<void (GLESWidget::*)()>(&GLESWidget::update));
-}
-
-void GLESWidget::paintGL()
-{
-    std::scoped_lock lock(image_mx);
-    QPainter painter(this);
-    painter.drawImage(QRect(0, 0, width(), height()), m_image, QRect(sx, sy, sw, sh));
-}
-
-void GLESWidget::mouseReleaseEvent(QMouseEvent *event)
+void RendererStack::mouseReleaseEvent(QMouseEvent *event)
 {
     if (this->geometry().contains(event->pos()) && event->button() == Qt::LeftButton && !mouse_capture)
     {
@@ -89,7 +87,7 @@ void GLESWidget::mouseReleaseEvent(QMouseEvent *event)
         mousedata.mousebuttons &= ~event->button();
     }
 }
-void GLESWidget::mousePressEvent(QMouseEvent *event)
+void RendererStack::mousePressEvent(QMouseEvent *event)
 {
     if (mouse_capture)
     {
@@ -97,7 +95,7 @@ void GLESWidget::mousePressEvent(QMouseEvent *event)
     }
     event->accept();
 }
-void GLESWidget::wheelEvent(QWheelEvent *event)
+void RendererStack::wheelEvent(QWheelEvent *event)
 {
     if (mouse_capture)
     {
@@ -106,7 +104,7 @@ void GLESWidget::wheelEvent(QWheelEvent *event)
 }
 
 int ignoreNextMouseEvent = 0;
-void GLESWidget::mouseMoveEvent(QMouseEvent *event)
+void RendererStack::mouseMoveEvent(QMouseEvent *event)
 {
     if (QApplication::platformName().contains("wayland"))
     {
@@ -128,27 +126,39 @@ void GLESWidget::mouseMoveEvent(QMouseEvent *event)
 #endif
 }
 
-void GLESWidget::qt_real_blit(int x, int y, int w, int h)
+// called from blitter thread
+void RendererStack::blit(int x, int y, int w, int h)
 {
+    if ((w <= 0) || (h <= 0) || (w > 2048) || (h > 2048) || (buffer32 == NULL))
     {
-        std::scoped_lock lock(image_mx);
-        if ((w <= 0) || (h <= 0) || (w > 2048) || (h > 2048) || (buffer32 == NULL))
-        {
-            video_blit_complete();
-            return;
-        }
-        sx = x;
-        sy = y;
-        sw = this->w = w;
-        sh = this->h = h;
-        auto imagebits = m_image.bits();
-        video_copy(imagebits + y * ((2048 + 64) * 4) + x * 4, &(buffer32->line[y][x]), h * (2048 + 64) * sizeof(uint32_t));
-
-        if (screenshots)
-        {
-            video_screenshot((uint32_t *)imagebits, 0, 0, 2048 + 64);
-        }
         video_blit_complete();
+        return;
+    }
+    sx = x;
+    sy = y;
+    sw = this->w = w;
+    sh = this->h = h;
+    auto imagebits = imagebufs[currentBuf].bits();
+    video_copy(imagebits + y * ((2048 + 64) * 4) + x * 4, &(buffer32->line[y][x]), h * (2048 + 64) * sizeof(uint32_t));
+
+    if (screenshots)
+    {
+        video_screenshot((uint32_t *)imagebits, 0, 0, 2048 + 64);
+    }
+    video_blit_complete();
+    blitToRenderer(imagebufs[currentBuf], sx, sy, sw, sh);
+    currentBuf = (currentBuf + 1) % 2;
+}
+
+void RendererStack::on_RendererStack_currentChanged(int arg1) {
+    disconnect(this, &RendererStack::blitToRenderer, nullptr, nullptr);
+    switch (arg1) {
+    case 0:
+        connect(this, &RendererStack::blitToRenderer, dynamic_cast<SoftwareRenderer*>(currentWidget()), &SoftwareRenderer::onBlit);
+        break;
+    case 1:
+    case 2:
+        connect(this, &RendererStack::blitToRenderer, dynamic_cast<HardwareRenderer*>(currentWidget()), &HardwareRenderer::onBlit);
+        break;
     }
-    reqUpdate();
 }

src/qt/qt_rendererstack.hpp

@@ -0,0 +1,60 @@
+#ifndef QT_RENDERERCONTAINER_HPP
+#define QT_RENDERERCONTAINER_HPP
+
+#include <QStackedWidget>
+#include <QKeyEvent>
+
+namespace Ui {
+class RendererStack;
+}
+
+class RendererStack : public QStackedWidget
+{
+    Q_OBJECT
+
+public:
+    explicit RendererStack(QWidget *parent = nullptr);
+    ~RendererStack();
+
+    void mousePressEvent(QMouseEvent* event) override;
+    void mouseReleaseEvent(QMouseEvent* event) override;
+    void mouseMoveEvent(QMouseEvent* event) override;
+    void wheelEvent(QWheelEvent *event) override;
+    void keyPressEvent(QKeyEvent* event) override
+    {
+        event->ignore();
+    }
+    void keyReleaseEvent(QKeyEvent* event) override
+    {
+        event->ignore();
+    }
+
+signals:
+    void blitToRenderer(const QImage& img, int, int, int, int);
+
+public slots:
+    void blit(int x, int y, int w, int h);
+    void mousePoll();
+
+private slots:
+    void on_RendererStack_currentChanged(int arg1);
+
+private:
+    Ui::RendererStack *ui;
+
+    struct mouseinputdata {
+        int deltax, deltay, deltaz;
+        int mousebuttons;
+    };
+    mouseinputdata mousedata;
+
+    int x, y, w, h, sx, sy, sw, sh;
+
+    // always have a qimage available for writing, which is _probably_ unused
+    // worst case - it will just get reallocated because it's refcounter is > 1
+    // when calling bits();
+    int currentBuf = 0;
+    QVector<QImage> imagebufs;
+};
+
+#endif // QT_RENDERERCONTAINER_HPP

src/qt/qt_rendererstack.ui

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>RendererStack</class>
+ <widget class="QStackedWidget" name="RendererStack">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>StackedWidget</string>
+  </property>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

src/qt/qt_softwarerenderer.cpp

@@ -0,0 +1,22 @@
+#include "qt_softwarerenderer.hpp"
+
+#include <QPainter>
+
+SoftwareRenderer::SoftwareRenderer(QWidget *parent) : QWidget(parent) {}
+
+void SoftwareRenderer::paintEvent(QPaintEvent *event) {
+    (void) event;
+
+    QPainter painter(this);
+    painter.drawImage(QRect(0, 0, width(), height()), image, QRect(sx, sy, sw, sh));
+    image = QImage();
+}
+
+void SoftwareRenderer::onBlit(const QImage& img, int x, int y, int w, int h) {
+    image = img;
+    sx = x;
+    sy = y;
+    sw = w;
+    sh = h;
+    update();
+}

src/qt/qt_softwarerenderer.hpp

@@ -0,0 +1,22 @@
+#ifndef SOFTWARERENDERER_HPP
+#define SOFTWARERENDERER_HPP
+
+#include <QWidget>
+
+class SoftwareRenderer : public QWidget
+{
+    Q_OBJECT
+public:
+    explicit SoftwareRenderer(QWidget *parent = nullptr);
+
+    void paintEvent(QPaintEvent *event) override;
+
+public slots:
+    void onBlit(const QImage& img, int, int, int, int);
+
+private:
+    QImage image;
+    int sx, sy, sw, sh;
+};
+
+#endif // SOFTWARERENDERER_HPP