Revert "Use Ninja for MSVC AppVeyor builds"

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

@@ -17,7 +17,7 @@ constexpr u64 audio_ticks{static_cast<u64>(CoreTiming::BASE_CLOCK_RATE / 200)};
 
 class IAudioRenderer final : public ServiceFramework<IAudioRenderer> {
 public:
-    IAudioRenderer(AudioRendererParameter audren_params)
+    IAudioRenderer(AudioRendererParameters audren_params)
         : ServiceFramework("IAudioRenderer"), worker_params(audren_params) {
         static const FunctionInfo functions[] = {
             {0, nullptr, "GetAudioRendererSampleRate"},
@@ -58,22 +58,22 @@ private:
     }
 
     void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
-        UpdateDataHeader config{};
+        AudioRendererConfig config;
         auto buf = ctx.ReadBuffer();
-        std::memcpy(&config, buf.data(), sizeof(UpdateDataHeader));
+        std::memcpy(&config, buf.data(), sizeof(AudioRendererConfig));
         u32 memory_pool_count = worker_params.effect_count + (worker_params.voice_count * 4);
 
         std::vector<MemoryPoolInfo> mem_pool_info(memory_pool_count);
         std::memcpy(mem_pool_info.data(),
-                    buf.data() + sizeof(UpdateDataHeader) + config.behavior_size,
+                    buf.data() + sizeof(AudioRendererConfig) + config.behavior_size,
                     memory_pool_count * sizeof(MemoryPoolInfo));
 
-        UpdateDataHeader response_data{worker_params};
+        AudioRendererResponse response_data{worker_params};
 
         ASSERT(ctx.GetWriteBufferSize() == response_data.total_size);
 
         std::vector<u8> output(response_data.total_size);
-        std::memcpy(output.data(), &response_data, sizeof(UpdateDataHeader));
+        std::memcpy(output.data(), &response_data, sizeof(AudioRendererResponse));
         std::vector<MemoryPoolEntry> memory_pool(memory_pool_count);
         for (unsigned i = 0; i < memory_pool.size(); i++) {
             if (mem_pool_info[i].pool_state == MemoryPoolStates::RequestAttach)
@@ -83,7 +83,7 @@ private:
             else
                 memory_pool[i].state = mem_pool_info[i].pool_state;
         }
-        std::memcpy(output.data() + sizeof(UpdateDataHeader), memory_pool.data(),
+        std::memcpy(output.data() + sizeof(AudioRendererResponse), memory_pool.data(),
                     response_data.memory_pools_size);
 
         ctx.WriteBuffer(output);
@@ -146,40 +146,53 @@ private:
     };
     static_assert(sizeof(MemoryPoolInfo) == 0x20, "MemoryPoolInfo has wrong size");
 
-    struct UpdateDataHeader {
-        UpdateDataHeader() {}
+    struct AudioRendererConfig {
+        u32 revision;
+        u32 behavior_size;
+        u32 memory_pools_size;
+        u32 voices_size;
+        u32 voice_resource_size;
+        u32 effects_size;
+        u32 mixes_size;
+        u32 sinks_size;
+        u32 performance_buffer_size;
+        INSERT_PADDING_WORDS(6);
+        u32 total_size;
+    };
+    static_assert(sizeof(AudioRendererConfig) == 0x40, "AudioRendererConfig has wrong size");
 
-        UpdateDataHeader(const AudioRendererParameter& config) {
-            revision = Common::MakeMagic('R', 'E', 'V', '4'); // 5.1.0 Revision
-            behavior_size = 0xb0;
+    struct AudioRendererResponse {
+        AudioRendererResponse(const AudioRendererParameters& config) {
+            revision = config.revision;
+            error_info_size = 0xb0;
             memory_pools_size = (config.effect_count + (config.voice_count * 4)) * 0x10;
             voices_size = config.voice_count * 0x10;
             effects_size = config.effect_count * 0x10;
             sinks_size = config.sink_count * 0x20;
             performance_manager_size = 0x10;
-            total_size = sizeof(UpdateDataHeader) + behavior_size + memory_pools_size +
+            total_size = sizeof(AudioRendererResponse) + error_info_size + memory_pools_size +
                          voices_size + effects_size + sinks_size + performance_manager_size;
         }
 
         u32_le revision;
-        u32_le behavior_size;
+        u32_le error_info_size;
         u32_le memory_pools_size;
         u32_le voices_size;
-        u32_le voice_resource_size;
+        u32_le unknown_10;
         u32_le effects_size;
-        u32_le mixes_size;
+        u32_le unknown_18;
         u32_le sinks_size;
         u32_le performance_manager_size;
         INSERT_PADDING_WORDS(6);
         u32_le total_size;
     };
-    static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size");
+    static_assert(sizeof(AudioRendererResponse) == 0x40, "AudioRendererResponse has wrong size");
 
     /// This is used to trigger the audio event callback.
     CoreTiming::EventType* audio_event;
 
     Kernel::SharedPtr<Kernel::Event> system_event;
-    AudioRendererParameter worker_params;
+    AudioRendererParameters worker_params;
 };
 
 class IAudioDevice final : public ServiceFramework<IAudioDevice> {
@@ -278,7 +291,7 @@ AudRenU::AudRenU() : ServiceFramework("audren:u") {
 
 void AudRenU::OpenAudioRenderer(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    auto params = rp.PopRaw<AudioRendererParameter>();
+    auto params = rp.PopRaw<AudioRendererParameters>();
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
 
     rb.Push(RESULT_SUCCESS);
@@ -289,7 +302,7 @@ void AudRenU::OpenAudioRenderer(Kernel::HLERequestContext& ctx) {
 
 void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    auto params = rp.PopRaw<AudioRendererParameter>();
+    auto params = rp.PopRaw<AudioRendererParameters>();
 
     u64 buffer_sz = Common::AlignUp(4 * params.unknown_8, 0x40);
     buffer_sz += params.unknown_c * 1024;

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

@@ -12,7 +12,7 @@ class HLERequestContext;
 
 namespace Service::Audio {
 
-struct AudioRendererParameter {
+struct AudioRendererParameters {
     u32_le sample_rate;
     u32_le sample_count;
     u32_le unknown_8;
@@ -28,7 +28,7 @@ struct AudioRendererParameter {
     INSERT_PADDING_WORDS(1);
     u32_le revision;
 };
-static_assert(sizeof(AudioRendererParameter) == 52, "AudioRendererParameter is an invalid size");
+static_assert(sizeof(AudioRendererParameters) == 52, "AudioRendererParameters is an invalid size");
 
 class AudRenU final : public ServiceFramework<AudRenU> {
 public:

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");