PostProcessing: Refactor config to use separate sections

src/duckstation-qt/postprocessingsettingswidget.cpp

@@ -1,10 +1,20 @@
-// SPDX-FileCopyrightText: 2019-2022 Connor McLaughlin <stenzek@gmail.com>
+// SPDX-FileCopyrightText: 2019-2023 Connor McLaughlin <stenzek@gmail.com>
 // SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
 
 #include "postprocessingsettingswidget.h"
 #include "qthost.h"
 #include "settingwidgetbinder.h"
+
+#include "util/postprocessing.h"
+
+#include "common/error.h"
+
+#include <QtWidgets/QCheckBox>
+#include <QtWidgets/QDialogButtonBox>
+#include <QtWidgets/QGridLayout>
+#include <QtWidgets/QLabel>
 #include <QtWidgets/QMessageBox>
+#include <QtWidgets/QSlider>
 
 PostProcessingSettingsWidget::PostProcessingSettingsWidget(SettingsDialog* dialog, QWidget* parent)
   : QWidget(parent), m_dialog(dialog)
@@ -12,53 +22,101 @@ PostProcessingSettingsWidget::PostProcessingSettingsWidget(SettingsDialog* dialo
   SettingsInterface* sif = dialog->getSettingsInterface();
 
   m_ui.setupUi(this);
-  m_ui.widget->setOptionsButtonVisible(false);
-  m_ui.reload->setEnabled(false);
-  updateShaderConfigPanel(-1);
+
+  SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.enablePostProcessing, "PostProcessing", "Enabled", false);
+
+  updateList();
+  updateButtonsAndConfigPane(std::nullopt);
   connectUi();
-
-  SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.enablePostProcessing, "Display", "PostProcessing", false);
-
-  std::string post_chain = m_dialog->getStringValue("Display", "PostProcessChain", "").value_or(std::string());
-  if (!post_chain.empty())
-  {
-    if (!m_ui.widget->setConfigString(post_chain))
-    {
-      QMessageBox::critical(this, tr("Error"), tr("The current post-processing chain is invalid, it has been reset."));
-      m_dialog->removeSettingValue("Display", "PostProcessChain");
-    }
-    else
-    {
-      m_ui.reload->setEnabled(true);
-    }
-  }
 }
 
 PostProcessingSettingsWidget::~PostProcessingSettingsWidget() = default;
 
+SettingsInterface& PostProcessingSettingsWidget::getSettingsInterfaceToUpdate()
+{
+  return m_dialog->isPerGameSettings() ? *m_dialog->getSettingsInterface() : *Host::Internal::GetBaseSettingsLayer();
+}
+
+void PostProcessingSettingsWidget::commitSettingsUpdate()
+{
+  if (m_dialog->isPerGameSettings())
+    m_dialog->getSettingsInterface()->Save();
+  else
+    Host::CommitBaseSettingChanges();
+
+  g_emu_thread->updatePostProcessingSettings();
+}
+
 void PostProcessingSettingsWidget::connectUi()
 {
-  connect(m_ui.reload, &QPushButton::clicked, this, &PostProcessingSettingsWidget::onReloadClicked);
-  connect(m_ui.widget, &PostProcessingChainConfigWidget::chainAboutToChange, this,
-          &PostProcessingSettingsWidget::onChainAboutToChange);
-  connect(m_ui.widget, &PostProcessingChainConfigWidget::selectedShaderChanged, this,
-          &PostProcessingSettingsWidget::onChainSelectedShaderChanged);
-  connect(m_ui.widget, &PostProcessingChainConfigWidget::chainConfigStringChanged, this,
-          &PostProcessingSettingsWidget::onConfigChanged);
+  connect(m_ui.reload, &QPushButton::clicked, this, &PostProcessingSettingsWidget::onReloadButtonClicked);
+  connect(m_ui.add, &QToolButton::clicked, this, &PostProcessingSettingsWidget::onAddButtonClicked);
+  connect(m_ui.remove, &QToolButton::clicked, this, &PostProcessingSettingsWidget::onRemoveButtonClicked);
+  connect(m_ui.clear, &QToolButton::clicked, this, &PostProcessingSettingsWidget::onClearButtonClicked);
+  connect(m_ui.moveUp, &QToolButton::clicked, this, &PostProcessingSettingsWidget::onMoveUpButtonClicked);
+  connect(m_ui.moveDown, &QToolButton::clicked, this, &PostProcessingSettingsWidget::onMoveDownButtonClicked);
+  connect(m_ui.stages, &QListWidget::itemSelectionChanged, this,
+          &PostProcessingSettingsWidget::onSelectedShaderChanged);
 }
 
