FBO MSAA WIP

nschimme · nschimme · commit f70ab50ff736 · 2025-07-20T15:59:41.000-04:00
diff --git a/src/configuration/configuration.cpp b/src/configuration/configuration.cpp
@@ -596,7 +596,7 @@ void Configuration::CanvasSettings::read(const QSettings &conf)
     connectionNormalColor = lookupColor(KEY_CONNECTION_NORMAL_COLOR, Colors::white.toHex());
     roomDarkColor = lookupColor(KEY_ROOM_DARK_COLOR, DEFAULT_DARK_COLOR);
     roomDarkLitColor = lookupColor(KEY_ROOM_DARK_LIT_COLOR, DEFAULT_NO_SUNDEATH_COLOR);
-    antialiasingSamples = conf.value(KEY_NUMBER_OF_ANTI_ALIASING_SAMPLES, 0).toInt();
+    advanced.antialiasingSamples.set(conf.value(KEY_NUMBER_OF_ANTI_ALIASING_SAMPLES, 0).toInt());
     trilinearFiltering = conf.value(KEY_USE_TRILINEAR_FILTERING, true).toBool();
     advanced.use3D.set(conf.value(KEY_3D_CANVAS, false).toBool());
     advanced.autoTilt.set(conf.value(KEY_3D_AUTO_TILT, true).toBool());
@@ -779,7 +779,7 @@ void Configuration::CanvasSettings::write(QSettings &conf) const
     conf.setValue(KEY_ROOM_DARK_COLOR, getQColorName(roomDarkColor));
     conf.setValue(KEY_ROOM_DARK_LIT_COLOR, getQColorName(roomDarkLitColor));
     conf.setValue(KEY_CONNECTION_NORMAL_COLOR, getQColorName(connectionNormalColor));
-    conf.setValue(KEY_NUMBER_OF_ANTI_ALIASING_SAMPLES, antialiasingSamples);
+    conf.setValue(KEY_NUMBER_OF_ANTI_ALIASING_SAMPLES, advanced.antialiasingSamples.get());
     conf.setValue(KEY_USE_TRILINEAR_FILTERING, trilinearFiltering);
     conf.setValue(KEY_3D_CANVAS, advanced.use3D.get());
     conf.setValue(KEY_3D_AUTO_TILT, advanced.autoTilt.get());
diff --git a/src/configuration/configuration.h b/src/configuration/configuration.h
@@ -139,7 +139,6 @@ class NODISCARD Configuration final
         NamedConfig<bool> showUnmappedExits{"SHOW_UNMAPPED_EXITS", false};
         bool drawUpperLayersTextured = false;
         bool drawDoorNames = false;
-        int antialiasingSamples = 0;
         bool trilinearFiltering = false;
         bool softwareOpenGL = false;
         QString resourcesDirectory;
@@ -155,6 +154,7 @@ class NODISCARD Configuration final
 
         struct NODISCARD Advanced final
         {
+            NamedConfig<int> antialiasingSamples{"ANTIALIASING_SAMPLES", 0};
             NamedConfig<bool> use3D{"MMAPPER_3D", true};
             NamedConfig<bool> autoTilt{"MMAPPER_AUTO_TILT", true};
             NamedConfig<bool> printPerfStats{"MMAPPER_GL_PERFSTATS", IS_DEBUG_BUILD};
diff --git a/src/display/mapcanvas_gl.cpp b/src/display/mapcanvas_gl.cpp
@@ -268,6 +268,11 @@ void MapCanvas::initializeGL()
     setConfig().canvas.showUnmappedExits.registerChangeCallback(m_lifetime, [this]() {
         this->forceUpdateMeshes();
     });
+
+    setConfig().canvas.advanced.antialiasingSamples.registerChangeCallback(m_lifetime, [this]() {
+        this->updateMultisampling();
+        this->update();
+    });
 }
 
 /* Direct means it is always called from the emitter's thread */
@@ -472,6 +477,10 @@ void MapCanvas::resizeGL(int width, int height)
 
     setViewportAndMvp(width, height);
 
