xbzk/gpu-logging_qt-controls_android-fix (#4018)

5af7771f83-Bugfix: Made gpu_log_level global-only (was per-game switchable). Fixed Android non-determinism where a per-game profile silently overrode the global to Off and trapped GPULogger::Initialize() in a dead state, making shader dumps fail invisibly. Android per-game UI now hides the whole GPU logging block; Qt UI is untouched (global-only anyway).

bf4aabe8ab-Refactor/Cleanup: Removed gpu_logging_enabled master toggle as redundant with gpu_log_level == Off. Introduced GPU::Logging::IsActive() helper, replaced 14 call sites across vk_*.cpp. Refactored LogShaderCompilation() to be text-only and extracted SPIR-V dumping into a standalone GPU::Logging::DumpSpirvShader() free function. No singleton dependency, gated only by gpu_log_shader_dumps. Now gpu_log_level and gpu_log_shader_dumps are fully orthogonal. Cleaned up Android (BooleanSetting, SettingsItem, presenter, 7 locale string files).

865a1c5027-Refactor: Renamed dump_shaders → dump_guest_shaders to disambiguate from gpu_log_shader_dumps. Updated Qt label to "Dump Guest (Maxwell) Shaders" and rewrote the tooltip to mention .ash, the DumpDir/shaders/ location, and nvdisasm.

7cab456fdf-Feature: Added Qt UI control for GPU log level in the Logging session. Added gpu_log_shader_dumps checkbox to the Graphics column right below dump_guest_shaders.

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4018
Reviewed-by: MaranBr <maranbr@eden-emu.dev>

src/video_core/gpu_logging/gpu_logging.cpp

@@ -4,6 +4,7 @@
 #include "video_core/gpu_logging/gpu_logging.h"
 
 #include <fmt/format.h>
+#include <mutex>
 #include <thread>
 
 #include "common/fs/file.h"
@@ -280,13 +281,12 @@ void GPULogger::LogMemoryDeallocation(uintptr_t memory) {
 }
 
 void GPULogger::LogShaderCompilation(const std::string& shader_name,
-                                     const std::string& shader_info,
-                                     std::span<const u32> spirv_code) {
+                                     const std::string& shader_info) {
     if (!initialized || current_level == LogLevel::Off) {
         return;
     }
 
-    if (!dump_shaders && current_level < LogLevel::Verbose) {
+    if (current_level < LogLevel::Verbose) {
         return;
     }
 
@@ -294,38 +294,36 @@ void GPULogger::LogShaderCompilation(const std::string& shader_name,
         std::chrono::steady_clock::now().time_since_epoch());
 
     const auto log_entry = fmt::format("[{}] [Shader] Compiled: {} ({})\n",
-                                      FormatTimestamp(timestamp), shader_name, shader_info);
+                                       FormatTimestamp(timestamp), shader_name, shader_info);
     WriteToLog(log_entry);
+}
 
-    // Dump SPIR-V binary if enabled and we have data
-    if (dump_shaders && !spirv_code.empty()) {
-        using namespace Common::FS;
-        const auto& log_dir = GetEdenPath(EdenPath::LogDir);
-        const auto shaders_dir = log_dir / "shaders";
+bool IsActive() noexcept {
+    return Settings::values.gpu_log_level.GetValue() != Settings::GpuLogLevel::Off;
+}
 
-        // Create directory on first dump
-        if (!shader_dump_dir_created) {
-            [[maybe_unused]] const bool created = CreateDir(shaders_dir);
-            shader_dump_dir_created = true;
-        }
-
-        // Write SPIR-V binary file
-        const auto shader_path = shaders_dir / fmt::format("{}.spv", shader_name);
-        auto shader_file = std::make_unique<Common::FS::IOFile>(
-            shader_path, FileAccessMode::Write, FileType::BinaryFile);
-
-        if (shader_file->IsOpen()) {
-            const size_t bytes_to_write = spirv_code.size() * sizeof(u32);
-            static_cast<void>(shader_file->WriteSpan(spirv_code));
-            shader_file->Close();
-
-            const auto dump_log = fmt::format("[{}] [Shader] Dumped SPIR-V: {} ({} bytes)\n",
-                FormatTimestamp(timestamp), shader_path.string(), bytes_to_write);
-            WriteToLog(dump_log);
-        } else {
-            LOG_WARNING(Render_Vulkan, "[GPU Logging] Failed to dump shader: {}", shader_path.string());
-        }
+void DumpSpirvShader(u64 shader_hash, std::span<const u32> spirv_code) {
+    if (spirv_code.empty()) {
+        return;
     }
+
+    using namespace Common::FS;
+    const auto& dump_dir = GetEdenPath(EdenPath::DumpDir);
+
+    // Ensure DumpDir exists once. CreateDir is idempotent, so guarded to skip the syscall.
+    static std::once_flag dump_dir_flag;
+    std::call_once(dump_dir_flag, [&dump_dir]() {
+        [[maybe_unused]] const bool created = CreateDir(dump_dir);
+    });
+
+    const auto shader_path = dump_dir / fmt::format("{:016x}_{:016x}.spv",
+                                                    Settings::GetCurrentProgramID(), shader_hash);
+    Common::FS::IOFile shader_file(shader_path, FileAccessMode::Write, FileType::BinaryFile);
+    if (!shader_file.IsOpen()) {
+        LOG_WARNING(Render_Vulkan, "[Shader Dump] Failed to open {}", shader_path.string());
+        return;
+    }
+    static_cast<void>(shader_file.WriteSpan(spirv_code));
 }
 
 void GPULogger::LogPipelineStateChange(const std::string& state_info) {
@@ -657,10 +655,6 @@ void GPULogger::EnableVulkanCallTracking(bool enabled) {
     track_vulkan_calls = enabled;
 }
 
-void GPULogger::EnableShaderDumps(bool enabled) {
-    dump_shaders = enabled;
-}
-
 void GPULogger::EnableMemoryTracking(bool enabled) {
     track_memory = enabled;
 }

src/video_core/gpu_logging/gpu_logging.h

@@ -87,8 +87,7 @@ public:
     void LogVulkanCall(const std::string& call_name, const std::string& params, int result);
     void LogMemoryAllocation(uintptr_t memory, u64 size, u32 memory_flags);
     void LogMemoryDeallocation(uintptr_t memory);
-    void LogShaderCompilation(const std::string& shader_name, const std::string& shader_info,
-                              std::span<const u32> spirv_code = {});
+    void LogShaderCompilation(const std::string& shader_name, const std::string& shader_info);
     void LogPipelineStateChange(const std::string& state_info);
     void LogDriverDebugInfo(const std::string& debug_info);
 
@@ -121,7 +120,6 @@ public:
     // Settings
     void SetLogLevel(LogLevel level);
     void EnableVulkanCallTracking(bool enabled);
-    void EnableShaderDumps(bool enabled);
     void EnableMemoryTracking(bool enabled);
     void EnableDriverDebugInfo(bool enabled);
     void SetRingBufferSize(size_t entries);
@@ -171,7 +169,6 @@ private:
 
     // Feature flags
     bool track_vulkan_calls = true;
-    bool dump_shaders = false;
     bool track_memory = false;
     bool capture_driver_debug = false;
 
@@ -179,15 +176,16 @@ private:
     std::set<std::string> used_extensions;
     mutable std::mutex extension_mutex;
 
-    // Shader dump directory (created on demand)
-    bool shader_dump_dir_created = false;
-
     // Stored state for crash dumps
     std::string stored_driver_debug_info;
     std::string stored_pipeline_state;
     mutable std::mutex state_mutex;
 };
 
+[[nodiscard]] bool IsActive() noexcept;
+
+void DumpSpirvShader(u64 shader_hash, std::span<const u32> spirv_code);
+
 // Helper to get stage name from index
 inline const char* GetShaderStageName(size_t stage_index) {
     static constexpr std::array<const char*, 5> stage_names{

src/video_core/macro.cpp

@@ -1328,22 +1328,14 @@ Macro::Opcode MacroJITx64Impl::GetOpCode() const {
 #endif
 
 static void Dump(u64 hash, std::span<const u32> code, bool decompiled = false) {
-    const auto base_dir{Common::FS::GetEdenPath(Common::FS::EdenPath::DumpDir)};
-    const auto macro_dir{base_dir / "macros"};
-    if (!Common::FS::CreateDir(base_dir) || !Common::FS::CreateDir(macro_dir)) {
-        LOG_ERROR(Common_Filesystem, "Failed to create macro dump directories");
+    const auto dump_dir{Common::FS::GetEdenPath(Common::FS::EdenPath::DumpDir)};
+    if (!Common::FS::CreateDir(dump_dir)) {
+        LOG_ERROR(Common_Filesystem, "Failed to create dump directory");
         return;
     }
-    auto name{macro_dir / fmt::format("{:016x}.macro", hash)};
-
-    if (decompiled) {
-        auto new_name{macro_dir / fmt::format("decompiled_{:016x}.macro", hash)};
-        if (Common::FS::Exists(name)) {
-            (void)Common::FS::RenameFile(name, new_name);
-            return;
-        }
-        name = new_name;
-    }
+    const char* const variant_suffix = decompiled ? "jit" : "raw";
+    const auto name{dump_dir / fmt::format("{:016x}_{:016x}_{}.macro",
+                                           Settings::GetCurrentProgramID(), hash, variant_suffix)};
 
     std::fstream macro_file(name, std::ios::out | std::ios::binary);
     if (!macro_file) {

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -481,7 +481,7 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
         const u32 cfg_offset = u32(env.StartAddress() + sizeof(Shader::ProgramHeader));
         Shader::Maxwell::Flow::CFG cfg(env, pools.flow_block, cfg_offset, index == 0);
 
-        if (Settings::values.dump_shaders) {
+        if (Settings::values.dump_guest_shaders) {
             env.Dump(hash, key.unique_hashes[index]);
         }
 
@@ -578,7 +578,7 @@ std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
 
     Shader::Maxwell::Flow::CFG cfg{env, pools.flow_block, env.StartAddress()};
 
-    if (Settings::values.dump_shaders) {
+    if (Settings::values.dump_guest_shaders) {
         env.Dump(hash, key.unique_hash);
     }
 

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -87,7 +87,7 @@ ComputePipeline::ComputePipeline(const Device& device_, Scheduler& scheduler, vk
         }, *pipeline_cache);
 
         // Log compute pipeline creation
-        if (Settings::values.gpu_logging_enabled.GetValue()) {
+        if (GPU::Logging::IsActive()) {
             GPU::Logging::GPULogger::GetInstance().LogPipelineStateChange(
                 "ComputePipeline created"
             );
@@ -223,7 +223,7 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
     }
 
     // Log compute pipeline binding
-    if (Settings::values.gpu_logging_enabled.GetValue() &&
+    if (GPU::Logging::IsActive() &&
         Settings::values.gpu_log_vulkan_calls.GetValue()) {
         GPU::Logging::GPULogger::GetInstance().LogPipelineBind(true, "compute pipeline");
     }

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -532,7 +532,7 @@ void GraphicsPipeline::ConfigureDraw(const RescalingPushConstant& rescaling,
     const bool bind_pipeline{scheduler.UpdateGraphicsPipeline(this)};
 
     // Log graphics pipeline binding
-    if (bind_pipeline && Settings::values.gpu_logging_enabled.GetValue() &&
+    if (bind_pipeline && GPU::Logging::IsActive() &&
         Settings::values.gpu_log_vulkan_calls.GetValue()) {
         const std::string pipeline_info = fmt::format("hash=0x{:016x}", key.Hash());
         GPU::Logging::GPULogger::GetInstance().LogPipelineBind(false, pipeline_info);
@@ -986,7 +986,7 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
     }, *pipeline_cache);
 
     // Log graphics pipeline creation
-    if (Settings::values.gpu_logging_enabled.GetValue()) {
+    if (GPU::Logging::IsActive()) {
         const std::string pipeline_info = fmt::format(
             "GraphicsPipeline created: stages={}, attachments={}",
             shader_stages.size(),

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -751,7 +751,7 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
             programs[index] = MergeDualVertexPrograms(program_va, program_vb, env);
         }
 
-        if (Settings::values.dump_shaders) {
+        if (Settings::values.dump_guest_shaders) {
             env.Dump(hash, key.unique_hashes[index]);
         }
 
@@ -783,14 +783,22 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
         device.SaveShader(code);
         modules[stage_index] = BuildShader(device, code);
 
-        // Log shader compilation to GPU logger (with SPIR-V binary dump if enabled)
-        if (Settings::values.gpu_logging_enabled.GetValue()) {
+        // Text log + .spv dump. Text log is gated by gpu_log_level != Off; .spv dump
+        // is independent and gated only by gpu_log_shader_dumps.
+        const bool should_log = GPU::Logging::IsActive();
+        const bool should_dump = Settings::values.gpu_log_shader_dumps.GetValue();
+        if (should_log || should_dump) {
             static constexpr std::array stage_names{"vertex", "tess_control", "tess_eval", "geometry", "fragment"};
             const std::string shader_name = fmt::format("shader_{:016x}_{}", key.unique_hashes[index], stage_names[stage_index]);
-            const std::string shader_info = fmt::format("SPIR-V size: {} bytes, hash: {:016x}",
-                code.size() * sizeof(u32), key.unique_hashes[index]);
-            GPU::Logging::GPULogger::GetInstance().LogShaderCompilation(shader_name, shader_info,
-                std::span<const u32>(code.data(), code.size()));
+            if (should_log) {
+                const std::string shader_info = fmt::format("SPIR-V size: {} bytes, hash: {:016x}",
+                    code.size() * sizeof(u32), key.unique_hashes[index]);
+                GPU::Logging::GPULogger::GetInstance().LogShaderCompilation(shader_name, shader_info);
+            }
+            if (should_dump) {
+                GPU::Logging::DumpSpirvShader(key.unique_hashes[index],
+                                              std::span<const u32>(code.data(), code.size()));
+            }
         }
 
         if (device.HasDebuggingToolAttached()) {
@@ -879,7 +887,7 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
     Shader::Maxwell::Flow::CFG cfg{env, pools.flow_block, env.StartAddress()};
 
     // Dump it before error.
-    if (Settings::values.dump_shaders) {
+    if (Settings::values.dump_guest_shaders) {
         env.Dump(hash, key.unique_hash);
     }
 
@@ -901,13 +909,20 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
     device.SaveShader(code);
     vk::ShaderModule spv_module{BuildShader(device, code)};
 
-    // Log compute shader compilation to GPU logger (with SPIR-V binary dump if enabled)
-    if (Settings::values.gpu_logging_enabled.GetValue()) {
+    // Text log + .spv dump. Same split as the graphics path.
+    const bool should_log = GPU::Logging::IsActive();
+    const bool should_dump = Settings::values.gpu_log_shader_dumps.GetValue();
+    if (should_log || should_dump) {
         const std::string shader_name = fmt::format("shader_{:016x}_compute", key.unique_hash);
-        const std::string shader_info = fmt::format("SPIR-V size: {} bytes, hash: {:016x}",
-            code.size() * sizeof(u32), key.unique_hash);
-        GPU::Logging::GPULogger::GetInstance().LogShaderCompilation(shader_name, shader_info,
-            std::span<const u32>(code.data(), code.size()));
+        if (should_log) {
+            const std::string shader_info = fmt::format("SPIR-V size: {} bytes, hash: {:016x}",
+                code.size() * sizeof(u32), key.unique_hash);
+            GPU::Logging::GPULogger::GetInstance().LogShaderCompilation(shader_name, shader_info);
+        }
+        if (should_dump) {
+            GPU::Logging::DumpSpirvShader(key.unique_hash,
+                                          std::span<const u32>(code.data(), code.size()));
+        }
     }
 
     if (device.HasDebuggingToolAttached()) {

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -270,7 +270,7 @@ void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
         });
 
         // Log draw call
-        if (Settings::values.gpu_logging_enabled.GetValue() &&
+        if (GPU::Logging::IsActive() &&
             Settings::values.gpu_log_vulkan_calls.GetValue()) {
             const std::string params = is_indexed ?
                 fmt::format("vertices={}, instances={}, firstIndex={}, baseVertex={}, baseInstance={}",
@@ -331,7 +331,7 @@ void RasterizerVulkan::DrawIndirect() {
         });
 
         // Log indirect draw call
-        if (Settings::values.gpu_logging_enabled.GetValue() &&
+        if (GPU::Logging::IsActive() &&
             Settings::values.gpu_log_vulkan_calls.GetValue()) {
             const std::string log_params = fmt::format("drawCount={}, stride={}",
                 params.max_draw_counts, params.stride);
@@ -585,7 +585,7 @@ void RasterizerVulkan::DispatchCompute() {
     scheduler.Record([dim](vk::CommandBuffer cmdbuf) { cmdbuf.Dispatch(dim[0], dim[1], dim[2]); });
 
     // Log compute dispatch
-    if (Settings::values.gpu_logging_enabled.GetValue() &&
+    if (GPU::Logging::IsActive() &&
         Settings::values.gpu_log_vulkan_calls.GetValue()) {
         const std::string params = fmt::format("groupCountX={}, groupCountY={}, groupCountZ={}",
             dim[0], dim[1], dim[2]);
@@ -1110,7 +1110,7 @@ void RasterizerVulkan::HandleTransformFeedback() {
                               regs.transform_feedback_enabled);
     if (regs.transform_feedback_enabled != 0) {
         // Log extension usage for transform feedback
-        if (Settings::values.gpu_logging_enabled.GetValue()) {
+        if (GPU::Logging::IsActive()) {
             GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
                 "VK_EXT_transform_feedback", "HandleTransformFeedback");
         }

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -181,7 +181,7 @@ void Scheduler::RequestRenderpass(const Framebuffer* framebuffer) {
     state.render_area = render_area;
 
     // Log render pass begin
-    if (Settings::values.gpu_logging_enabled.GetValue() &&
+    if (GPU::Logging::IsActive() &&
         Settings::values.gpu_log_vulkan_calls.GetValue()) {
         const std::string render_pass_info = fmt::format(
             "renderArea={}x{}, numImages={}",
@@ -292,7 +292,7 @@ u64 Scheduler::SubmitExecution(VkSemaphore signal_semaphore, VkSemaphore wait_se
                     cmdbuf, upload_cmdbuf, signal_semaphore, wait_semaphore, signal_value)) {
         case VK_SUCCESS:
             // Log successful queue submission
-            if (Settings::values.gpu_logging_enabled.GetValue() &&
+            if (GPU::Logging::IsActive() &&
                 Settings::values.gpu_log_vulkan_calls.GetValue()) {
                 GPU::Logging::GPULogger::GetInstance().LogVulkanCall(
                     "vkQueueSubmit", "", VK_SUCCESS);
@@ -335,7 +335,7 @@ void Scheduler::EndRenderPass()
         query_cache->CounterClose(VideoCommon::QueryType::StreamingByteCount);
 
         // Log render pass end
-        if (Settings::values.gpu_logging_enabled.GetValue() &&
+        if (GPU::Logging::IsActive() &&
             Settings::values.gpu_log_vulkan_calls.GetValue()) {
             GPU::Logging::GPULogger::GetInstance().LogRenderPassEnd();
         }

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -2332,7 +2332,7 @@ Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& t
     if (has_custom_border_colors) {
         pnext = &border_ci;
         // Log extension usage for custom border color
-        if (Settings::values.gpu_logging_enabled.GetValue()) {
+        if (GPU::Logging::IsActive()) {
             GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
                 "VK_EXT_custom_border_color", "Sampler::Sampler");
         }

src/video_core/shader_environment.cpp

@@ -18,6 +18,7 @@
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
 #include "common/logging.h"
+#include "common/settings.h"
 #include <ranges>
 #include "shader_recompiler/environment.h"
 #include "video_core/engines/kepler_compute.h"
@@ -73,36 +74,36 @@ static Shader::TexturePixelFormat ConvertTexturePixelFormat(const Tegra::Texture
 static std::string_view StageToPrefix(Shader::Stage stage) {
     switch (stage) {
     case Shader::Stage::VertexB:
-        return "VB";
+        return "vs";
     case Shader::Stage::TessellationControl:
-        return "TC";
+        return "tc";
     case Shader::Stage::TessellationEval:
-        return "TE";
+        return "te";
     case Shader::Stage::Geometry:
-        return "GS";
+        return "gs";
     case Shader::Stage::Fragment:
-        return "FS";
+        return "fs";
     case Shader::Stage::Compute:
-        return "CS";
+        return "cs";
     case Shader::Stage::VertexA:
-        return "VA";
+        return "va";
     default:
-        return "UK";
+        return "uk";
     }
 }
 
-static void DumpImpl(u64 pipeline_hash, u64 shader_hash, std::span<const u64> code,
+static void DumpImpl(u64 /*pipeline_hash*/, u64 shader_hash, std::span<const u64> code,
                      [[maybe_unused]] u32 read_highest, [[maybe_unused]] u32 read_lowest,
                      u32 initial_offset, Shader::Stage stage) {
-    const auto shader_dir{Common::FS::GetEdenPath(Common::FS::EdenPath::DumpDir)};
-    const auto base_dir{shader_dir / "shaders"};
-    if (!Common::FS::CreateDir(shader_dir) || !Common::FS::CreateDir(base_dir)) {
-        LOG_ERROR(Common_Filesystem, "Failed to create shader dump directories");
+    const auto dump_dir{Common::FS::GetEdenPath(Common::FS::EdenPath::DumpDir)};
+    if (!Common::FS::CreateDir(dump_dir)) {
+        LOG_ERROR(Common_Filesystem, "Failed to create dump directory");
         return;
     }
     const auto prefix = StageToPrefix(stage);
-    const auto name{base_dir /
-                    fmt::format("{:016x}_{}_{:016x}.ash", pipeline_hash, prefix, shader_hash)};
+    const auto name{dump_dir /
+                    fmt::format("{:016x}_{:016x}_{}.ash",
+                                Settings::GetCurrentProgramID(), shader_hash, prefix)};
     std::fstream shader_file(name, std::ios::out | std::ios::binary);
     ASSERT(initial_offset % sizeof(u64) == 0);
     const size_t jump_index = initial_offset / sizeof(u64);

src/video_core/vulkan_common/vulkan_debug_callback.cpp

@@ -76,7 +76,7 @@ VkBool32 DebugUtilCallback(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
     }
 
     // Route to GPU logger for tracking Vulkan validation messages
-    if (Settings::values.gpu_logging_enabled.GetValue() &&
+    if (GPU::Logging::IsActive() &&
         Settings::values.gpu_log_vulkan_calls.GetValue()) {
         // Convert severity to result code for logging (negative = error)
         int result_code = 0;

src/video_core/vulkan_common/vulkan_device.cpp

@@ -1518,7 +1518,10 @@ std::vector<VkDeviceQueueCreateInfo> Device::GetDeviceQueueCreateInfos() const {
 }
 
 void Device::InitializeGPULogging() {
-    if (!Settings::values.gpu_logging_enabled.GetValue()) {
+    // Get log level from settings — Off is the disable.
+    const auto log_level = static_cast<GPU::Logging::LogLevel>(
+        static_cast<u32>(Settings::values.gpu_log_level.GetValue()));
+    if (log_level == GPU::Logging::LogLevel::Off) {
         return;
     }
 
@@ -1532,18 +1535,12 @@ void Device::InitializeGPULogging() {
         detected_driver = GPU::Logging::DriverType::Qualcomm;
     }
 
-    // Get log level from settings
-    const auto log_level = static_cast<GPU::Logging::LogLevel>(
-        static_cast<u32>(Settings::values.gpu_log_level.GetValue()));
-
     // Initialize GPU logger
     GPU::Logging::GPULogger::GetInstance().Initialize(log_level, detected_driver);
 
     // Configure feature flags
     GPU::Logging::GPULogger::GetInstance().EnableVulkanCallTracking(
         Settings::values.gpu_log_vulkan_calls.GetValue());
-    GPU::Logging::GPULogger::GetInstance().EnableShaderDumps(
-        Settings::values.gpu_log_shader_dumps.GetValue());
     GPU::Logging::GPULogger::GetInstance().EnableMemoryTracking(
         Settings::values.gpu_log_memory_tracking.GetValue());
     GPU::Logging::GPULogger::GetInstance().EnableDriverDebugInfo(

src/video_core/vulkan_common/vulkan_memory_allocator.cpp

@@ -111,7 +111,7 @@ namespace Vulkan {
             : allocator{alloc}, allocation{a}, memory{info.deviceMemory},
               offset{info.offset}, size{info.size}, mapped_ptr{info.pMappedData} {
         // Log GPU memory allocation
-        if (Settings::values.gpu_logging_enabled.GetValue() &&
+        if (GPU::Logging::IsActive() &&
             Settings::values.gpu_log_memory_tracking.GetValue()) {
             GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(
                 reinterpret_cast<uintptr_t>(memory),
@@ -179,7 +179,7 @@ namespace Vulkan {
     void MemoryCommit::Release() {
         if (allocation && allocator) {
             // Log GPU memory deallocation
-            if (Settings::values.gpu_logging_enabled.GetValue() &&
+            if (GPU::Logging::IsActive() &&
                 Settings::values.gpu_log_memory_tracking.GetValue() &&
                 memory != VK_NULL_HANDLE) {
                 GPU::Logging::GPULogger::GetInstance().LogMemoryDeallocation(
@@ -243,7 +243,7 @@ namespace Vulkan {
         vk::Check(vmaCreateImage(allocator, &ci, &alloc_ci, &handle, &allocation, &alloc_info));
 
         // Log GPU memory allocation for images
-        if (Settings::values.gpu_logging_enabled.GetValue() &&
+        if (GPU::Logging::IsActive() &&
             Settings::values.gpu_log_memory_tracking.GetValue()) {
             GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(
                 reinterpret_cast<uintptr_t>(alloc_info.deviceMemory),
@@ -281,7 +281,7 @@ namespace Vulkan {
         vmaGetAllocationMemoryProperties(allocator, allocation, &property_flags);
 
         // Log GPU memory allocation for buffers
-        if (Settings::values.gpu_logging_enabled.GetValue() &&
+        if (GPU::Logging::IsActive() &&
             Settings::values.gpu_log_memory_tracking.GetValue()) {
             GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(
                 reinterpret_cast<uintptr_t>(alloc_info.deviceMemory),