GPU: Add wireframe rendering/overlay

src/core/fullscreen_ui.cpp

@@ -2872,8 +2872,8 @@ void FullscreenUI::DrawBIOSSettingsPage()
                     FSUI_CSTR("Patches the BIOS to skip the boot animation. Safe to enable."), "BIOS", "PatchFastBoot",
                     Settings::DEFAULT_FAST_BOOT_VALUE);
   DrawToggleSetting(bsi, FSUI_CSTR("Enable TTY Logging"),
-                    FSUI_CSTR("Logs BIOS calls to printf(). Not all games contain debugging messages."),
-                    "BIOS", "TTYLogging", false);
+                    FSUI_CSTR("Logs BIOS calls to printf(). Not all games contain debugging messages."), "BIOS",
+                    "TTYLogging", false);
 
   EndMenuButtons();
 }
@@ -4695,6 +4695,11 @@ void FullscreenUI::DrawAdvancedSettingsPage()
     bsi, FSUI_CSTR("Stretch Display Vertically"),
     FSUI_CSTR("Stretches the display to match the aspect ratio by multiplying vertically instead of horizontally."),
     "Display", "StretchVertically", false);
+  DrawEnumSetting(bsi, FSUI_CSTR("Wireframe Rendering"),
+                  FSUI_CSTR("Overlays or replaces normal triangle drawing with a wireframe/line view."), "GPU",
+                  "WireframeMode", GPUWireframeMode::Disabled, &Settings::ParseGPUWireframeMode,
+                  &Settings::GetGPUWireframeModeName, &Settings::GetGPUWireframeModeDisplayName,
+                  GPUWireframeMode::Count);
 
   MenuHeading(FSUI_CSTR("PGXP Settings"));
 

src/core/gpu_hw.cpp

@@ -45,6 +45,11 @@ ALWAYS_INLINE static constexpr std::tuple<T, T> MinMax(T v1, T v2)
     return std::tie(v1, v2);
 }
 
+ALWAYS_INLINE static u32 GetMaxResolutionScale()
+{
+  return g_gpu_device->GetMaxTextureSize() / VRAM_WIDTH;
+}
+
 ALWAYS_INLINE static bool ShouldUseUVLimits()
 {
   // We only need UV limits if PGXP is enabled, or texture filtering is enabled.
@@ -57,7 +62,7 @@ ALWAYS_INLINE static bool ShouldDisableColorPerspective()
 }
 
 /// Returns true if the specified texture filtering mode requires dual-source blending.
-static bool TextureFilterRequiresDualSourceBlend(GPUTextureFilter filter)
+ALWAYS_INLINE static bool TextureFilterRequiresDualSourceBlend(GPUTextureFilter filter)
 {
   return (filter == GPUTextureFilter::Bilinear || filter == GPUTextureFilter::JINC2 || filter == GPUTextureFilter::xBR);
 }
@@ -148,42 +153,50 @@ bool GPU_HW::Initialize()
     return false;
 
   const GPUDevice::Features features = g_gpu_device->GetFeatures();
-  m_max_resolution_scale = g_gpu_device->GetMaxTextureSize() / VRAM_WIDTH;
-  m_supports_dual_source_blend = features.dual_source_blend;
-  m_supports_per_sample_shading = features.per_sample_shading;
-  m_supports_disable_color_perspective = features.noperspective_interpolation;
 
   m_resolution_scale = CalculateResolutionScale();
   m_multisamples = std::min(g_settings.gpu_multisamples, g_gpu_device->GetMaxMultisamples());
-  m_per_sample_shading = g_settings.gpu_per_sample_shading && m_supports_per_sample_shading;
+  m_per_sample_shading = g_settings.gpu_per_sample_shading && features.per_sample_shading;
   m_true_color = g_settings.gpu_true_color;
   m_scaled_dithering = g_settings.gpu_scaled_dithering;
   m_texture_filtering = g_settings.gpu_texture_filter;
   m_using_uv_limits = ShouldUseUVLimits();
   m_chroma_smoothing = g_settings.gpu_24bit_chroma_smoothing;
   m_downsample_mode = GetDownsampleMode(m_resolution_scale);