+    // Update the multisampling FBO size when the canvas is resized
+    const int wantMultisampling = getConfig().canvas.advanced.antialiasingSamples.get();
+    getOpenGL().setMultisamplingFbo(wantMultisampling, size());
+
     // Render
     update();
 }
@@ -621,6 +630,20 @@ void MapCanvas::actuallyPaintGL()
     setViewportAndMvp(width(), height());
 
     auto &gl = getOpenGL();
+
+    // Bind the appropriate FBO: multisampling if valid, otherwise resolved if valid, fallback to default
+    QOpenGLFramebufferObject *fboToBind = nullptr;
+    if (gl.getMultisamplingFbo() && gl.getMultisamplingFbo()->isValid()) {
+        fboToBind = gl.getMultisamplingFbo();
+    } else if (gl.getResolvedFbo() && gl.getResolvedFbo()->isValid()) {
+        fboToBind = gl.getResolvedFbo();
+    }
+
+    if (fboToBind) {
+        fboToBind->bind();
+    }
+
+    // Clear the FBO
     gl.clear(Color{getConfig().canvas.backgroundColor});
 
     if (m_data.isEmpty()) {
@@ -633,6 +656,14 @@ void MapCanvas::actuallyPaintGL()
     paintSelections();
     paintCharacters();
     paintDifferences();
+
+    // Unbind the FBO we rendered to
+    if (fboToBind) {
+        fboToBind->release();
+    }
+
+    // Blit from the resolved FBO to the default framebuffer (handles multisample resolve if needed)
+    gl.blitResolvedToDefault(size());
 }
 
 NODISCARD bool MapCanvas::Diff::isUpToDate(const Map &saved, const Map &current) const
@@ -1007,14 +1038,15 @@ void MapCanvas::paintSelectionArea()
 
 void MapCanvas::updateMultisampling()
 {
-    const int wantMultisampling = getConfig().canvas.antialiasingSamples;
+    const int wantMultisampling = getConfig().canvas.advanced.antialiasingSamples.get();
     std::optional<int> &activeStatus = m_graphicsOptionsStatus.multisampling;
     if (activeStatus == wantMultisampling) {
         return;
     }
 
-    // REVISIT: check return value?
-    MAYBE_UNUSED const bool enabled = getOpenGL().tryEnableMultisampling(wantMultisampling);
+    // Update the multisampling FBO in the OpenGL class
+    getOpenGL().setMultisamplingFbo(wantMultisampling, size());
+
     activeStatus = wantMultisampling;
 }
 
diff --git a/src/main.cpp b/src/main.cpp
@@ -93,8 +93,8 @@ static void setSurfaceFormat()
     // Probe for supported OpenGL versions
     QSurfaceFormat fmt = OpenGL::createDefaultSurfaceFormat();
 
-    const auto &config = getConfig().canvas;
-    fmt.setSamples(config.antialiasingSamples);
+    //const auto &config = getConfig().canvas;
+    //fmt.setSamples(config.advanced.antialiasingSamples.get());
     QSurfaceFormat::setDefaultFormat(fmt);
 }
 
diff --git a/src/opengl/OpenGL.cpp b/src/opengl/OpenGL.cpp
@@ -323,9 +323,146 @@ void OpenGL::setProjectionMatrix(const glm::mat4 &m)
     getFunctions().setProjectionMatrix(m);
 }
 
