AudioRendererParameters should be AudioRendererParameter according to SMO

According to game symbols(SMO), there's references to UpdateDataHeader which seems to be what AudioRendererResponse actually is

CMakeLists.txt

@@ -124,7 +124,7 @@ else()
     # /EHsc - C++-only exception handling semantics
     # /Zc:throwingNew - let codegen assume `operator new` will never return null
     # /Zc:inline - let codegen omit inline functions in object files
-    set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} /EHsc /std:c++latest /Zc:throwingNew,inline" CACHE STRING "" FORCE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} /EHsc /Zc:throwingNew,inline" CACHE STRING "" FORCE)
 
     # /MDd - Multi-threaded Debug Runtime DLL
     set(CMAKE_C_FLAGS_DEBUG   "/Od /MDd" CACHE STRING "" FORCE)

CMakeModules/CopyYuzuQt5Deps.cmake

@@ -1,6 +1,6 @@
 function(copy_yuzu_Qt5_deps target_dir)
     include(WindowsCopyFiles)
-    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
+    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/")
     set(Qt5_DLL_DIR "${Qt5_DIR}/../../../bin")
     set(Qt5_PLATFORMS_DIR "${Qt5_DIR}/../../../plugins/platforms/")
     set(PLATFORMS ${DLL_DEST}platforms/)

CMakeModules/CopyYuzuSDLDeps.cmake

@@ -1,5 +1,5 @@
 function(copy_yuzu_SDL_deps target_dir)
     include(WindowsCopyFiles)
-    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
+    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/")
     windows_copy_files(${target_dir} ${SDL2_DLL_DIR} ${DLL_DEST} SDL2.dll)
 endfunction(copy_yuzu_SDL_deps)

CMakeModules/CopyYuzuUnicornDeps.cmake

@@ -1,6 +1,6 @@
 function(copy_yuzu_unicorn_deps target_dir)
     include(WindowsCopyFiles)
-    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
+    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/")
     windows_copy_files(${target_dir} ${UNICORN_DLL_DIR} ${DLL_DEST}
         libgcc_s_seh-1.dll
         libwinpthread-1.dll

appveyor.yml

@@ -36,12 +36,20 @@ install:
         }
 
 before_build:
+  # Install Ninja
+  - set NINJA_URL="https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-win.zip"
+  - appveyor DownloadFile %NINJA_URL% -FileName ninja.zip
+  - 7z x ninja.zip -oC:\projects\deps\ninja > nul
+  - set PATH=C:\projects\deps\ninja;%PATH%
+  - ninja --version
+  - call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat" x64
+
   - mkdir %BUILD_TYPE%_build
   - cd %BUILD_TYPE%_build
   - ps: |
         if ($env:BUILD_TYPE -eq 'msvc') {
           # redirect stderr and change the exit code to prevent powershell from cancelling the build if cmake prints a warning
-          cmd /C 'cmake -G "Visual Studio 15 2017 Win64" -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 .. 2>&1 && exit 0'
+          cmd /C 'cmake -G "Ninja" -DCMAKE_BUILD_TYPE=Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 .. 2>&1 && exit 0'
         } else {
           C:\msys64\usr\bin\bash.exe -lc "cmake -G 'MSYS Makefiles' -DYUZU_BUILD_UNICORN=1 -DCMAKE_BUILD_TYPE=Release .. 2>&1"
         }
@@ -51,7 +59,7 @@ build_script:
   - ps: |
         if ($env:BUILD_TYPE -eq 'msvc') {
           # https://www.appveyor.com/docs/build-phase
-          msbuild msvc_build/yuzu.sln /maxcpucount /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
+          ninja -C msvc_build
         } else {
           C:\msys64\usr\bin\bash.exe -lc 'mingw32-make -C mingw_build/ 2>&1'
         }
@@ -80,7 +88,7 @@ after_build:
           $env:BUILD_SYMBOLS = $MSVC_BUILD_PDB
           $env:BUILD_UPDATE = $MSVC_SEVENZIP
 
-          $BUILD_DIR = ".\msvc_build\bin\Release"
+          $BUILD_DIR = ".\msvc_build\bin"
 
           # Make a debug symbol upload
           mkdir pdb

externals/cmake-modules/WindowsCopyFiles.cmake

@@ -22,7 +22,7 @@ function(windows_copy_files TARGET SOURCE_DIR DEST_DIR)
     # cmake adds an extra check for command success which doesn't work too well with robocopy
     # so trick it into thinking the command was successful with the || cmd /c "exit /b 0"
     add_custom_command(TARGET ${TARGET} POST_BUILD
-        COMMAND if not exist ${DEST_DIR} mkdir ${DEST_DIR} 2> nul
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${DEST_DIR}
         COMMAND robocopy ${SOURCE_DIR} ${DEST_DIR} ${ARGN} /NJH /NJS /NDL /NFL /NC /NS /NP || cmd /c "exit /b 0"
     )