-  m_disable_color_perspective = m_supports_disable_color_perspective && ShouldDisableColorPerspective();
+  m_wireframe_mode = g_settings.gpu_wireframe_mode;
+  m_disable_color_perspective = features.noperspective_interpolation && ShouldDisableColorPerspective();
 
   if (m_multisamples != g_settings.gpu_multisamples)
   {
-    Host::AddFormattedOSDMessage(20.0f, TRANSLATE("OSDMessage", "%ux MSAA is not supported, using %ux instead."),
+    Host::AddFormattedOSDMessage(Host::OSD_CRITICAL_ERROR_DURATION,
+                                 TRANSLATE("OSDMessage", "%ux MSAA is not supported, using %ux instead."),
                                  g_settings.gpu_multisamples, m_multisamples);
   }
   if (!m_per_sample_shading && g_settings.gpu_per_sample_shading)
   {
     Host::AddOSDMessage(TRANSLATE_STR("OSDMessage", "SSAA is not supported, using MSAA instead."), 20.0f);
   }
-  if (!m_supports_dual_source_blend && TextureFilterRequiresDualSourceBlend(m_texture_filtering))
+  if (!features.dual_source_blend && TextureFilterRequiresDualSourceBlend(m_texture_filtering))
   {
     Host::AddFormattedOSDMessage(
-      20.0f, TRANSLATE("OSDMessage", "Texture filter '%s' is not supported with the current renderer."),
+      Host::OSD_CRITICAL_ERROR_DURATION,
+      TRANSLATE("OSDMessage", "Texture filter '%s' is not supported with the current renderer."),
       Settings::GetTextureFilterDisplayName(m_texture_filtering));
     m_texture_filtering = GPUTextureFilter::Nearest;
   }
 
-  if (!m_supports_disable_color_perspective && !ShouldDisableColorPerspective())
+  if (!features.noperspective_interpolation && !ShouldDisableColorPerspective())
     Log_WarningPrint("Disable color perspective not supported, but should be used.");
 
+  if (!features.geometry_shaders && m_wireframe_mode != GPUWireframeMode::Disabled)
+  {
+    Host::AddOSDMessage(
+      TRANSLATE("OSDMessage",
+                "Geometry shaders are not supported by your GPU, and are required for wireframe rendering."),
+      Host::OSD_CRITICAL_ERROR_DURATION);
+    m_wireframe_mode = GPUWireframeMode::Disabled;
+  }
+
   m_pgxp_depth_buffer = g_settings.UsingPGXPDepthBuffer();
 
   UpdateSoftwareRenderer(false);
@@ -290,12 +303,16 @@ void GPU_HW::UpdateSettings(const Settings& old_settings)
 {
   GPU::UpdateSettings(old_settings);
 
+  const GPUDevice::Features features = g_gpu_device->GetFeatures();
+
   const u32 resolution_scale = CalculateResolutionScale();
   const u32 multisamples = std::min(g_settings.gpu_multisamples, g_gpu_device->GetMaxMultisamples());
-  const bool per_sample_shading = g_settings.gpu_per_sample_shading && m_supports_per_sample_shading;
+  const bool per_sample_shading = g_settings.gpu_per_sample_shading && features.noperspective_interpolation;
   const GPUDownsampleMode downsample_mode = GetDownsampleMode(resolution_scale);
+  const GPUWireframeMode wireframe_mode =
+    features.geometry_shaders ? g_settings.gpu_wireframe_mode : GPUWireframeMode::Disabled;
   const bool use_uv_limits = ShouldUseUVLimits();
-  const bool disable_color_perspective = m_supports_disable_color_perspective && ShouldDisableColorPerspective();
+  const bool disable_color_perspective = features.noperspective_interpolation && ShouldDisableColorPerspective();
 
   // TODO: Use old_settings
   const bool framebuffer_changed =
@@ -305,7 +322,8 @@ void GPU_HW::UpdateSettings(const Settings& old_settings)
      m_true_color != g_settings.gpu_true_color || m_per_sample_shading != per_sample_shading ||
      m_scaled_dithering != g_settings.gpu_scaled_dithering || m_texture_filtering != g_settings.gpu_texture_filter ||
      m_using_uv_limits != use_uv_limits || m_chroma_smoothing != g_settings.gpu_24bit_chroma_smoothing ||
-     m_downsample_mode != downsample_mode || m_pgxp_depth_buffer != g_settings.UsingPGXPDepthBuffer() ||
+     m_downsample_mode != downsample_mode || m_wireframe_mode != wireframe_mode ||
+     m_pgxp_depth_buffer != g_settings.UsingPGXPDepthBuffer() ||
      m_disable_color_perspective != disable_color_perspective);
 
   if (m_resolution_scale != resolution_scale)
@@ -348,6 +366,7 @@ void GPU_HW::UpdateSettings(const Settings& old_settings)
   m_using_uv_limits = use_uv_limits;
   m_chroma_smoothing = g_settings.gpu_24bit_chroma_smoothing;
   m_downsample_mode = downsample_mode;
+  m_wireframe_mode = wireframe_mode;
   m_disable_color_perspective = disable_color_perspective;
 
   if (!m_supports_dual_source_blend && TextureFilterRequiresDualSourceBlend(m_texture_filtering))
@@ -387,10 +406,12 @@ void GPU_HW::UpdateSettings(const Settings& old_settings)
 
 u32 GPU_HW::CalculateResolutionScale() const
 {
+  const u32 max_resolution_scale = GetMaxResolutionScale();
+
   u32 scale;
   if (g_settings.gpu_resolution_scale != 0)
   {
-    scale = std::clamp<u32>(g_settings.gpu_resolution_scale, 1, m_max_resolution_scale);
+    scale = std::clamp<u32>(g_settings.gpu_resolution_scale, 1, max_resolution_scale);
   }
   else
   {
@@ -404,7 +425,7 @@ u32 GPU_HW::CalculateResolutionScale() const
       static_cast<s32>(std::ceil(static_cast<float>(g_gpu_device->GetWindowHeight()) / height));
     Log_InfoPrintf("Height = %d, preferred scale = %d", height, preferred_scale);
 
-    scale = static_cast<u32>(std::clamp<s32>(preferred_scale, 1, m_max_resolution_scale));
+    scale = static_cast<u32>(std::clamp<s32>(preferred_scale, 1, max_resolution_scale));
   }
 
   if (g_settings.gpu_downsample_mode == GPUDownsampleMode::Adaptive && scale > 1 && !Common::IsPow2(scale))
@@ -474,7 +495,7 @@ std::tuple<u32, u32> GPU_HW::GetFullDisplayResolution(bool scaled /* = true */)
 void GPU_HW::PrintSettingsToLog()
 {
   Log_InfoPrintf("Resolution Scale: %u (%ux%u), maximum %u", m_resolution_scale, VRAM_WIDTH * m_resolution_scale,
-                 VRAM_HEIGHT * m_resolution_scale, m_max_resolution_scale);
+                 VRAM_HEIGHT * m_resolution_scale, GetMaxResolutionScale());
   Log_InfoPrintf("Multisampling: %ux%s", m_multisamples, m_per_sample_shading ? " (per sample shading)" : "");
   Log_InfoPrintf("Dithering: %s%s", m_true_color ? "Disabled" : "Enabled",
                  (!m_true_color && m_scaled_dithering) ? " (Scaled)" : "");
@@ -483,6 +504,7 @@ void GPU_HW::PrintSettingsToLog()
   Log_InfoPrintf("Using UV limits: %s", m_using_uv_limits ? "YES" : "NO");
   Log_InfoPrintf("Depth buffer: %s", m_pgxp_depth_buffer ? "YES" : "NO");
   Log_InfoPrintf("Downsampling: %s", Settings::GetDownsampleModeDisplayName(m_downsample_mode));
+  Log_InfoPrintf("Wireframe rendering: %s", Settings::GetGPUWireframeModeDisplayName(m_wireframe_mode));
   Log_InfoPrintf("Using software renderer for readbacks: %s", m_sw_renderer ? "YES" : "NO");
 }
 
@@ -772,6 +794,39 @@ bool GPU_HW::CompilePipelines()
     }
   }
 