+void OpenGL::setMultisamplingFbo(int requestedSamples, const QSize &size)
+{
+    // Calculate physical size based on logical size and device pixel ratio
+    const float dpr = getDevicePixelRatio();
+    const QSize physicalSize(size.width() * static_cast<int>(dpr),
+                             size.height() * static_cast<int>(dpr));
+
+    // Always manage the resolved FBO if size is not empty
+    if (!physicalSize.isEmpty()) {
+        QOpenGLFramebufferObjectFormat resolvedFormat;
+        resolvedFormat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
+        resolvedFormat.setSamples(0); // Not multisampled
+        resolvedFormat.setTextureTarget(GL_TEXTURE_2D);
+        resolvedFormat.setInternalTextureFormat(GL_RGBA8);
+
+        if (!m_resolvedFbo || m_resolvedFbo->size() != physicalSize) {
+            m_resolvedFbo = std::make_unique<QOpenGLFramebufferObject>(physicalSize, resolvedFormat);
+            if (!m_resolvedFbo->isValid()) {
+                MMLOG_ERROR() << "Failed to create resolved FBO with physical size "
+                              << physicalSize.width() << "x" << physicalSize.height()
+                              << ". This may cause rendering issues.";
+                m_resolvedFbo.reset(); // Indicate failure
+            } else {
+                MMLOG_INFO() << "Created resolved FBO with physical size "
+                             << m_resolvedFbo->size().width() << "x"
+                             << m_resolvedFbo->size().height();
+            }
+        }
+    } else {
+        m_resolvedFbo.reset();
+        MMLOG_INFO() << "Resolved FBO destroyed (size empty)";
+    }
+
+    // Manage the multisampling FBO only if samples > 0 and size is not empty
+    if (requestedSamples > 0 && !physicalSize.isEmpty()) {
+        auto &gl = getFunctions();
+        GLint maxSamples = 0;
+        gl.glGetIntegerv(GL_MAX_SAMPLES, &maxSamples);
+        int actualSamples = std::min(requestedSamples, static_cast<int>(maxSamples));
+
+        if (actualSamples == 0 && requestedSamples > 0) {
+            MMLOG_WARNING() << "Requested " << requestedSamples
+                            << " samples, but max supported is 0. Disabling multisampling.";
+        } else if (actualSamples < requestedSamples) {
+            MMLOG_INFO() << "Requested " << requestedSamples << " samples, but using "
+                         << actualSamples << " (max supported).";
+        }
+
+        QOpenGLFramebufferObjectFormat msFormat;
+        msFormat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
+        msFormat.setSamples(actualSamples);
+        msFormat.setTextureTarget(GL_TEXTURE_2D_MULTISAMPLE);
+        msFormat.setInternalTextureFormat(GL_RGBA8);
+
+        if (!m_multisamplingFbo || m_multisamplingFbo->size() != physicalSize
+            || m_multisamplingFbo->format().samples() != actualSamples) {
+            m_multisamplingFbo = std::make_unique<QOpenGLFramebufferObject>(physicalSize, msFormat);
+            if (!m_multisamplingFbo->isValid()) {
+                MMLOG_ERROR() << "Failed to create multisampling FBO with " << actualSamples
+                              << " samples and physical size " << physicalSize.width() << "x"
+                              << physicalSize.height() << ". Falling back to no multisampling.";
+                m_multisamplingFbo.reset(); // Fallback
+            } else {
+                MMLOG_INFO() << "Created multisampling FBO with "
+                             << m_multisamplingFbo->format().samples()
+                             << " samples and physical size " << m_multisamplingFbo->size().width()
+                             << "x" << m_multisamplingFbo->size().height();
+            }
+        }
+    } else {
+        m_multisamplingFbo.reset();
+        MMLOG_INFO() << "Multisampling FBO destroyed (samples <= 0 or size empty)";
+    }
+}
+
+QOpenGLFramebufferObject *OpenGL::getRenderFbo() const
+{
+    // Render to the multisampling FBO if it's valid, otherwise render to the resolved FBO
+    if (m_multisamplingFbo && m_multisamplingFbo->isValid()) {
+        return m_multisamplingFbo.get();
+    }
+    // Fallback to resolved FBO (which should always be valid if size is not empty)
+    return m_resolvedFbo.get();
+}
+
+void OpenGL::bindMultisamplingFbo()
+{
+    if (m_multisamplingFbo) {
+        m_multisamplingFbo->bind();
+    }
+}
+
+void OpenGL::releaseMultisamplingFbo()
+{
+    if (m_multisamplingFbo) {
+        m_multisamplingFbo->release();
+    }
+}
+
+void OpenGL::blitResolvedToDefault(const QSize & /*size*/)
+{
+    if (!m_resolvedFbo || !m_resolvedFbo->isValid()) {
+        MMLOG_WARNING() << "Resolved FBO not valid for blitting. Skipping blit sequence.";
+        return;
+    }
+
+    // If multisampling FBO is valid, blit from it to the resolved FBO first
+    if (m_multisamplingFbo && m_multisamplingFbo->isValid()) {
+        QOpenGLFramebufferObject::blitFramebuffer(m_resolvedFbo.get(),
+                                                  m_multisamplingFbo.get(),
+                                                  GL_COLOR_BUFFER_BIT,
+                                                  GL_LINEAR); // Use GL_LINEAR for filtering during resolve
+    }
+    // Always blit from the resolved FBO to the default framebuffer (displays on screen)
+    QOpenGLFramebufferObject::blitFramebuffer(
+        nullptr, // Default framebuffer
+        m_resolvedFbo.get(),
+        GL_COLOR_BUFFER_BIT,
+        GL_NEAREST); // GL_NEAREST is usually fine for 1:1 blit to screen
+}
+
 bool OpenGL::tryEnableMultisampling(const int requestedSamples)
 {
-    return getFunctions().tryEnableMultisampling(requestedSamples);
+    // This function now primarily manages the GL_MULTISAMPLE state for the default framebuffer.
+    // The FBO handles the actual multisampling rendering.
+    auto &gl = getFunctions();
+    if (requestedSamples > 0) {
+        gl.glEnable(GL_MULTISAMPLE);
+        // The old smoothing hints might still be useful as a fallback or in conjunction,
+        // but the primary multisampling is now via FBO. We can keep them for now.
+        gl.glEnable(GL_LINE_SMOOTH);
+        gl.glDisable(GL_POLYGON_SMOOTH);
+        gl.glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
+        return true;
+    } else {
+        gl.glDisable(GL_MULTISAMPLE);
+        gl.glDisable(GL_LINE_SMOOTH);
+        gl.glDisable(GL_POLYGON_SMOOTH);
+        return false;
+    }
 }
 
 UniqueMesh OpenGL::createPointBatch(const std::vector<ColorVert> &batch)