-endfunction()
+endfunction()

src/common/assert.h

@@ -28,12 +28,19 @@ __declspec(noinline, noreturn)
 }
 
 #define ASSERT(_a_)                                                                                \
-    if (!(_a_)) {                                                                                  \
-    }
+    do                                                                                             \
+        if (!(_a_)) {                                                                              \
+            assert_noinline_call([] { NGLOG_CRITICAL(Debug, "Assertion Failed!"); });              \
+        }                                                                                          \
+    while (0)
 
 #define ASSERT_MSG(_a_, ...)                                                                       \
-    if (!(_a_)) {                                                                                  \
-    }
+    do                                                                                             \
+        if (!(_a_)) {                                                                              \
+            assert_noinline_call(                                                                  \
+                [&] { NGLOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__); });                \
+        }                                                                                          \
+    while (0)
 
 #define UNREACHABLE() ASSERT_MSG(false, "Unreachable code!")
 #define UNREACHABLE_MSG(...) ASSERT_MSG(false, __VA_ARGS__)

src/core/hle/service/audio/audren_u.cpp

@@ -150,7 +150,7 @@ private:
         UpdateDataHeader() {}
 
         UpdateDataHeader(const AudioRendererParameter& config) {
-            revision = Common::MakeMagic('R', 'E', 'V', '4'); // 5.1.0 Revision
+            revision = config.revision;
             behavior_size = 0xb0;
             memory_pools_size = (config.effect_count + (config.voice_count * 4)) * 0x10;
             voices_size = config.voice_count * 0x10;

src/video_core/debug_utils/debug_utils.h

@@ -55,10 +55,8 @@ public:
         virtual ~BreakPointObserver() {
             auto context = context_weak.lock();
             if (context) {
-                {
-                    std::unique_lock<std::mutex> lock(context->breakpoint_mutex);
-                    context->breakpoint_observers.remove(this);
-                }
+                std::unique_lock<std::mutex> lock(context->breakpoint_mutex);
+                context->breakpoint_observers.remove(this);
 
                 // If we are the last observer to be destroyed, tell the debugger context that
                 // it is free to continue. In particular, this is required for a proper yuzu

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -197,8 +197,8 @@ void RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr buffer_offset) {
     ASSERT_MSG(!gpu.regs.shader_config[0].enable, "VertexA is unsupported!");
 
     // Next available bindpoints to use when uploading the const buffers and textures to the GLSL
-    // shaders. The constbuffer bindpoint starts after the shader stage configuration bind points.
-    u32 current_constbuffer_bindpoint = uniform_buffers.size();
+    // shaders.
+    u32 current_constbuffer_bindpoint = 0;
     u32 current_texture_bindpoint = 0;
 
     for (unsigned index = 1; index < Maxwell::MaxShaderProgram; ++index) {
@@ -437,7 +437,7 @@ void RasterizerOpenGL::DrawArrays() {
 
     // Unbind textures for potential future use as framebuffer attachments
     for (auto& texture_unit : state.texture_units) {
-        texture_unit.Unbind();
+        texture_unit.texture_2d = 0;
     }
     state.Apply();
 
@@ -608,39 +608,27 @@ u32 RasterizerOpenGL::SetupConstBuffers(Maxwell::ShaderStage stage, GLuint progr
 
         boost::optional<VAddr> addr = gpu.memory_manager->GpuToCpuAddress(buffer.address);
 
-        size_t size = 0;
-
+        std::vector<u8> data;
         if (used_buffer.IsIndirect()) {
             // Buffer is accessed indirectly, so upload the entire thing
-            size = buffer.size * sizeof(float);
-
-            if (size > MaxConstbufferSize) {
-                NGLOG_ERROR(HW_GPU, "indirect constbuffer size {} exceeds maximum {}", size,
-                            MaxConstbufferSize);
-                size = MaxConstbufferSize;
-            }
+            data.resize(buffer.size * sizeof(float));
         } else {
             // Buffer is accessed directly, upload just what we use
-            size = used_buffer.GetSize() * sizeof(float);
+            data.resize(used_buffer.GetSize() * sizeof(float));
         }
 
-        // Align the actual size so it ends up being a multiple of vec4 to meet the OpenGL std140
-        // UBO alignment requirements.
-        size = Common::AlignUp(size, sizeof(GLvec4));
-        ASSERT_MSG(size <= MaxConstbufferSize, "Constbuffer too big");
-
-        std::vector<u8> data(size);
         Memory::ReadBlock(*addr, data.data(), data.size());
 
-        glBindBuffer(GL_UNIFORM_BUFFER, buffer_draw_state.ssbo);
-        glBufferData(GL_UNIFORM_BUFFER, data.size(), data.data(), GL_DYNAMIC_DRAW);
-        glBindBuffer(GL_UNIFORM_BUFFER, 0);
+        glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer_draw_state.ssbo);
+        glBufferData(GL_SHADER_STORAGE_BUFFER, data.size(), data.data(), GL_DYNAMIC_DRAW);
+        glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 
         // Now configure the bindpoint of the buffer inside the shader
         std::string buffer_name = used_buffer.GetName();
-        GLuint index = glGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, buffer_name.c_str());
+        GLuint index =
+            glGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, buffer_name.c_str());
         if (index != -1)
-            glUniformBlockBinding(program, index, buffer_draw_state.bindpoint);
+            glShaderStorageBlockBinding(program, index, buffer_draw_state.bindpoint);
     }
 
     state.Apply();

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -54,11 +54,6 @@ public:
         OGLShader shader;
     };
 
-    /// Maximum supported size that a constbuffer can have in bytes.
-    static constexpr size_t MaxConstbufferSize = 0x10000;
-    static_assert(MaxConstbufferSize % sizeof(GLvec4) == 0,
-                  "The maximum size of a constbuffer must be a multiple of the size of GLvec4");
-
 private:
     class SamplerInfo {
     public:

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -46,7 +46,7 @@ struct FormatTuple {
 
 static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_format_tuples = {{
     {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, false},                    // ABGR8
-    {GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, false},                       // B5G6R5
+    {GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, false},                           // B5G6R5
     {GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, false},              // A2B10G10R10
     {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, false},                // A1B5G5R5
     {GL_R8, GL_RED, GL_UNSIGNED_BYTE, false},                                   // R8
@@ -645,7 +645,7 @@ void CachedSurface::DownloadGLTexture(const MathUtil::Rectangle<u32>& rect, GLui
         glActiveTexture(GL_TEXTURE0);
         glGetTexImage(GL_TEXTURE_2D, 0, tuple.format, tuple.type, &gl_buffer[buffer_offset]);
     } else {
-        state.UnbindTexture(texture.handle);
+        state.ResetTexture(texture.handle);
         state.draw.read_framebuffer = read_fb_handle;
         state.Apply();
 

src/video_core/renderer_opengl/gl_resource_manager.h

@@ -38,7 +38,7 @@ public:
         if (handle == 0)
             return;
         glDeleteTextures(1, &handle);
-        OpenGLState::GetCurState().UnbindTexture(handle).Apply();
+        OpenGLState::GetCurState().ResetTexture(handle).Apply();
         handle = 0;
     }
 

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -9,7 +9,6 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "video_core/engines/shader_bytecode.h"
-#include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_shader_decompiler.h"
 
 namespace GLShader {
@@ -398,8 +397,7 @@ public:
     /// Generates code representing a uniform (C buffer) register, interpreted as the input type.
     std::string GetUniform(u64 index, u64 offset, GLSLRegister::Type type) {
         declr_const_buffers[index].MarkAsUsed(index, offset, stage);
-        std::string value = 'c' + std::to_string(index) + '[' + std::to_string(offset / 4) + "][" +
-                            std::to_string(offset % 4) + ']';
+        std::string value = 'c' + std::to_string(index) + '[' + std::to_string(offset) + ']';
 
         if (type == GLSLRegister::Type::Float) {
             return value;
@@ -413,12 +411,8 @@ public:
     std::string GetUniformIndirect(u64 index, s64 offset, const Register& index_reg,
                                    GLSLRegister::Type type) {
         declr_const_buffers[index].MarkAsUsedIndirect(index, stage);
-
-        std::string final_offset = "((floatBitsToInt(" + GetRegister(index_reg, 0) + ") + " +
-                                   std::to_string(offset) + ") / 4)";
-
-        std::string value =
-            'c' + std::to_string(index) + '[' + final_offset + " / 4][" + final_offset + " % 4]";
+        std::string value = 'c' + std::to_string(index) + "[(floatBitsToInt(" +
+                            GetRegister(index_reg, 0) + ") + " + std::to_string(offset) + ") / 4]";
 
         if (type == GLSLRegister::Type::Float) {
             return value;
@@ -460,10 +454,9 @@ public:
 
         unsigned const_buffer_layout = 0;
         for (const auto& entry : GetConstBuffersDeclarations()) {
-            declarations.AddLine("layout(std140) uniform " + entry.GetName());
+            declarations.AddLine("layout(std430) buffer " + entry.GetName());
             declarations.AddLine('{');
-            declarations.AddLine("    vec4 c" + std::to_string(entry.GetIndex()) +
-                                 "[MAX_CONSTBUFFER_ELEMENTS];");
+            declarations.AddLine("    float c" + std::to_string(entry.GetIndex()) + "[];");
             declarations.AddLine("};");
             declarations.AddNewLine();
             ++const_buffer_layout;
@@ -811,7 +804,6 @@ private:
         if (!opcode) {
             NGLOG_CRITICAL(HW_GPU, "Unhandled instruction: {0:x}", instr.value);
             UNREACHABLE();
-            return offset + 1;
         }
 
         shader.AddLine("// " + std::to_string(offset) + ": " + opcode->GetName());
@@ -1721,10 +1713,7 @@ private:
 }; // namespace Decompiler
 
 std::string GetCommonDeclarations() {
-    std::string declarations = "bool exec_shader();\n";
-    declarations += "#define MAX_CONSTBUFFER_ELEMENTS " +
-                    std::to_string(RasterizerOpenGL::MaxConstbufferSize / (sizeof(GLvec4)));
-    return declarations;
+    return "bool exec_shader();";
 }
 
 boost::optional<ProgramResult> DecompileProgram(const ProgramCode& program_code, u32 main_offset,

src/video_core/renderer_opengl/gl_state.cpp

@@ -48,9 +48,24 @@ OpenGLState::OpenGLState() {
     logic_op = GL_COPY;
 
     for (auto& texture_unit : texture_units) {
-        texture_unit.Reset();
+        texture_unit.texture_2d = 0;
+        texture_unit.sampler = 0;
+        texture_unit.swizzle.r = GL_RED;
+        texture_unit.swizzle.g = GL_GREEN;
+        texture_unit.swizzle.b = GL_BLUE;
+        texture_unit.swizzle.a = GL_ALPHA;
     }
 
+    lighting_lut.texture_buffer = 0;
+
+    fog_lut.texture_buffer = 0;
+
+    proctex_lut.texture_buffer = 0;
+    proctex_diff_lut.texture_buffer = 0;
+    proctex_color_map.texture_buffer = 0;
+    proctex_alpha_map.texture_buffer = 0;
+    proctex_noise_lut.texture_buffer = 0;
+
     draw.read_framebuffer = 0;
     draw.draw_framebuffer = 0;
     draw.vertex_array = 0;
@@ -208,12 +223,54 @@ void OpenGLState::Apply() const {
             if (current.enabled != new_state.enabled || current.bindpoint != new_state.bindpoint ||
                 current.ssbo != new_state.ssbo) {
                 if (new_state.enabled) {
-                    glBindBufferBase(GL_UNIFORM_BUFFER, new_state.bindpoint, new_state.ssbo);
+                    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, new_state.bindpoint, new_state.ssbo);
                 }
             }
         }
     }
 
+    // Lighting LUTs
+    if (lighting_lut.texture_buffer != cur_state.lighting_lut.texture_buffer) {
+        glActiveTexture(TextureUnits::LightingLUT.Enum());
+        glBindTexture(GL_TEXTURE_BUFFER, lighting_lut.texture_buffer);
+    }
+
+    // Fog LUT
+    if (fog_lut.texture_buffer != cur_state.fog_lut.texture_buffer) {
+        glActiveTexture(TextureUnits::FogLUT.Enum());
+        glBindTexture(GL_TEXTURE_BUFFER, fog_lut.texture_buffer);
+    }
+
+    // ProcTex Noise LUT
+    if (proctex_noise_lut.texture_buffer != cur_state.proctex_noise_lut.texture_buffer) {
+        glActiveTexture(TextureUnits::ProcTexNoiseLUT.Enum());
+        glBindTexture(GL_TEXTURE_BUFFER, proctex_noise_lut.texture_buffer);
+    }
+
+    // ProcTex Color Map
+    if (proctex_color_map.texture_buffer != cur_state.proctex_color_map.texture_buffer) {
+        glActiveTexture(TextureUnits::ProcTexColorMap.Enum());
+        glBindTexture(GL_TEXTURE_BUFFER, proctex_color_map.texture_buffer);
+    }
+
+    // ProcTex Alpha Map
+    if (proctex_alpha_map.texture_buffer != cur_state.proctex_alpha_map.texture_buffer) {
+        glActiveTexture(TextureUnits::ProcTexAlphaMap.Enum());
+        glBindTexture(GL_TEXTURE_BUFFER, proctex_alpha_map.texture_buffer);
+    }
+
+    // ProcTex LUT
+    if (proctex_lut.texture_buffer != cur_state.proctex_lut.texture_buffer) {
+        glActiveTexture(TextureUnits::ProcTexLUT.Enum());
+        glBindTexture(GL_TEXTURE_BUFFER, proctex_lut.texture_buffer);
+    }
+
+    // ProcTex Diff LUT
+    if (proctex_diff_lut.texture_buffer != cur_state.proctex_diff_lut.texture_buffer) {
+        glActiveTexture(TextureUnits::ProcTexDiffLUT.Enum());
+        glBindTexture(GL_TEXTURE_BUFFER, proctex_diff_lut.texture_buffer);
+    }
+
     // Framebuffer
     if (draw.read_framebuffer != cur_state.draw.read_framebuffer) {
         glBindFramebuffer(GL_READ_FRAMEBUFFER, draw.read_framebuffer);
@@ -281,12 +338,26 @@ void OpenGLState::Apply() const {
     cur_state = *this;
 }
 
-OpenGLState& OpenGLState::UnbindTexture(GLuint handle) {
+OpenGLState& OpenGLState::ResetTexture(GLuint handle) {
     for (auto& unit : texture_units) {
         if (unit.texture_2d == handle) {
-            unit.Unbind();
+            unit.texture_2d = 0;
         }
     }
+    if (lighting_lut.texture_buffer == handle)
+        lighting_lut.texture_buffer = 0;
+    if (fog_lut.texture_buffer == handle)
+        fog_lut.texture_buffer = 0;
+    if (proctex_noise_lut.texture_buffer == handle)
+        proctex_noise_lut.texture_buffer = 0;
+    if (proctex_color_map.texture_buffer == handle)
+        proctex_color_map.texture_buffer = 0;
+    if (proctex_alpha_map.texture_buffer == handle)
+        proctex_alpha_map.texture_buffer = 0;
+    if (proctex_lut.texture_buffer == handle)
+        proctex_lut.texture_buffer = 0;
+    if (proctex_diff_lut.texture_buffer == handle)
+        proctex_diff_lut.texture_buffer = 0;
     return *this;
 }
 

src/video_core/renderer_opengl/gl_state.h

@@ -91,21 +91,36 @@ public:
             GLint b; // GL_TEXTURE_SWIZZLE_B
             GLint a; // GL_TEXTURE_SWIZZLE_A
         } swizzle;
-
-        void Unbind() {
-            texture_2d = 0;
-            swizzle.r = GL_RED;
-            swizzle.g = GL_GREEN;
-            swizzle.b = GL_BLUE;
-            swizzle.a = GL_ALPHA;
-        }
-
-        void Reset() {
-            Unbind();
-            sampler = 0;
-        }
     } texture_units[32];
 
+    struct {
+        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
+    } lighting_lut;
+
+    struct {
+        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
+    } fog_lut;
+
+    struct {
+        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
+    } proctex_noise_lut;
+
+    struct {
+        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
+    } proctex_color_map;
+
+    struct {
+        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
+    } proctex_alpha_map;
+
+    struct {
+        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
+    } proctex_lut;
+
+    struct {
+        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
+    } proctex_diff_lut;
+
     struct {
         GLuint read_framebuffer; // GL_READ_FRAMEBUFFER_BINDING
         GLuint draw_framebuffer; // GL_DRAW_FRAMEBUFFER_BINDING
@@ -150,7 +165,7 @@ public:
     void Apply() const;
 
     /// Resets any references to the given resource
-    OpenGLState& UnbindTexture(GLuint handle);
+    OpenGLState& ResetTexture(GLuint handle);
     OpenGLState& ResetSampler(GLuint handle);
     OpenGLState& ResetProgram(GLuint handle);
     OpenGLState& ResetPipeline(GLuint handle);

src/yuzu/main.cpp

@@ -334,6 +334,8 @@ bool GMainWindow::SupportsRequiredGLExtensions() {
         unsupported_ext.append("ARB_program_interface_query");
     if (!GLAD_GL_ARB_separate_shader_objects)
         unsupported_ext.append("ARB_separate_shader_objects");
+    if (!GLAD_GL_ARB_shader_storage_buffer_object)
+        unsupported_ext.append("ARB_shader_storage_buffer_object");
     if (!GLAD_GL_ARB_vertex_attrib_binding)
         unsupported_ext.append("ARB_vertex_attrib_binding");