+  if (m_wireframe_mode != GPUWireframeMode::Disabled)
+  {
+    std::unique_ptr<GPUShader> gs =
+      g_gpu_device->CreateShader(GPUShaderStage::Geometry, shadergen.GenerateWireframeGeometryShader());
+    std::unique_ptr<GPUShader> fs =
+      g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GenerateWireframeFragmentShader());
+    if (!gs || !fs)
+      return false;
+
+    GL_OBJECT_NAME(gs, "Batch Wireframe Geometry Shader");
+    GL_OBJECT_NAME(fs, "Batch Wireframe Fragment Shader");
+
+    plconfig.input_layout.vertex_attributes =
+      gsl::span<const GPUPipeline::VertexAttribute>(vertex_attributes, NUM_BATCH_VERTEX_ATTRIBUTES);
+    plconfig.blend = (m_wireframe_mode == GPUWireframeMode::OverlayWireframe) ?
+                       GPUPipeline::BlendState::GetAlphaBlendingState() :
+                       GPUPipeline::BlendState::GetNoBlendingState();
+    plconfig.blend.write_mask = 0x7;
+    plconfig.depth = GPUPipeline::DepthState::GetNoTestsState();
+    plconfig.vertex_shader = batch_vertex_shaders[0].get();
+    plconfig.geometry_shader = gs.get();
+    plconfig.fragment_shader = fs.get();
+
+    if (!(m_wireframe_pipeline = g_gpu_device->CreatePipeline(plconfig)))
+      return false;
+
+    GL_OBJECT_NAME(m_wireframe_pipeline, "Batch Wireframe Pipeline");
+
+    plconfig.vertex_shader = nullptr;
+    plconfig.geometry_shader = nullptr;
+    plconfig.fragment_shader = nullptr;
+  }
+
   batch_shader_guard.Run();
 
   std::unique_ptr<GPUShader> fullscreen_quad_vertex_shader =
