gl_shader_decompiler: Add safe fallbacks when ARB_shader_ballot is not available

src/video_core/renderer_opengl/gl_device.cpp

@@ -62,6 +62,7 @@ Device::Device() {
     max_varyings = GetInteger<u32>(GL_MAX_VARYING_VECTORS);
     has_warp_intrinsics = GLAD_GL_NV_gpu_shader5 && GLAD_GL_NV_shader_thread_group &&
                           GLAD_GL_NV_shader_thread_shuffle;
+    has_shader_ballot = GLAD_GL_ARB_shader_ballot;
     has_vertex_viewport_layer = GLAD_GL_ARB_shader_viewport_layer_array;
     has_image_load_formatted = HasExtension(extensions, "GL_EXT_shader_image_load_formatted");
     has_variable_aoffi = TestVariableAoffi();
@@ -79,6 +80,7 @@ Device::Device(std::nullptr_t) {
     max_vertex_attributes = 16;
     max_varyings = 15;
     has_warp_intrinsics = true;
+    has_shader_ballot = true;
     has_vertex_viewport_layer = true;
     has_image_load_formatted = true;
     has_variable_aoffi = true;

src/video_core/renderer_opengl/gl_device.h

@@ -34,6 +34,10 @@ public:
         return has_warp_intrinsics;
     }
 
+    bool HasShaderBallot() const {
+        return has_shader_ballot;
+    }
+
     bool HasVertexViewportLayer() const {
         return has_vertex_viewport_layer;
     }
@@ -68,6 +72,7 @@ private:
     u32 max_vertex_attributes{};
     u32 max_varyings{};
     bool has_warp_intrinsics{};
+    bool has_shader_ballot{};
     bool has_vertex_viewport_layer{};
     bool has_image_load_formatted{};
     bool has_variable_aoffi{};

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -1382,13 +1382,19 @@ private:
     Expression FSwizzleAdd(Operation operation) {
         const std::string op_a = VisitOperand(operation, 0).AsFloat();
         const std::string op_b = VisitOperand(operation, 1).AsFloat();
-        const std::string instr_mask = VisitOperand(operation, 2).AsUint();
 
+        if (!device.HasShaderBallot()) {
+            LOG_ERROR(Render_OpenGL, "Shader ballot is unavailable but required by the shader");
+            return {fmt::format("{} + {}", op_a, op_b), Type::Float};
+        }
+
+        const std::string instr_mask = VisitOperand(operation, 2).AsUint();
         const std::string mask = code.GenerateTemporary();
-        code.AddLine("uint {} = {} >> ((gl_SubGroupInvocationARB & 3) << 1);", mask, instr_mask);
+        code.AddLine("uint {} = ({} >> ((gl_SubGroupInvocationARB & 3) << 1)) & 3;", mask,
+                     instr_mask);
 
-        const std::string modifier_a = fmt::format("fswzadd_modifiers_a[{} & 3]", mask);
-        const std::string modifier_b = fmt::format("fswzadd_modifiers_b[{} & 3]", mask);
+        const std::string modifier_a = fmt::format("fswzadd_modifiers_a[{}]", mask);
+        const std::string modifier_b = fmt::format("fswzadd_modifiers_b[{}]", mask);
         return {fmt::format("(({} * {}) + ({} * {}))", op_a, modifier_a, op_b, modifier_b),
                 Type::Float};
     }
@@ -1957,11 +1963,21 @@ private:
     }
 
     Expression ThreadId(Operation operation) {
+        if (!device.HasShaderBallot()) {
+            LOG_ERROR(Render_OpenGL, "Shader ballot is unavailable but required by the shader");
+            return {"0U", Type::Uint};
+        }
         return {"gl_SubGroupInvocationARB", Type::Uint};
     }
 
     Expression ShuffleIndexed(Operation operation) {
-        const std::string value = VisitOperand(operation, 0).AsFloat();
+        std::string value = VisitOperand(operation, 0).AsFloat();
+
+        if (!device.HasShaderBallot()) {
+            LOG_ERROR(Render_OpenGL, "Shader ballot is unavailable but required by the shader");
+            return {std::move(value), Type::Float};
+        }
+
         const std::string index = VisitOperand(operation, 1).AsUint();
         return {fmt::format("readInvocationARB({}, {})", value, index), Type::Float};
     }