Remove remnants of separable shader setting (#6403)

src/android/app/src/main/jni/default_ini.h

@@ -106,10 +106,6 @@ graphics_api =
 # 0: Software, 1 (default): Hardware
 use_hw_shader =
 
-# Whether to use separable shaders to emulate 3DS shaders (macOS only)
-# 0: Off (Default), 1 : On
-separable_shader =
-
 # Whether to use accurate multiplication in hardware shaders
 # 0: Off (Default. Faster, but causes issues in some games) 1: On (Slower, but correct)
 shaders_accurate_mul =

src/citra/config.cpp

@@ -136,12 +136,6 @@ void Config::ReadValues() {
     ReadSetting("Renderer", Settings::values.graphics_api);
     ReadSetting("Renderer", Settings::values.use_gles);
     ReadSetting("Renderer", Settings::values.use_hw_shader);
-#ifdef __APPLE__
-    // Separable shader is broken on macos with Intel GPU thanks to poor drivers.
-    // We still want to provide this option for test/development purposes, but disable it by
-    // default.
-    ReadSetting("Renderer", Settings::values.separable_shader);
-#endif
     ReadSetting("Renderer", Settings::values.shaders_accurate_mul);
     ReadSetting("Renderer", Settings::values.use_shader_jit);
     ReadSetting("Renderer", Settings::values.resolution_factor);

src/citra/default_ini.h

@@ -110,10 +110,6 @@ use_gles =
 # 0: Software, 1 (default): Hardware
 use_hw_shader =
 
-# Whether to use separable shaders to emulate 3DS shaders (macOS only)
-# 0: Off (Default), 1 : On
-separable_shader =
-
 # Whether to use accurate multiplication in hardware shaders
 # 0: Off (Faster, but causes issues in some games) 1: On (Default. Slower, but correct)
 shaders_accurate_mul =

src/citra_qt/configuration/config.cpp

@@ -628,12 +628,6 @@ void Config::ReadRendererValues() {
 
     ReadGlobalSetting(Settings::values.graphics_api);
     ReadGlobalSetting(Settings::values.use_hw_shader);
-#ifdef __APPLE__
-    // Hardware shader is broken on macos with Intel GPUs thanks to poor drivers.
-    // We still want to provide this option for test/development purposes, but disable it by
-    // default.
-    ReadGlobalSetting(Settings::values.separable_shader);
-#endif
     ReadGlobalSetting(Settings::values.shaders_accurate_mul);
     ReadGlobalSetting(Settings::values.use_disk_shader_cache);
     ReadGlobalSetting(Settings::values.use_vsync_new);
@@ -1107,11 +1101,6 @@ void Config::SaveRendererValues() {
 
     WriteGlobalSetting(Settings::values.graphics_api);
     WriteGlobalSetting(Settings::values.use_hw_shader);
-#ifdef __APPLE__
-    // Hardware shader is broken on macos thanks to poor drivers.
-    // TODO: enable this for none Intel GPUs
-    WriteGlobalSetting(Settings::values.separable_shader);
-#endif
     WriteGlobalSetting(Settings::values.shaders_accurate_mul);
     WriteGlobalSetting(Settings::values.use_disk_shader_cache);
     WriteGlobalSetting(Settings::values.use_vsync_new);

src/citra_qt/configuration/configure_graphics.cpp

@@ -3,9 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <QColorDialog>
-#ifdef __APPLE__
-#include <QMessageBox>
-#endif
 #include "citra_qt/configuration/configuration_shared.h"
 #include "citra_qt/configuration/configure_graphics.h"
 #include "common/settings.h"
@@ -37,28 +34,6 @@ ConfigureGraphics::ConfigureGraphics(QWidget* parent)
         ui->toggle_disk_shader_cache->setEnabled(checked);
     });
 
-#ifdef __APPLE__
-    connect(ui->toggle_hw_shader, &QCheckBox::stateChanged, this, [this](int state) {
-        if (state == Qt::Checked) {
-            ui->toggle_separable_shader->setEnabled(true);
-        }
-    });
-    connect(ui->toggle_separable_shader, &QCheckBox::stateChanged, this, [this](int state) {
-        if (state == Qt::Checked) {
-            QMessageBox::warning(
-                this, tr("Hardware Shader Warning"),
-                tr("Separable Shader support is broken on macOS with Intel GPUs, and will cause "
-                   "graphical issues "
-                   "like showing a black screen.<br><br>The option is only there for "
-                   "test/development purposes. If you experience graphical issues with Hardware "
-                   "Shader, please turn it off."));
-        }
-    });
-#else
-    // TODO(B3N30): Hide this for macs with none Intel GPUs, too.
-    ui->toggle_separable_shader->setVisible(false);
-#endif
-
     SetupPerGameUI();
     SetConfiguration();
 }
@@ -77,7 +52,6 @@ void ConfigureGraphics::SetConfiguration() {
     }
 
     ui->toggle_hw_shader->setChecked(Settings::values.use_hw_shader.GetValue());
-    ui->toggle_separable_shader->setChecked(Settings::values.separable_shader.GetValue());
     ui->toggle_accurate_mul->setChecked(Settings::values.shaders_accurate_mul.GetValue());
     ui->toggle_disk_shader_cache->setChecked(Settings::values.use_disk_shader_cache.GetValue());
     ui->toggle_vsync_new->setChecked(Settings::values.use_vsync_new.GetValue());
@@ -92,8 +66,6 @@ void ConfigureGraphics::ApplyConfiguration() {
                                              ui->graphics_api_combo);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_hw_shader, ui->toggle_hw_shader,
                                              use_hw_shader);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.separable_shader,
