gl_shader_disk_cache: Pass return values returning instead of by parameters

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -344,17 +344,15 @@ ShaderDiskCacheUsage CachedShader::GetUsage(GLenum primitive_mode,
 ShaderCacheOpenGL::ShaderCacheOpenGL(RasterizerOpenGL& rasterizer) : RasterizerCache{rasterizer} {}
 
 void ShaderCacheOpenGL::LoadDiskCache() {
-    std::vector<ShaderDiskCacheRaw> raws;
+    const auto transferable = disk_cache.LoadTransferable();
-    std::vector<ShaderDiskCacheUsage> usages;
+    if (!transferable) {
-    if (!disk_cache.LoadTransferable(raws, usages)) {
         return;
     }
+    const auto [raws, usages] = *transferable;
 
-    std::map<u64, ShaderDiskCacheDecompiled> decompiled;
+    auto [decompiled, dumps] = disk_cache.LoadPrecompiled();
-    std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump> dumps;
-    disk_cache.LoadPrecompiled(decompiled, dumps);
 
-    const std::set<GLenum> supported_formats{GetSupportedFormats()};
+    const auto supported_formats{GetSupportedFormats()};
     const auto unspecialized{GenerateUnspecializedShaders(raws, decompiled)};
 
     // Build shaders

src/video_core/renderer_opengl/gl_shader_disk_cache.cpp

@@ -111,17 +111,17 @@ void ShaderDiskCacheRaw::Save(FileUtil::IOFile& file) const {
     }
 }
 
-bool ShaderDiskCacheOpenGL::LoadTransferable(std::vector<ShaderDiskCacheRaw>& raws,
+std::optional<std::pair<std::vector<ShaderDiskCacheRaw>, std::vector<ShaderDiskCacheUsage>>>
-                                             std::vector<ShaderDiskCacheUsage>& usages) {
+ShaderDiskCacheOpenGL::LoadTransferable() {
     if (!Settings::values.use_disk_shader_cache) {
-        return false;
+        return {};
     }
 
     FileUtil::IOFile file(GetTransferablePath(), "rb");
     if (!file.IsOpen()) {
         LOG_INFO(Render_OpenGL, "No transferable shader cache found for game with title id={}",
                  GetTitleID());
-        return false;
+        return {};
     }
     const u64 file_size = file.GetSize();
 
@@ -132,15 +132,17 @@ bool ShaderDiskCacheOpenGL::LoadTransferable(std::vector<ShaderDiskCacheRaw>& ra
         LOG_INFO(Render_OpenGL, "Transferable shader cache is old - removing");
         file.Close();
         FileUtil::Delete(GetTransferablePath());
-        return false;
+        return {};
     }
     if (version > NativeVersion) {
         LOG_WARNING(Render_OpenGL, "Transferable shader cache was generated with a newer version "
                                    "of the emulator - skipping");
-        return false;
+        return {};
     }
 
     // Version is valid, load the shaders
+    std::vector<ShaderDiskCacheRaw> raws;
+    std::vector<ShaderDiskCacheUsage> usages;
     while (file.Tell() < file_size) {
         TransferableEntryKind kind{};
         file.ReadBytes(&kind, sizeof(u32));
@@ -161,25 +163,24 @@ bool ShaderDiskCacheOpenGL::LoadTransferable(std::vector<ShaderDiskCacheRaw>& ra
         default:
             LOG_ERROR(Render_OpenGL, "Unknown transferable shader cache entry kind={} - aborting",
                       static_cast<u32>(kind));
-            return false;
+            return {};
         }
     }
-    return true;
+    return {{raws, usages}};
 }
 
-bool ShaderDiskCacheOpenGL::LoadPrecompiled(
+std::pair<std::map<u64, ShaderDiskCacheDecompiled>,
-    std::map<u64, ShaderDiskCacheDecompiled>& decompiled,
+          std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>
-    std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump>& dumps) {
+ShaderDiskCacheOpenGL::LoadPrecompiled() {
-
     if (!Settings::values.use_disk_shader_cache) {
-        return false;
+        return {};
     }
 
     FileUtil::IOFile file(GetPrecompiledPath(), "rb");
     if (!file.IsOpen()) {
         LOG_INFO(Render_OpenGL, "No precompiled shader cache found for game with title id={}",
                  GetTitleID());
-        return false;
+        return {};
     }
     const u64 file_size = file.GetSize();
 
@@ -189,9 +190,11 @@ bool ShaderDiskCacheOpenGL::LoadPrecompiled(
         LOG_INFO(Render_OpenGL, "Precompiled cache is from another version of yuzu - removing");
         file.Close();
         InvalidatePrecompiled();
-        return false;
+        return {};
     }
 
+    std::map<u64, ShaderDiskCacheDecompiled> decompiled;
+    std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump> dumps;
     while (file.Tell() < file_size) {
         PrecompiledEntryKind kind{};
         file.ReadBytes(&kind, sizeof(u32));
@@ -217,9 +220,7 @@ bool ShaderDiskCacheOpenGL::LoadPrecompiled(
                           "Failed to decompress GLSL code in precompiled shader={:016x} - removing",
                           unique_identifier);
                 InvalidatePrecompiled();
-                dumps.clear();
+                return {};
-                decompiled.clear();
-                return false;
             }
             entry.code = std::string(reinterpret_cast<const char*>(code.data()), code_size);
 
@@ -294,9 +295,7 @@ bool ShaderDiskCacheOpenGL::LoadPrecompiled(
                 LOG_ERROR(Render_OpenGL,
                           "Failed to decompress precompiled binary program - removing");
                 InvalidatePrecompiled();
-                dumps.clear();
+                return {};
-                decompiled.clear();
-                return false;
             }
 
             dumps.insert({usage, dump});
@@ -306,12 +305,10 @@ bool ShaderDiskCacheOpenGL::LoadPrecompiled(
             LOG_ERROR(Render_OpenGL, "Unknown precompiled shader cache entry kind={} - removing",
                       static_cast<u32>(kind));
             InvalidatePrecompiled();
-            dumps.clear();
+            return {};
-            decompiled.clear();
-            return false;
         }
     }
-    return true;
+    return {decompiled, dumps};
 }
 
 void ShaderDiskCacheOpenGL::InvalidateTransferable() const {

src/video_core/renderer_opengl/gl_shader_disk_cache.h

@@ -4,9 +4,11 @@
 
 #pragma once
 
+#include <optional>
 #include <set>
 #include <string>
 #include <tuple>
+#include <utility>
 #include <vector>
 
 #include <glad/glad.h>
@@ -142,13 +144,14 @@ struct ShaderDiskCacheDump {
 
 class ShaderDiskCacheOpenGL {
 public:
-    /// Loads transferable cache. If file has a old version, it deletes it. Returns true on success.
+    /// Loads transferable cache. If file has a old version or on failure, it deletes the file.
-    bool LoadTransferable(std::vector<ShaderDiskCacheRaw>& raws,
+    std::optional<std::pair<std::vector<ShaderDiskCacheRaw>, std::vector<ShaderDiskCacheUsage>>>
-                          std::vector<ShaderDiskCacheUsage>& usages);
+    LoadTransferable();
 
-    /// Loads current game's precompiled cache. Invalidates if emulator's version has changed.
+    /// Loads current game's precompiled cache. Invalidates on failure.
-    bool LoadPrecompiled(std::map<u64, ShaderDiskCacheDecompiled>& decompiled,
+    std::pair<std::map<u64, ShaderDiskCacheDecompiled>,
-                         std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump>& dumps);
+              std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>
+    LoadPrecompiled();
 
     /// Removes the transferable (and precompiled) cache file.
     void InvalidateTransferable() const;