-void PostProcessingSettingsWidget::onChainAboutToChange()
+std::optional<u32> PostProcessingSettingsWidget::getSelectedIndex() const
 {
-  updateShaderConfigPanel(-1);
+  QList<QListWidgetItem*> selected_items = m_ui.stages->selectedItems();
+  return selected_items.empty() ? std::nullopt :
+                                  std::optional<u32>(selected_items.first()->data(Qt::UserRole).toUInt());
 }
 
-void PostProcessingSettingsWidget::onChainSelectedShaderChanged(qint32 index)
+void PostProcessingSettingsWidget::selectIndex(s32 index)
 {
-  updateShaderConfigPanel(index);
+  if (index < 0 || index >= m_ui.stages->count())
+    return;
+
+  QSignalBlocker sb(m_ui.stages);
+  m_ui.stages->setCurrentItem(m_ui.stages->item(index));
+  updateButtonsAndConfigPane(index);
 }
 
-void PostProcessingSettingsWidget::updateShaderConfigPanel(s32 index)
+void PostProcessingSettingsWidget::updateList()
 {
+  const auto lock = Host::GetSettingsLock();
+  const SettingsInterface& si = getSettingsInterfaceToUpdate();
+
+  updateList(si);
+}
+
+void PostProcessingSettingsWidget::updateList(const SettingsInterface& si)
+{
+  m_ui.stages->clear();
+
+  const u32 stage_count = PostProcessing::Config::GetStageCount(si);
+
+  for (u32 i = 0; i < stage_count; i++)
+  {
+    const std::string stage_name = PostProcessing::Config::GetStageShaderName(si, i);
+    QListWidgetItem* item = new QListWidgetItem(QString::fromStdString(stage_name), m_ui.stages);
+    item->setData(Qt::UserRole, QVariant(i));
+  }
+
+  m_ui.clear->setEnabled(stage_count > 0);
+  m_ui.reload->setEnabled(stage_count > 0);
+  updateButtonsAndConfigPane(std::nullopt);
+}
+
+void PostProcessingSettingsWidget::updateButtonsAndConfigPane(std::optional<u32> index)
+{
+  m_ui.remove->setEnabled(index.has_value());
+
+  if (index.has_value())
+  {
+    m_ui.moveUp->setEnabled(index.value() > 0);
+    m_ui.moveDown->setEnabled(index.value() < static_cast<u32>(m_ui.stages->count() - 1));
+  }
+  else
+  {
+    m_ui.moveUp->setEnabled(false);
+    m_ui.moveDown->setEnabled(false);
+  }
+
   m_ui.scrollArea->setWidget(nullptr);
   m_ui.scrollArea->setVisible(false);
 
@@ -68,35 +126,282 @@ void PostProcessingSettingsWidget::updateShaderConfigPanel(s32 index)
     m_shader_config = nullptr;
   }
 
-  if (index < 0)
+  if (!index.has_value())
     return;
 
-  PostProcessingShader* shader = m_ui.widget->getChain().GetShaderStage(static_cast<u32>(index));
-  if (!shader->HasOptions())
+  const auto lock = Host::GetSettingsLock();
+  const SettingsInterface& si = getSettingsInterfaceToUpdate();
+  std::vector<PostProcessing::ShaderOption> options = PostProcessing::Config::GetStageOptions(si, index.value());
+  if (options.empty())
     return;
 