@@ -1026,6 +1081,8 @@ void GPU_HW::DestroyPipelines()
 {
   static constexpr auto destroy = [](std::unique_ptr<GPUPipeline>& p) { p.reset(); };
 
+  m_wireframe_pipeline.reset();
+
   m_batch_pipelines.enumerate(destroy);
 
   m_vram_fill_pipelines.enumerate(destroy);
@@ -1136,7 +1193,7 @@ void GPU_HW::UnmapBatchVertexPointer(u32 used_vertices)
   m_batch_current_vertex_ptr = nullptr;
 }
 
-void GPU_HW::DrawBatchVertices(BatchRenderMode render_mode, u32 base_vertex, u32 num_vertices)
+void GPU_HW::DrawBatchVertices(BatchRenderMode render_mode, u32 num_vertices, u32 base_vertex)
 {
   // [depth_test][render_mode][texture_mode][transparency_mode][dithering][interlacing]
   const u8 depth_test = m_batch.use_depth_buffer ? static_cast<u8>(2) : BoolToUInt8(m_batch.check_mask_before_draw);
@@ -2365,16 +2422,26 @@ void GPU_HW::FlushRender()
     m_batch_ubo_dirty = false;
   }
 
+  if (m_wireframe_mode != GPUWireframeMode::OnlyWireframe)
+  {
     if (NeedsTwoPassRendering())
     {
       m_renderer_stats.num_batches += 2;
-    DrawBatchVertices(BatchRenderMode::OnlyOpaque, m_batch_base_vertex, vertex_count);
-    DrawBatchVertices(BatchRenderMode::OnlyTransparent, m_batch_base_vertex, vertex_count);
+      DrawBatchVertices(BatchRenderMode::OnlyOpaque, vertex_count, m_batch_base_vertex);
+      DrawBatchVertices(BatchRenderMode::OnlyTransparent, vertex_count, m_batch_base_vertex);
     }
     else
     {
       m_renderer_stats.num_batches++;
-    DrawBatchVertices(m_batch.GetRenderMode(), m_batch_base_vertex, vertex_count);
+      DrawBatchVertices(m_batch.GetRenderMode(), vertex_count, m_batch_base_vertex);
+    }
+  }
+
+  if (m_wireframe_mode != GPUWireframeMode::Disabled)
+  {
+    m_renderer_stats.num_batches++;
+    g_gpu_device->SetPipeline(m_wireframe_pipeline.get());
+    g_gpu_device->Draw(vertex_count, m_batch_base_vertex);
   }
 }
 