diff --git a/src/opengl/OpenGL.h b/src/opengl/OpenGL.h
@@ -13,6 +13,7 @@
 
 #include <glm/glm.hpp>
 
+#include <QOpenGLFramebufferObject>
 #include <QSurfaceFormat>
 #include <qopengl.h>
 
@@ -27,6 +28,10 @@ class NODISCARD OpenGL final
     static std::string g_highest_reportable_version_string;
     std::shared_ptr<Legacy::Functions> m_opengl;
     bool m_rendererInitialized = false;
+    // Replaced raw multisampling FBO with QOpenGLFramebufferObject
+    std::unique_ptr<QOpenGLFramebufferObject> m_multisamplingFbo;
+    // Added resolved FBO using QOpenGLFramebufferObject
+    std::unique_ptr<QOpenGLFramebufferObject> m_resolvedFbo;
 
 private:
     NODISCARD auto &getFunctions() { return deref(m_opengl); }
@@ -65,6 +70,21 @@ class NODISCARD OpenGL final
 public:
     NODISCARD bool tryEnableMultisampling(int samples);
 
+public:
+    // Modified setMultisamplingFbo to handle QOpenGLFramebufferObject
+    void setMultisamplingFbo(int samples, const QSize &size);
+    // Modified bindMultisamplingFbo to use QOpenGLFramebufferObject
+    void bindMultisamplingFbo();
+    // Modified releaseMultisamplingFbo to use QOpenGLFramebufferObject
+    void releaseMultisamplingFbo();
+    // Removed blitMultisamplingFboToDefault as blitting will be handled differently
+
+    // Added a new function to perform the blit sequence
+    void blitResolvedToDefault(const QSize &size);
+
+    // Added function to get the FBO to render to
+    NODISCARD QOpenGLFramebufferObject *getRenderFbo() const;
+
 public:
     NODISCARD UniqueMesh createPointBatch(const std::vector<ColorVert> &verts);
 
