Replace all gflag implementations with cvar implementations

src/xenia/gpu/command_processor.cc

@@ -393,7 +393,7 @@ void CommandProcessor::IssueSwap(uint32_t frontbuffer_ptr,
   // This prevents the display from pulling the backbuffer out from under us.
   // If we skip a lot then we may need to buffer more, but as the display
   // thread should be fairly idle that shouldn't happen.
-  if (!FLAGS_vsync) {
+  if (!cvars::vsync) {
     std::lock_guard<std::mutex> lock(swap_state_.mutex);
     if (swap_state_.pending) {
       swap_state_.pending = false;
@@ -895,7 +895,7 @@ bool CommandProcessor::ExecutePacketType3_WAIT_REG_MEM(RingBuffer* reader,
       // Wait.
       if (wait >= 0x100) {
         PrepareForWait();
-        if (!FLAGS_vsync) {
+        if (!cvars::vsync) {
           // User wants it fast and dangerous.
           xe::threading::MaybeYield();
         } else {

src/xenia/gpu/gpu_flags.cc

@@ -10,10 +10,10 @@
 #include "xenia/gpu/gpu_flags.h"
 
 DEFINE_string(trace_gpu_prefix, "scratch/gpu/",
-              "Prefix path for GPU trace files.");
-DEFINE_bool(trace_gpu_stream, false, "Trace all GPU packets.");
+              "Prefix path for GPU trace files.", "GPU");
+DEFINE_bool(trace_gpu_stream, false, "Trace all GPU packets.", "GPU");
 
 DEFINE_string(dump_shaders, "",
-              "Path to write GPU shaders to as they are compiled.");
+              "Path to write GPU shaders to as they are compiled.", "GPU");
 
-DEFINE_bool(vsync, true, "Enable VSYNC.");
+DEFINE_bool(vsync, true, "Enable VSYNC.", "GPU");

src/xenia/gpu/gpu_flags.h

@@ -9,8 +9,7 @@
 
 #ifndef XENIA_GPU_GPU_FLAGS_H_
 #define XENIA_GPU_GPU_FLAGS_H_
-
-#include <gflags/gflags.h>
+#include "xenia/base/cvar.h"
 
 DECLARE_string(trace_gpu_prefix);
 DECLARE_bool(trace_gpu_stream);

src/xenia/gpu/graphics_system.cc

@@ -113,7 +113,7 @@ X_STATUS GraphicsSystem::Setup(cpu::Processor* processor,
   vsync_worker_running_ = true;
   vsync_worker_thread_ = kernel::object_ref<kernel::XHostThread>(
       new kernel::XHostThread(kernel_state_, 128 * 1024, 0, [this]() {
-        uint64_t vsync_duration = FLAGS_vsync ? 16 : 1;
+        uint64_t vsync_duration = cvars::vsync ? 16 : 1;
         uint64_t last_frame_time = Clock::QueryGuestTickCount();
         while (vsync_worker_running_) {
           uint64_t current_time = Clock::QueryGuestTickCount();
@@ -132,7 +132,7 @@ X_STATUS GraphicsSystem::Setup(cpu::Processor* processor,
   vsync_worker_thread_->set_name("GraphicsSystem Vsync");
   vsync_worker_thread_->Create();
 
-  if (FLAGS_trace_gpu_stream) {
+  if (cvars::trace_gpu_stream) {
     BeginTracing();
   }
 
@@ -270,11 +270,12 @@ void GraphicsSystem::ClearCaches() {
 }
 
 void GraphicsSystem::RequestFrameTrace() {
-  command_processor_->RequestFrameTrace(xe::to_wstring(FLAGS_trace_gpu_prefix));
+  command_processor_->RequestFrameTrace(
+      xe::to_wstring(cvars::trace_gpu_prefix));
 }
 
 void GraphicsSystem::BeginTracing() {
-  command_processor_->BeginTracing(xe::to_wstring(FLAGS_trace_gpu_prefix));
+  command_processor_->BeginTracing(xe::to_wstring(cvars::trace_gpu_prefix));
 }
 
 void GraphicsSystem::EndTracing() { command_processor_->EndTracing(); }

src/xenia/gpu/shader_compiler_main.cc

@@ -7,13 +7,12 @@
  ******************************************************************************
  */
 
-#include <gflags/gflags.h>
-
 #include <cinttypes>
 #include <cstring>
 #include <string>
 #include <vector>
 
+#include "xenia/base/cvar.h"
 #include "xenia/base/logging.h"
 #include "xenia/base/main.h"
 #include "xenia/base/string.h"
@@ -22,35 +21,36 @@
 #include "xenia/gpu/spirv_shader_translator.h"
 #include "xenia/ui/spirv/spirv_disassembler.h"
 
-DEFINE_string(shader_input, "", "Input shader binary file path.");
+DEFINE_string(shader_input, "", "Input shader binary file path.", "GPU");
 DEFINE_string(shader_input_type, "",
-              "'vs', 'ps', or unspecified to infer from the given filename.");
-DEFINE_string(shader_output, "", "Output shader file path.");
+              "'vs', 'ps', or unspecified to infer from the given filename.",
+              "GPU");
+DEFINE_string(shader_output, "", "Output shader file path.", "GPU");
 DEFINE_string(shader_output_type, "ucode",
-              "Translator to use: [ucode, glsl45, spirv, spirvtext].");
+              "Translator to use: [ucode, glsl45, spirv, spirvtext].", "GPU");
 
 namespace xe {
 namespace gpu {
 
 int shader_compiler_main(const std::vector<std::wstring>& args) {
   ShaderType shader_type;
-  if (!FLAGS_shader_input_type.empty()) {
-    if (FLAGS_shader_input_type == "vs") {
+  if (!cvars::shader_input_type.empty()) {
+    if (cvars::shader_input_type == "vs") {
       shader_type = ShaderType::kVertex;
-    } else if (FLAGS_shader_input_type == "ps") {
+    } else if (cvars::shader_input_type == "ps") {
       shader_type = ShaderType::kPixel;
     } else {
       XELOGE("Invalid --shader_input_type; must be 'vs' or 'ps'.");
       return 1;
     }
   } else {
-    auto last_dot = FLAGS_shader_input.find_last_of('.');
+    auto last_dot = cvars::shader_input.find_last_of('.');
     bool valid_type = false;
     if (last_dot != std::string::npos) {
-      if (FLAGS_shader_input.substr(last_dot) == ".vs") {
+      if (cvars::shader_input.substr(last_dot) == ".vs") {
         shader_type = ShaderType::kVertex;
         valid_type = true;
-      } else if (FLAGS_shader_input.substr(last_dot) == ".ps") {
+      } else if (cvars::shader_input.substr(last_dot) == ".ps") {
         shader_type = ShaderType::kPixel;
         valid_type = true;
       }
@@ -63,9 +63,9 @@ int shader_compiler_main(const std::vector<std::wstring>& args) {
     }
   }
 
-  auto input_file = fopen(FLAGS_shader_input.c_str(), "rb");
+  auto input_file = fopen(cvars::shader_input.c_str(), "rb");
   if (!input_file) {
-    XELOGE("Unable to open input file: %s", FLAGS_shader_input.c_str());
+    XELOGE("Unable to open input file: %s", cvars::shader_input.c_str());
     return 1;
   }
   fseek(input_file, 0, SEEK_END);
@@ -76,7 +76,7 @@ int shader_compiler_main(const std::vector<std::wstring>& args) {
   fclose(input_file);
 
   XELOGI("Opened %s as a %s shader, %" PRId64 " words (%" PRId64 " bytes).",
-         FLAGS_shader_input.c_str(),
+         cvars::shader_input.c_str(),
          shader_type == ShaderType::kVertex ? "vertex" : "pixel",
          ucode_dwords.size(), ucode_dwords.size() * 4);
 
@@ -86,10 +86,10 @@ int shader_compiler_main(const std::vector<std::wstring>& args) {
       shader_type, ucode_data_hash, ucode_dwords.data(), ucode_dwords.size());
 
   std::unique_ptr<ShaderTranslator> translator;
-  if (FLAGS_shader_output_type == "spirv" ||
-      FLAGS_shader_output_type == "spirvtext") {
+  if (cvars::shader_output_type == "spirv" ||
+      cvars::shader_output_type == "spirvtext") {
     translator = std::make_unique<SpirvShaderTranslator>();
-  } else if (FLAGS_shader_output_type == "glsl45") {
+  } else if (cvars::shader_output_type == "glsl45") {
     translator = std::make_unique<GlslShaderTranslator>(
         GlslShaderTranslator::Dialect::kGL45);
   } else {
@@ -102,7 +102,7 @@ int shader_compiler_main(const std::vector<std::wstring>& args) {
   size_t source_data_size = shader->translated_binary().size();
 
   std::unique_ptr<xe::ui::spirv::SpirvDisassembler::Result> spirv_disasm_result;
-  if (FLAGS_shader_output_type == "spirvtext") {
+  if (cvars::shader_output_type == "spirvtext") {
     // Disassemble SPIRV.
     spirv_disasm_result = xe::ui::spirv::SpirvDisassembler().Disassemble(
         reinterpret_cast<const uint32_t*>(source_data), source_data_size / 4);
@@ -110,8 +110,8 @@ int shader_compiler_main(const std::vector<std::wstring>& args) {
     source_data_size = std::strlen(spirv_disasm_result->text()) + 1;
   }
 
-  if (!FLAGS_shader_output.empty()) {
-    auto output_file = fopen(FLAGS_shader_output.c_str(), "wb");
+  if (!cvars::shader_output.empty()) {
+    auto output_file = fopen(cvars::shader_output.c_str(), "wb");
     fwrite(source_data, 1, source_data_size, output_file);
     fclose(output_file);
   }

src/xenia/gpu/spirv_shader_translator.cc

@@ -9,19 +9,20 @@
 
 #include "xenia/gpu/spirv_shader_translator.h"
 
-#include <gflags/gflags.h>
-
 #include <algorithm>
 #include <cfloat>
 #include <cstddef>
 #include <cstring>
 #include <vector>
 
+#include "xenia/base/cvar.h"
 #include "xenia/base/logging.h"
 #include "xenia/base/math.h"
 
-DEFINE_bool(spv_validate, false, "Validate SPIR-V shaders after generation");
-DEFINE_bool(spv_disasm, false, "Disassemble SPIR-V shaders after generation");
+DEFINE_bool(spv_validate, false, "Validate SPIR-V shaders after generation",
+            "GPU");
+DEFINE_bool(spv_disasm, false, "Disassemble SPIR-V shaders after generation",
+            "GPU");
 
 namespace xe {
 namespace gpu {
@@ -667,7 +668,7 @@ std::vector<uint8_t> SpirvShaderTranslator::CompleteTranslation() {
 
 void SpirvShaderTranslator::PostTranslation(Shader* shader) {
   // Validation.
-  if (FLAGS_spv_validate) {
+  if (cvars::spv_validate) {
     auto validation = validator_.Validate(
         reinterpret_cast<const uint32_t*>(shader->translated_binary().data()),
         shader->translated_binary().size() / sizeof(uint32_t));
@@ -677,7 +678,7 @@ void SpirvShaderTranslator::PostTranslation(Shader* shader) {
     }
   }
 
-  if (FLAGS_spv_disasm) {
+  if (cvars::spv_disasm) {
     // TODO(benvanik): only if needed? could be slowish.
     auto disasm = disassembler_.Disassemble(
         reinterpret_cast<const uint32_t*>(shader->translated_binary().data()),

src/xenia/gpu/texture_dump.cc

@@ -7,13 +7,12 @@
  ******************************************************************************
  */
 
-#include <gflags/gflags.h>
-
+#include "xenia/base/cvar.h"
 #include "xenia/base/logging.h"
 #include "xenia/base/math.h"
 #include "xenia/gpu/texture_info.h"
 
-DEFINE_bool(texture_dump, false, "Dump textures to DDS");
+DEFINE_bool(texture_dump, false, "Dump textures to DDS", "GPU");
 
 namespace xe {
 namespace gpu {

src/xenia/gpu/trace_dump.cc

@@ -9,8 +9,6 @@
 
 #include "xenia/gpu/trace_dump.h"
 
-#include <gflags/gflags.h>
-
 #include "third_party/stb/stb_image_write.h"
 #include "xenia/base/logging.h"
 #include "xenia/base/profiling.h"
@@ -28,8 +26,9 @@
 #undef _CRT_NONSTDC_NO_DEPRECATE
 #include "third_party/stb/stb_image_write.h"
 
-DEFINE_string(target_trace_file, "", "Specifies the trace file to load.");
-DEFINE_string(trace_dump_path, "", "Output path for dumped files.");
+DEFINE_string(target_trace_file, "", "Specifies the trace file to load.",
+              "GPU");
+DEFINE_string(trace_dump_path, "", "Output path for dumped files.", "GPU");
 
 namespace xe {
 namespace gpu {
@@ -44,11 +43,11 @@ int TraceDump::Main(const std::vector<std::wstring>& args) {
   // Grab path from the flag or unnamed argument.
   std::wstring path;
   std::wstring output_path;
-  if (!FLAGS_target_trace_file.empty()) {
+  if (!cvars::target_trace_file.empty()) {
     // Passed as a named argument.
     // TODO(benvanik): find something better than gflags that supports
     // unicode.
-    path = xe::to_wstring(FLAGS_target_trace_file);
+    path = xe::to_wstring(cvars::target_trace_file);
   } else if (args.size() >= 2) {
     // Passed as an unnamed argument.
     path = args[1];
@@ -79,7 +78,7 @@ int TraceDump::Main(const std::vector<std::wstring>& args) {
   // Root file name for outputs.
   if (output_path.empty()) {
     base_output_path_ =
-        xe::fix_path_separators(xe::to_wstring(FLAGS_trace_dump_path));
+        xe::fix_path_separators(xe::to_wstring(cvars::trace_dump_path));
 
     std::wstring output_name =
         xe::find_name_from_path(xe::fix_path_separators(path));

src/xenia/gpu/trace_viewer.cc

@@ -9,8 +9,6 @@
 
 #include "xenia/gpu/trace_viewer.h"
 
-#include <gflags/gflags.h>
-
 #include <cinttypes>
 
 #include "third_party/half/include/half.hpp"
@@ -32,7 +30,8 @@
 #include "xenia/ui/window.h"
 #include "xenia/xbox.h"
 
-DEFINE_string(target_trace_file, "", "Specifies the trace file to load.");
+DEFINE_string(target_trace_file, "", "Specifies the trace file to load.",
+              "GPU");
 
 namespace xe {
 namespace gpu {
@@ -53,11 +52,11 @@ TraceViewer::~TraceViewer() = default;
 int TraceViewer::Main(const std::vector<std::wstring>& args) {
   // Grab path from the flag or unnamed argument.
   std::wstring path;
-  if (!FLAGS_target_trace_file.empty()) {
+  if (!cvars::target_trace_file.empty()) {
     // Passed as a named argument.
     // TODO(benvanik): find something better than gflags that supports
     // unicode.
-    path = xe::to_wstring(FLAGS_target_trace_file);
+    path = xe::to_wstring(cvars::target_trace_file);
   } else if (args.size() >= 2) {
     // Passed as an unnamed argument.
     path = args[1];

src/xenia/gpu/vulkan/pipeline_cache.cc

@@ -347,7 +347,7 @@ VkPipeline PipelineCache::GetPipeline(const RenderState* render_state,
   }
 
   // Dump shader disassembly.
-  if (FLAGS_vulkan_dump_disasm) {
+  if (cvars::vulkan_dump_disasm) {
     if (device_->HasEnabledExtension(VK_AMD_SHADER_INFO_EXTENSION_NAME)) {
       DumpShaderDisasmAMD(pipeline);
     } else if (device_->device_info().properties.vendorID == 0x10DE) {
@@ -387,8 +387,8 @@ bool PipelineCache::TranslateShader(VulkanShader* shader,
   }
 
   // Dump shader files if desired.
-  if (!FLAGS_dump_shaders.empty()) {
-    shader->Dump(FLAGS_dump_shaders, "vk");
+  if (!cvars::dump_shaders.empty()) {
+    shader->Dump(cvars::dump_shaders, "vk");
   }
 
   return shader->is_valid();
@@ -1398,7 +1398,7 @@ PipelineCache::UpdateStatus PipelineCache::UpdateMultisampleState() {
   // PA_SU_SC_MODE_CNTL MSAA_ENABLE (0x10000)
   // If set, all samples will be sampled at set locations. Otherwise, they're
   // all sampled from the pixel center.
-  if (FLAGS_vulkan_native_msaa) {
+  if (cvars::vulkan_native_msaa) {
     auto msaa_num_samples =
         static_cast<MsaaSamples>((regs.rb_surface_info >> 16) & 0x3);
     switch (msaa_num_samples) {

src/xenia/gpu/vulkan/render_cache.cc

@@ -194,7 +194,7 @@ VkResult CachedTileView::Initialize(VkCommandBuffer command_buffer) {
   image_info.extent.depth = 1;
   image_info.mipLevels = 1;
   image_info.arrayLayers = 1;
-  if (FLAGS_vulkan_native_msaa) {
+  if (cvars::vulkan_native_msaa) {
     auto msaa_samples = static_cast<MsaaSamples>(key.msaa_samples);
     switch (msaa_samples) {
       case MsaaSamples::k1X:
@@ -422,7 +422,7 @@ CachedRenderPass::~CachedRenderPass() {
 
 VkResult CachedRenderPass::Initialize() {
   VkSampleCountFlagBits sample_count;
-  if (FLAGS_vulkan_native_msaa) {
+  if (cvars::vulkan_native_msaa) {
     switch (config.surface_msaa) {
       case MsaaSamples::k1X:
         sample_count = VK_SAMPLE_COUNT_1_BIT;
@@ -534,7 +534,7 @@ VkResult CachedRenderPass::Initialize() {
 bool CachedRenderPass::IsCompatible(
     const RenderConfiguration& desired_config) const {
   if (config.surface_msaa != desired_config.surface_msaa &&
-      FLAGS_vulkan_native_msaa) {
+      cvars::vulkan_native_msaa) {
     return false;
   }
 

src/xenia/gpu/vulkan/texture_cache.cc

@@ -1040,7 +1040,7 @@ bool TextureCache::UploadTexture(VkCommandBuffer command_buffer,
     unpack_offset += ComputeMipStorage(src, mip);
   }
 
-  if (FLAGS_texture_dump) {
+  if (cvars::texture_dump) {
     TextureDump(src, unpack_buffer, unpack_length);
   }
 

src/xenia/gpu/vulkan/vulkan_command_processor.cc

@@ -356,7 +356,7 @@ void VulkanCommandProcessor::BeginFrame() {
   // The capture will end when these commands are submitted to the queue.
   static uint32_t frame = 0;
   if (device_->is_renderdoc_attached() && !capturing_ &&
-      (FLAGS_vulkan_renderdoc_capture_all || trace_requested_)) {
+      (cvars::vulkan_renderdoc_capture_all || trace_requested_)) {
     if (queue_mutex_) {
       queue_mutex_->lock();
     }

src/xenia/gpu/vulkan/vulkan_gpu_flags.cc

@@ -10,7 +10,7 @@
 #include "xenia/gpu/vulkan/vulkan_gpu_flags.h"
 
 DEFINE_bool(vulkan_renderdoc_capture_all, false,
-            "Capture everything with RenderDoc.");
-DEFINE_bool(vulkan_native_msaa, false, "Use native MSAA");
+            "Capture everything with RenderDoc.", "Vulkan");
+DEFINE_bool(vulkan_native_msaa, false, "Use native MSAA", "Vulkan");
 DEFINE_bool(vulkan_dump_disasm, false,
-            "Dump shader disassembly. NVIDIA only supported.");
+            "Dump shader disassembly. NVIDIA only supported.", "Vulkan");

src/xenia/gpu/vulkan/vulkan_gpu_flags.h

@@ -10,9 +10,8 @@
 #ifndef XENIA_GPU_VULKAN_VULKAN_GPU_FLAGS_H_
 #define XENIA_GPU_VULKAN_VULKAN_GPU_FLAGS_H_
 
-#include <gflags/gflags.h>
-
 #define FINE_GRAINED_DRAW_SCOPES 1
+#include "xenia/base/cvar.h"
 
 DECLARE_bool(vulkan_renderdoc_capture_all);
 DECLARE_bool(vulkan_native_msaa);