src/core/gpu_hw.h

@@ -157,7 +157,7 @@ private:
   void SetScissor();
   void MapBatchVertexPointer(u32 required_vertices);
   void UnmapBatchVertexPointer(u32 used_vertices);
-  void DrawBatchVertices(BatchRenderMode render_mode, u32 base_vertex, u32 num_vertices);
+  void DrawBatchVertices(BatchRenderMode render_mode, u32 num_vertices, u32 base_vertex);
   void ClearDisplay() override;
   void UpdateDisplay() override;
 
@@ -266,24 +266,22 @@ private:
 
   u32 m_resolution_scale = 1;
   u32 m_multisamples = 1;
-  u32 m_max_resolution_scale = 1;
-  bool m_true_color = true;
 
   union
   {
-    BitField<u8, bool, 0, 1> m_supports_per_sample_shading;
-    BitField<u8, bool, 1, 1> m_supports_dual_source_blend;
-    BitField<u8, bool, 2, 1> m_supports_disable_color_perspective;
-    BitField<u8, bool, 3, 1> m_per_sample_shading;
-    BitField<u8, bool, 4, 1> m_scaled_dithering;
-    BitField<u8, bool, 5, 1> m_chroma_smoothing;
-    BitField<u8, bool, 6, 1> m_disable_color_perspective;
+    BitField<u8, bool, 0, 1> m_supports_dual_source_blend;
+    BitField<u8, bool, 1, 1> m_per_sample_shading;
+    BitField<u8, bool, 2, 1> m_scaled_dithering;
+    BitField<u8, bool, 3, 1> m_chroma_smoothing;
+    BitField<u8, bool, 4, 1> m_disable_color_perspective;
 
     u8 bits = 0;
   };
 
   GPUTextureFilter m_texture_filtering = GPUTextureFilter::Nearest;
   GPUDownsampleMode m_downsample_mode = GPUDownsampleMode::Disabled;
+  GPUWireframeMode m_wireframe_mode = GPUWireframeMode::Disabled;
+  bool m_true_color = true;
   bool m_using_uv_limits = false;
   bool m_pgxp_depth_buffer = false;
 
@@ -298,6 +296,7 @@ private:
 
   // [depth_test][render_mode][texture_mode][transparency_mode][dithering][interlacing]
   DimensionalArray<std::unique_ptr<GPUPipeline>, 2, 2, 5, 9, 4, 3> m_batch_pipelines{};
+  std::unique_ptr<GPUPipeline> m_wireframe_pipeline;
 
   // [wrapped][interlaced]
   DimensionalArray<std::unique_ptr<GPUPipeline>, 2, 2> m_vram_fill_pipelines{};

src/core/gpu_hw_shadergen.cpp

@@ -1087,6 +1087,96 @@ float3 SampleVRAM24Smoothed(uint2 icoords)
   return ss.str();
 }
 