@@ -162,4 +182,14 @@ class NODISCARD OpenGL final
 public:
     void cleanup();
     void setTextureLookup(MMTextureId, SharedMMTexture);
+
+public:
+    NODISCARD QOpenGLFramebufferObject *getMultisamplingFbo() const
+    {
+        return m_multisamplingFbo.get();
+    }
+    NODISCARD QOpenGLFramebufferObject *getResolvedFbo() const { return m_resolvedFbo.get(); }
+
+public:
+    void initArray(const SharedMMTexture &array, const std::vector<SharedMMTexture> &input);
 };
diff --git a/src/preferences/graphicspage.cpp b/src/preferences/graphicspage.cpp
@@ -49,7 +49,10 @@ GraphicsPage::GraphicsPage(QWidget *parent)
     connect(ui->antialiasingSamplesComboBox,
             &QComboBox::currentTextChanged,
             this,
-            &GraphicsPage::slot_antialiasingSamplesTextChanged);
+            [this](const QString &text) {
+                setConfig().canvas.advanced.antialiasingSamples.set(text.toInt());
+                graphicsSettingsChanged();
+            });
     connect(ui->trilinearFilteringCheckBox,
             &QCheckBox::stateChanged,
             this,
@@ -109,7 +112,7 @@ void GraphicsPage::slot_loadConfig()
     setIconColor(ui->darkLitPushButton, settings.roomDarkLitColor);
     setIconColor(ui->connectionNormalPushButton, settings.connectionNormalColor);
 
-    const QString antiAliasingSamples = QString::number(settings.antialiasingSamples);
+    const QString antiAliasingSamples = QString::number(settings.advanced.antialiasingSamples.get());
     const int index = utils::clampNonNegative(
         ui->antialiasingSamplesComboBox->findText(antiAliasingSamples));
     ui->antialiasingSamplesComboBox->setCurrentIndex(index);
@@ -133,12 +136,6 @@ void GraphicsPage::changeColorClicked(XNamedColor &namedColor, QPushButton *cons
     }
 }
 
-void GraphicsPage::slot_antialiasingSamplesTextChanged(const QString & /*unused*/)
-{
-    setConfig().canvas.antialiasingSamples = ui->antialiasingSamplesComboBox->currentText().toInt();
-    graphicsSettingsChanged();
-}
-
 void GraphicsPage::slot_trilinearFilteringStateChanged(int /*unused*/)
 {
     setConfig().canvas.trilinearFiltering = ui->trilinearFilteringCheckBox->isChecked();
diff --git a/src/preferences/graphicspage.h b/src/preferences/graphicspage.h
@@ -40,7 +40,6 @@ class NODISCARD_QOBJECT GraphicsPage final : public QWidget
 
 public slots:
     void slot_loadConfig();
-    void slot_antialiasingSamplesTextChanged(const QString &);
     void slot_trilinearFilteringStateChanged(int);
     void slot_drawNeedsUpdateStateChanged(int);
     void slot_drawNotMappedExitsStateChanged(int);

Original file line number	Diff line number	Diff line change
`@@ -93,8 +93,8 @@ static void setSurfaceFormat()`
`93`	`93`	`// Probe for supported OpenGL versions`
`94`	`94`	`QSurfaceFormat fmt = OpenGL::createDefaultSurfaceFormat();`
`95`	`95`
`96`		`- const auto &config = getConfig().canvas;`
`97`		`- fmt.setSamples(config.antialiasingSamples);`
	`96`	`+ //const auto &config = getConfig().canvas;`
	`97`	`+ //fmt.setSamples(config.advanced.antialiasingSamples.get());`
`98`	`98`	`QSurfaceFormat::setDefaultFormat(fmt);`
`99`	`99`	`}`
`100`	`100`