-  m_shader_config = new PostProcessingShaderConfigWidget(m_ui.scrollArea, shader);
-  connect(m_shader_config, &PostProcessingShaderConfigWidget::configChanged,
-          [this]() { onConfigChanged(m_ui.widget->getChain().GetConfigString()); });
+  m_shader_config = new PostProcessingShaderConfigWidget(m_ui.scrollArea, this, index.value(), std::move(options));
   m_ui.scrollArea->setWidget(m_shader_config);
   m_ui.scrollArea->setVisible(true);
 }
 
-void PostProcessingSettingsWidget::onConfigChanged(const std::string& new_config)
+void PostProcessingSettingsWidget::onAddButtonClicked()
 {
-  if (new_config.empty())
+  QMenu menu;
+
+  const std::vector<std::pair<std::string, std::string>> shaders = PostProcessing::GetAvailableShaderNames();
+  if (shaders.empty())
   {
-    m_dialog->removeSettingValue("Display", "PostProcessChain");
-    m_ui.reload->setEnabled(false);
+    menu.addAction(tr("No Shaders Available"))->setEnabled(false);
   }
   else
   {
-    m_dialog->setStringSettingValue("Display", "PostProcessChain", new_config.c_str());
-    m_ui.reload->setEnabled(true);
+    for (auto& [display_name, name] : shaders)
+    {
+      QAction* action = menu.addAction(QString::fromStdString(display_name));
+      connect(action, &QAction::triggered, [this, shader = std::move(name)]() {
+        auto lock = Host::GetSettingsLock();
+        SettingsInterface& si = getSettingsInterfaceToUpdate();
+
+        Error error;
+        if (!PostProcessing::Config::AddStage(si, shader, &error))
+        {
+          lock.unlock();
+          QMessageBox::critical(this, tr("Error"),
+                                tr("Failed to add shader: %1").arg(QString::fromStdString(error.GetDescription())));
+          return;
+        }
+
+        updateList(si);
+        lock.unlock();
+        commitSettingsUpdate();
+      });
+    }
+  }
+
+  menu.exec(QCursor::pos());
+}
+
+void PostProcessingSettingsWidget::onRemoveButtonClicked()
+{
+  QList<QListWidgetItem*> selected_items = m_ui.stages->selectedItems();
+  if (selected_items.empty())
+    return;
+
+  auto lock = Host::GetSettingsLock();
+  SettingsInterface& si = getSettingsInterfaceToUpdate();
+
+  QListWidgetItem* item = selected_items.first();
+  u32 index = item->data(Qt::UserRole).toUInt();
+  if (index < PostProcessing::Config::GetStageCount(si))
+  {
+    PostProcessing::Config::RemoveStage(si, index);
+    updateList(si);
+    lock.unlock();
+    commitSettingsUpdate();
   }
 }
 