+std::string GPU_HW_ShaderGen::GenerateWireframeGeometryShader()
+{
+  std::stringstream ss;
+  WriteHeader(ss);
+  WriteCommonFunctions(ss);
+
+  if (m_glsl)
+  {
+    ss << R"(
+layout(triangles) in;
+layout(line_strip, max_vertices = 6) out;
+
+void main()
+{
+  gl_Position = gl_in[0].gl_Position;
+  EmitVertex();
+  gl_Position = gl_in[1].gl_Position;
+  EmitVertex();
+  EndPrimitive();
+  gl_Position = gl_in[1].gl_Position;
+  EmitVertex();
+  gl_Position = gl_in[2].gl_Position;
+  EmitVertex();
+  EndPrimitive();
+  gl_Position = gl_in[2].gl_Position;
+  EmitVertex();
+  gl_Position = gl_in[0].gl_Position;
+  EmitVertex();
+  EndPrimitive();
+}
+)";
+  }
+  else
+  {
+    ss << R"(
+struct GSInput
+{
+  float4 col0 : COLOR0;
+  float4 pos : SV_Position;
+};
+
+struct GSOutput
+{
+  float4 pos : SV_Position;
+};
+
+GSOutput GetVertex(GSInput vi)
+{
+  GSOutput vo;
+  vo.pos = vi.pos;
+  return vo;
+}
+
+[maxvertexcount(6)]
+void main(triangle GSInput input[3], inout LineStream<GSOutput> output)
+{
+  output.Append(GetVertex(input[0]));
+  output.Append(GetVertex(input[1]));
+  output.RestartStrip();
+
+  output.Append(GetVertex(input[1]));
+  output.Append(GetVertex(input[2]));
+  output.RestartStrip();
+
+  output.Append(GetVertex(input[2]));
+  output.Append(GetVertex(input[0]));
+  output.RestartStrip();
+}
+)";
+  }
+
+  return ss.str();
+}
+
+std::string GPU_HW_ShaderGen::GenerateWireframeFragmentShader()
+{
+  std::stringstream ss;
+  WriteHeader(ss);
+  WriteCommonFunctions(ss);
+
+  DeclareFragmentEntryPoint(ss, 0, 0, {}, false, 1);
+  ss << R"(
+{
+  o_col0 = float4(1.0, 1.0, 1.0, 0.5);
+}
+)";
+
+  return ss.str();
+}
+
 std::string GPU_HW_ShaderGen::GenerateVRAMReadFragmentShader()
 {
   std::stringstream ss;

src/core/gpu_hw_shadergen.h

@@ -18,6 +18,8 @@ public:
                                           bool dithering, bool interlacing);
   std::string GenerateDisplayFragmentShader(bool depth_24bit, GPU_HW::InterlacedRenderMode interlace_mode,
                                             bool smooth_chroma);
+  std::string GenerateWireframeGeometryShader();
+  std::string GenerateWireframeFragmentShader();
   std::string GenerateVRAMReadFragmentShader();
   std::string GenerateVRAMWriteFragmentShader(bool use_ssbo);
   std::string GenerateVRAMCopyFragmentShader();

src/core/settings.cpp

@@ -225,6 +225,10 @@ void Settings::Load(SettingsInterface& si)
     ParseDownsampleModeName(
       si.GetStringValue("GPU", "DownsampleMode", GetDownsampleModeName(DEFAULT_GPU_DOWNSAMPLE_MODE)).c_str())
       .value_or(DEFAULT_GPU_DOWNSAMPLE_MODE);
+  gpu_wireframe_mode =
+    ParseGPUWireframeMode(
+      si.GetStringValue("GPU", "WireframeMode", GetGPUWireframeModeName(DEFAULT_GPU_WIREFRAME_MODE)).c_str())
+      .value_or(DEFAULT_GPU_WIREFRAME_MODE);
   gpu_disable_interlacing = si.GetBoolValue("GPU", "DisableInterlacing", true);
   gpu_force_ntsc_timings = si.GetBoolValue("GPU", "ForceNTSCTimings", false);
   gpu_widescreen_hack = si.GetBoolValue("GPU", "WidescreenHack", false);
@@ -462,6 +466,7 @@ void Settings::Save(SettingsInterface& si) const
   si.SetBoolValue("GPU", "ScaledDithering", gpu_scaled_dithering);
   si.SetStringValue("GPU", "TextureFilter", GetTextureFilterName(gpu_texture_filter));
   si.SetStringValue("GPU", "DownsampleMode", GetDownsampleModeName(gpu_downsample_mode));
+  si.SetStringValue("GPU", "WireframeMode", GetGPUWireframeModeName(gpu_wireframe_mode));
   si.SetBoolValue("GPU", "DisableInterlacing", gpu_disable_interlacing);
   si.SetBoolValue("GPU", "ForceNTSCTimings", gpu_force_ntsc_timings);
   si.SetBoolValue("GPU", "WidescreenHack", gpu_widescreen_hack);
@@ -1052,6 +1057,35 @@ const char* Settings::GetDownsampleModeDisplayName(GPUDownsampleMode mode)
   return Host::TranslateToCString("GPUDownsampleMode", s_downsample_mode_display_names[static_cast<int>(mode)]);
 }
 