-                                             ui->toggle_separable_shader, separable_shader);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.shaders_accurate_mul,
                                              ui->toggle_accurate_mul, shaders_accurate_mul);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_disk_shader_cache,
@@ -115,7 +87,6 @@ void ConfigureGraphics::SetupPerGameUI() {
     if (Settings::IsConfiguringGlobal()) {
         ui->graphics_api_group->setEnabled(Settings::values.graphics_api.UsingGlobal());
         ui->toggle_hw_shader->setEnabled(Settings::values.use_hw_shader.UsingGlobal());
-        ui->toggle_separable_shader->setEnabled(Settings::values.separable_shader.UsingGlobal());
         ui->toggle_accurate_mul->setEnabled(Settings::values.shaders_accurate_mul.UsingGlobal());
         ui->toggle_disk_shader_cache->setEnabled(
             Settings::values.use_disk_shader_cache.UsingGlobal());
@@ -132,8 +103,6 @@ void ConfigureGraphics::SetupPerGameUI() {
 
     ConfigurationShared::SetColoredTristate(ui->toggle_hw_shader, Settings::values.use_hw_shader,
                                             use_hw_shader);
-    ConfigurationShared::SetColoredTristate(ui->toggle_separable_shader,
-                                            Settings::values.separable_shader, separable_shader);
     ConfigurationShared::SetColoredTristate(
         ui->toggle_accurate_mul, Settings::values.shaders_accurate_mul, shaders_accurate_mul);
     ConfigurationShared::SetColoredTristate(ui->toggle_disk_shader_cache,

src/citra_qt/configuration/configure_graphics.h

@@ -32,7 +32,6 @@ private:
     void SetupPerGameUI();
 
     ConfigurationShared::CheckState use_hw_shader;
-    ConfigurationShared::CheckState separable_shader;
     ConfigurationShared::CheckState shaders_accurate_mul;
     ConfigurationShared::CheckState use_disk_shader_cache;
     ConfigurationShared::CheckState use_vsync_new;

src/citra_qt/configuration/configure_graphics.ui

@@ -114,13 +114,6 @@
             <property name="bottomMargin">
              <number>0</number>
             </property>
-            <item>
-             <widget class="QCheckBox" name="toggle_separable_shader">
-              <property name="text">
-               <string>Separable Shader (Intel GPUs only)</string>
-              </property>
-             </widget>
-            </item>
             <item>
              <widget class="QCheckBox" name="toggle_accurate_mul">
               <property name="toolTip">
@@ -195,7 +188,6 @@
   </layout>
  </widget>
  <tabstops>
-  <tabstop>toggle_separable_shader</tabstop>
   <tabstop>toggle_accurate_mul</tabstop>
   <tabstop>toggle_shader_jit</tabstop>
   <tabstop>toggle_disk_shader_cache</tabstop>

src/common/settings.cpp

@@ -70,7 +70,6 @@ void Apply() {
 
     VideoCore::g_shader_jit_enabled = values.use_shader_jit.GetValue();
     VideoCore::g_hw_shader_enabled = values.use_hw_shader.GetValue();
-    VideoCore::g_separable_shader_enabled = values.separable_shader.GetValue();
     VideoCore::g_hw_shader_accurate_mul = values.shaders_accurate_mul.GetValue();
 
 #ifndef ANDROID
@@ -135,7 +134,6 @@ void LogSettings() {
     log_setting("Renderer_GraphicsAPI", GetGraphicsAPIName(values.graphics_api.GetValue()));
     log_setting("Renderer_Debug", values.renderer_debug.GetValue());
     log_setting("Renderer_UseHwShader", values.use_hw_shader.GetValue());
-    log_setting("Renderer_SeparableShader", values.separable_shader.GetValue());
     log_setting("Renderer_ShadersAccurateMul", values.shaders_accurate_mul.GetValue());
     log_setting("Renderer_UseShaderJit", values.use_shader_jit.GetValue());
     log_setting("Renderer_UseResolutionFactor", values.resolution_factor.GetValue());
@@ -220,7 +218,6 @@ void RestoreGlobalState(bool is_powered_on) {
     // Renderer
     values.graphics_api.SetGlobal(true);
     values.use_hw_shader.SetGlobal(true);
-    values.separable_shader.SetGlobal(true);
     values.use_disk_shader_cache.SetGlobal(true);
     values.shaders_accurate_mul.SetGlobal(true);
     values.use_vsync_new.SetGlobal(true);

src/common/settings.h

@@ -433,7 +433,6 @@ struct Values {
     Setting<bool> use_gles{false, "use_gles"};
     Setting<bool> renderer_debug{false, "renderer_debug"};
     SwitchableSetting<bool> use_hw_shader{true, "use_hw_shader"};
-    SwitchableSetting<bool> separable_shader{false, "use_separable_shader"};
     SwitchableSetting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
     SwitchableSetting<bool> shaders_accurate_mul{true, "shaders_accurate_mul"};
     SwitchableSetting<bool> use_vsync_new{true, "use_vsync_new"};

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -173,18 +173,8 @@ RasterizerOpenGL::RasterizerOpenGL(Memory::MemorySystem& memory, VideoCore::Rend
     state.Apply();
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer.GetHandle());
 
-#ifdef __APPLE__
-    if (driver.GetVendor() == Vendor::Intel) {
-        shader_program_manager = std::make_unique<ShaderProgramManager>(
-            renderer.GetRenderWindow(), driver, VideoCore::g_separable_shader_enabled);
-    } else {
-        shader_program_manager =
-            std::make_unique<ShaderProgramManager>(renderer.GetRenderWindow(), driver, true);
-    }
-#else
     shader_program_manager =
         std::make_unique<ShaderProgramManager>(renderer.GetRenderWindow(), driver, !GLES);
-#endif
 
     glEnable(GL_BLEND);
 

src/video_core/video_core.cpp

@@ -24,7 +24,6 @@ std::unique_ptr<RendererBase> g_renderer{}; ///< Renderer plugin
 
 std::atomic<bool> g_shader_jit_enabled;
 std::atomic<bool> g_hw_shader_enabled;
-std::atomic<bool> g_separable_shader_enabled;
 std::atomic<bool> g_hw_shader_accurate_mul;
 
 Memory::MemorySystem* g_memory;

src/video_core/video_core.h

@@ -35,7 +35,6 @@ extern std::unique_ptr<RendererBase> g_renderer; ///< Renderer plugin
 // qt ui)
 extern std::atomic<bool> g_shader_jit_enabled;
 extern std::atomic<bool> g_hw_shader_enabled;
-extern std::atomic<bool> g_separable_shader_enabled;
 extern std::atomic<bool> g_hw_shader_accurate_mul;
 
 extern Memory::MemorySystem* g_memory;