-void PostProcessingSettingsWidget::onReloadClicked()
+void PostProcessingSettingsWidget::onClearButtonClicked()
+{
+  if (QMessageBox::question(this, tr("Question"), tr("Are you sure you want to clear all shader stages?"),
+                            QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes)
+  {
+    auto lock = Host::GetSettingsLock();
+    SettingsInterface& si = getSettingsInterfaceToUpdate();
+    PostProcessing::Config::ClearStages(si);
+    updateList(si);
+    lock.unlock();
+    commitSettingsUpdate();
+  }
+}
+
+void PostProcessingSettingsWidget::onMoveUpButtonClicked()
+{
+  std::optional<u32> index = getSelectedIndex();
+  if (index.has_value() && index.value() > 0)
+  {
+    auto lock = Host::GetSettingsLock();
+    SettingsInterface& si = getSettingsInterfaceToUpdate();
+    PostProcessing::Config::MoveStageUp(si, index.value());
+    updateList(si);
+    lock.unlock();
+    selectIndex(index.value() - 1);
+    commitSettingsUpdate();
+  }
+}
+
+void PostProcessingSettingsWidget::onMoveDownButtonClicked()
+{
+  std::optional<u32> index = getSelectedIndex();
+  if (index.has_value() || index.value() < (static_cast<u32>(m_ui.stages->count() - 1)))
+  {
+    auto lock = Host::GetSettingsLock();
+    SettingsInterface& si = getSettingsInterfaceToUpdate();
+    PostProcessing::Config::MoveStageDown(si, index.value());
+    updateList(si);
+    lock.unlock();
+    selectIndex(index.value() + 1);
+    commitSettingsUpdate();
+  }
+}
+
+void PostProcessingSettingsWidget::onReloadButtonClicked()
 {
   g_emu_thread->reloadPostProcessingShaders();
 }
+
+void PostProcessingSettingsWidget::onSelectedShaderChanged()
+{
+  std::optional<u32> index = getSelectedIndex();
+  updateButtonsAndConfigPane(index);
+}
+
+PostProcessingShaderConfigWidget::PostProcessingShaderConfigWidget(QWidget* parent,
+                                                                   PostProcessingSettingsWidget* widget,
+                                                                   u32 stage_index,
+                                                                   std::vector<PostProcessing::ShaderOption> options)
+  : QWidget(parent), m_widget(widget), m_stage_index(stage_index), m_options(std::move(options))
+{
+  m_layout = new QGridLayout(this);
+
+  createUi();
+}
+
+PostProcessingShaderConfigWidget::~PostProcessingShaderConfigWidget() = default;
+
+void PostProcessingShaderConfigWidget::updateConfigForOption(const PostProcessing::ShaderOption& option)
+{
+  const auto lock = Host::GetSettingsLock();
+  SettingsInterface& si = m_widget->getSettingsInterfaceToUpdate();
+  PostProcessing::Config::SetStageOption(si, m_stage_index, option);
+  m_widget->commitSettingsUpdate();
+}
+
+void PostProcessingShaderConfigWidget::onResetDefaultsClicked()
+{
+  {
+    const auto lock = Host::GetSettingsLock();
+    SettingsInterface& si = m_widget->getSettingsInterfaceToUpdate();
+    for (PostProcessing::ShaderOption& option : m_options)
+    {
+      if (std::memcmp(option.value.data(), option.default_value.data(), sizeof(option.value)) == 0)
+        continue;
+
+      option.value = option.default_value;
+      PostProcessing::Config::UnsetStageOption(si, m_stage_index, option);
+    }
+    m_widget->commitSettingsUpdate();
+  }
+
+  // Toss and recreate UI.
+  for (auto it = m_widgets.rbegin(); it != m_widgets.rend(); ++it)
+  {
+    m_layout->removeWidget(*it);
+    delete *it;
+  }
+  m_widgets.clear();
+  createUi();
+}
+
+void PostProcessingShaderConfigWidget::createUi()
+{
+  u32 row = 0;
+
+  for (PostProcessing::ShaderOption& option : m_options)
+  {
+    if (option.ui_name.empty())
+      continue;
+
+    if (option.type == PostProcessing::ShaderOption::Type::Bool)
+    {
+      QCheckBox* checkbox = new QCheckBox(QString::fromStdString(option.ui_name), this);
+      checkbox->setChecked(option.value[0].int_value != 0);
+      connect(checkbox, &QCheckBox::stateChanged, [this, &option](int state) {
+        option.value[0].int_value = (state == Qt::Checked) ? 1 : 0;
+        updateConfigForOption(option);
+      });
+      m_layout->addWidget(checkbox, row, 0, 1, 3, Qt::AlignLeft);
+      m_widgets.push_back(checkbox);
+      row++;
+    }
+    else
+    {
+      for (u32 i = 0; i < option.vector_size; i++)
+      {
+        QString label;
+        if (option.vector_size <= 1)
+        {
+          label = QString::fromStdString(option.ui_name);
+        }
+        else
+        {
+          static constexpr std::array<const char*, PostProcessing::ShaderOption::MAX_VECTOR_COMPONENTS + 1> suffixes = {
+            {QT_TR_NOOP("Red"), QT_TR_NOOP("Green"), QT_TR_NOOP("Blue"), QT_TR_NOOP("Alpha")}};
+          label = tr("%1 (%2)").arg(QString::fromStdString(option.ui_name)).arg(tr(suffixes[i]));
+        }
+
+        QWidget* label_w = new QLabel(label, this);
+        m_layout->addWidget(label_w, row, 0, 1, 1, Qt::AlignLeft);
+        m_widgets.push_back(label_w);
+
+        QSlider* slider = new QSlider(Qt::Horizontal, this);
+        m_layout->addWidget(slider, row, 1, 1, 1, Qt::AlignLeft);
+        m_widgets.push_back(slider);
+
+        QLabel* slider_label = new QLabel(this);
+        m_layout->addWidget(slider_label, row, 2, 1, 1, Qt::AlignLeft);
+        m_widgets.push_back(slider_label);
+
+        if (option.type == PostProcessing::ShaderOption::Type::Int)
+        {
+          slider_label->setText(QString::number(option.value[i].int_value));
+
+          const int range = option.max_value[i].int_value - option.min_value[i].int_value;
+          const int step_value =
+            (option.step_value[i].int_value != 0) ? option.step_value[i].int_value : ((range + 99) / 100);
+          const int num_steps = range / step_value;
+          slider->setMinimum(0);
+          slider->setMaximum(num_steps);
+          slider->setSingleStep(1);
+          slider->setTickInterval(step_value);
+          slider->setValue((option.value[i].int_value - option.min_value[i].int_value) / step_value);
+          connect(slider, &QSlider::valueChanged, [this, &option, i, slider_label](int value) {
+            const int new_value = std::clamp(option.min_value[i].int_value + (value * option.step_value[i].int_value),
+                                             option.min_value[i].int_value, option.max_value[i].int_value);
+            option.value[i].int_value = new_value;
+            slider_label->setText(QString::number(new_value));
+            updateConfigForOption(option);
+          });
+        }
+        else
+        {
+          slider_label->setText(QString::number(option.value[i].float_value));
+
+          const float range = option.max_value[i].float_value - option.min_value[i].float_value;
+          const float step_value =
+            (option.step_value[i].float_value != 0) ? option.step_value[i].float_value : ((range + 99.0f) / 100.0f);
+          const float num_steps = std::ceil(range / step_value);
+          slider->setMinimum(0);
+          slider->setMaximum(num_steps);
+          slider->setSingleStep(1);
+          slider->setTickInterval(step_value);
+          slider->setValue(
+            static_cast<int>((option.value[i].float_value - option.min_value[i].float_value) / step_value));
+          connect(slider, &QSlider::valueChanged, [this, &option, i, slider_label](int value) {
+            const float new_value = std::clamp(option.min_value[i].float_value +
+                                                 (static_cast<float>(value) * option.step_value[i].float_value),
+                                               option.min_value[i].float_value, option.max_value[i].float_value);
+            option.value[i].float_value = new_value;
+            slider_label->setText(QString::number(new_value));
+            updateConfigForOption(option);
+          });
+        }
+
+        row++;
+      }
+    }
+  }
+
+  QDialogButtonBox* button_box = new QDialogButtonBox(QDialogButtonBox::RestoreDefaults, this);
+  connect(button_box, &QDialogButtonBox::clicked, this, &PostProcessingShaderConfigWidget::onResetDefaultsClicked);
+  m_layout->addWidget(button_box, row, 0, 1, -1);
+
+  row++;
+  m_layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::Expanding), row, 0, 1, 3);
+}