+static constexpr auto s_wireframe_mode_names = make_array("Disabled", "OverlayWireframe", "OnlyWireframe");
+static constexpr auto s_wireframe_mode_display_names =
+  make_array(TRANSLATE_NOOP("GPUWireframeMode", "Disabled"), TRANSLATE_NOOP("GPUWireframeMode", "Overlay Wireframe"),
+             TRANSLATE_NOOP("GPUWireframeMode", "Only Wireframe"));
+
+std::optional<GPUWireframeMode> Settings::ParseGPUWireframeMode(const char* str)
+{
+  int index = 0;
+  for (const char* name : s_wireframe_mode_names)
+  {
+    if (StringUtil::Strcasecmp(name, str) == 0)
+      return static_cast<GPUWireframeMode>(index);
+
+    index++;
+  }
+
+  return std::nullopt;
+}
+
+const char* Settings::GetGPUWireframeModeName(GPUWireframeMode mode)
+{
+  return s_wireframe_mode_names[static_cast<int>(mode)];
+}
+
+const char* Settings::GetGPUWireframeModeDisplayName(GPUWireframeMode mode)
+{
+  return Host::TranslateToCString("GPUWireframeMode", s_wireframe_mode_display_names[static_cast<int>(mode)]);
+}
+
 static std::array<const char*, 3> s_display_crop_mode_names = {{"None", "Overscan", "Borders"}};
 static std::array<const char*, 3> s_display_crop_mode_display_names = {
   {TRANSLATE_NOOP("DisplayCropMode", "None"), TRANSLATE_NOOP("DisplayCropMode", "Only Overscan Area"),
@@ -1082,9 +1116,8 @@ const char* Settings::GetDisplayCropModeDisplayName(DisplayCropMode crop_mode)
 }
 
 static std::array<const char*, static_cast<size_t>(DisplayAspectRatio::Count)> s_display_aspect_ratio_names = {
-  {TRANSLATE_NOOP("DisplayAspectRatio", "Auto (Game Native)"),
-   TRANSLATE_NOOP("DisplayAspectRatio", "Stretch To Fill"), TRANSLATE_NOOP("DisplayAspectRatio", "Custom"), "4:3",
-   "16:9", "19:9", "20:9", "PAR 1:1"}};
+  {TRANSLATE_NOOP("DisplayAspectRatio", "Auto (Game Native)"), TRANSLATE_NOOP("DisplayAspectRatio", "Stretch To Fill"),
+   TRANSLATE_NOOP("DisplayAspectRatio", "Custom"), "4:3", "16:9", "19:9", "20:9", "PAR 1:1"}};
 static constexpr std::array<float, static_cast<size_t>(DisplayAspectRatio::Count)> s_display_aspect_ratio_values = {
   {-1.0f, -1.0f, -1.0f, 4.0f / 3.0f, 16.0f / 9.0f, 19.0f / 9.0f, 20.0f / 9.0f, -1.0f}};
 

src/core/settings.h

@@ -106,6 +106,7 @@ struct Settings
   bool gpu_scaled_dithering = true;
   GPUTextureFilter gpu_texture_filter = DEFAULT_GPU_TEXTURE_FILTER;
   GPUDownsampleMode gpu_downsample_mode = DEFAULT_GPU_DOWNSAMPLE_MODE;
+  GPUWireframeMode gpu_wireframe_mode = DEFAULT_GPU_WIREFRAME_MODE;
   bool gpu_disable_interlacing = true;
   bool gpu_force_ntsc_timings = false;
   bool gpu_widescreen_hack = false;
@@ -373,6 +374,10 @@ struct Settings
   static const char* GetDownsampleModeName(GPUDownsampleMode mode);
   static const char* GetDownsampleModeDisplayName(GPUDownsampleMode mode);
 
+  static std::optional<GPUWireframeMode> ParseGPUWireframeMode(const char* str);
+  static const char* GetGPUWireframeModeName(GPUWireframeMode mode);
+  static const char* GetGPUWireframeModeDisplayName(GPUWireframeMode mode);
+
   static std::optional<DisplayCropMode> ParseDisplayCropMode(const char* str);
   static const char* GetDisplayCropModeName(DisplayCropMode crop_mode);
   static const char* GetDisplayCropModeDisplayName(DisplayCropMode crop_mode);
@@ -421,6 +426,7 @@ struct Settings
 #endif
   static constexpr GPUTextureFilter DEFAULT_GPU_TEXTURE_FILTER = GPUTextureFilter::Nearest;
   static constexpr GPUDownsampleMode DEFAULT_GPU_DOWNSAMPLE_MODE = GPUDownsampleMode::Disabled;
+  static constexpr GPUWireframeMode DEFAULT_GPU_WIREFRAME_MODE = GPUWireframeMode::Disabled;
   static constexpr ConsoleRegion DEFAULT_CONSOLE_REGION = ConsoleRegion::Auto;
   static constexpr float DEFAULT_GPU_PGXP_DEPTH_THRESHOLD = 300.0f;
   static constexpr float GPU_PGXP_DEPTH_THRESHOLD_SCALE = 4096.0f;

src/core/system.cpp

@@ -3589,6 +3589,7 @@ void System::CheckForSettingsChanges(const Settings& old_settings)
         g_settings.gpu_force_ntsc_timings != old_settings.gpu_force_ntsc_timings ||
         g_settings.gpu_24bit_chroma_smoothing != old_settings.gpu_24bit_chroma_smoothing ||
         g_settings.gpu_downsample_mode != old_settings.gpu_downsample_mode ||
+        g_settings.gpu_wireframe_mode != old_settings.gpu_wireframe_mode ||
         g_settings.display_crop_mode != old_settings.display_crop_mode ||
         g_settings.display_aspect_ratio != old_settings.display_aspect_ratio ||
         g_settings.display_alignment != old_settings.display_alignment ||

src/core/types.h

@@ -95,6 +95,14 @@ enum class GPUDownsampleMode : u8
   Count
 };
 
+enum class GPUWireframeMode : u8
+{
+  Disabled,
+  OverlayWireframe,
+  OnlyWireframe,
+  Count,
+};
+
 enum class DisplayCropMode : u8
 {
   None,

src/duckstation-qt/advancedsettingswidget.cpp

@@ -279,6 +279,11 @@ void AdvancedSettingsWidget::addTweakOptions()
 
   addMSAATweakOption(m_dialog, m_ui.tweakOptionTable, tr("Multisample Antialiasing"));
 
+  addChoiceTweakOption(m_dialog, m_ui.tweakOptionTable, tr("Wireframe Mode"), "GPU", "WireframeMode",
+                       Settings::ParseGPUWireframeMode, Settings::GetGPUWireframeModeName,
+                       Settings::GetGPUWireframeModeDisplayName, static_cast<u32>(GPUWireframeMode::Count),
+                       GPUWireframeMode::Disabled);
+
   if (m_dialog->isPerGameSettings())
   {
     addIntRangeTweakOption(m_dialog, m_ui.tweakOptionTable, tr("Display Active Start Offset"), "Display",
@@ -365,6 +370,7 @@ void AdvancedSettingsWidget::onResetToDefaultClicked()
     setBooleanTweakOption(m_ui.tweakOptionTable, i++, true);     // Apply compatibility settings
     setIntRangeTweakOption(m_ui.tweakOptionTable, i++, 0);       // Display FPS limit
     setChoiceTweakOption(m_ui.tweakOptionTable, i++, 0);         // Multisample antialiasing
+    setChoiceTweakOption(m_ui.tweakOptionTable, i++, 0);         // Wireframe mode
     setBooleanTweakOption(m_ui.tweakOptionTable, i++, false);    // PGXP vertex cache
     setFloatRangeTweakOption(m_ui.tweakOptionTable, i++, -1.0f); // PGXP geometry tolerance
     setFloatRangeTweakOption(m_ui.tweakOptionTable, i++,

src/util/shadergen.cpp

@@ -488,6 +488,8 @@ void ShaderGen::DeclareFragmentEntryPoint(
   bool noperspective_color /* = false */)
 {
   if (m_glsl)
+  {
+    if (num_color_inputs > 0 || num_texcoord_inputs > 0 || additional_inputs.size() > 0)
     {
       if (m_use_glsl_interface_blocks)
       {
@@ -526,6 +528,7 @@ void ShaderGen::DeclareFragmentEntryPoint(
           ss << qualifier_to_use << " in " << name << ";\n";
         }
       }
+    }
 
     if (declare_fragcoord)
       ss << "#define v_pos gl_FragCoord\n";