Squashed commit of the following:

commit 8f8f51cadfd80d618c388a368b118cb95a3c4e5b
Author: DoubleStyx <79298541+DoubleStyx@users.noreply.github.com>
Date:   Mon Jun 15 18:46:04 2026 -0500

    Unify debug HUD diagnostics under Stats

commit 3d45205eb860473f645bad3c8476f474903ba5e8
Author: DoubleStyx <79298541+DoubleStyx@users.noreply.github.com>
Date:   Mon Jun 15 15:28:17 2026 -0500

    Expand debug HUD renderer diagnostics

Author: DoubleStyx

crates/renderide/src/backend/debug_hud_bundle.rs

@@ -8,6 +8,7 @@ use crate::diagnostics::{
     DebugHud, DebugHudInput, DebugHudOverlayContext, FrameDiagnosticsSnapshot,
     FrameTimingHudSnapshot, RendererInfoSnapshot, SceneTransformsSnapshot, TextureDebugSnapshot,
 };
+use crate::hud_contract::WorldMeshViewHudStats;
 use crate::hud_contract::{DebugHudEncodeError, PerViewHudConfig, PerViewHudOutputs};
 use crate::world_mesh::{WorldMeshDrawStateRow, WorldMeshDrawStats};
 
@@ -19,8 +20,10 @@ pub struct DebugHudBundle {
     want_capture_mouse: bool,
     want_capture_keyboard: bool,
     last_world_mesh_draw_stats: WorldMeshDrawStats,
+    last_world_mesh_view_stats: Vec<WorldMeshViewHudStats>,
     last_world_mesh_draw_state_rows: Vec<WorldMeshDrawStateRow>,
     per_view_config: PerViewHudConfig,
+    capture_graph_command_diagnostics: bool,
     current_view_texture_2d_asset_ids: BTreeSet<i32>,
 }
 
@@ -40,8 +43,10 @@ impl DebugHudBundle {
             want_capture_mouse: false,
             want_capture_keyboard: false,
             last_world_mesh_draw_stats: WorldMeshDrawStats::default(),
+            last_world_mesh_view_stats: Vec::new(),
             last_world_mesh_draw_state_rows: Vec::new(),
             per_view_config: PerViewHudConfig::default(),
+            capture_graph_command_diagnostics: false,
             current_view_texture_2d_asset_ids: BTreeSet::new(),
         }
     }
@@ -71,6 +76,9 @@ impl DebugHudBundle {
         if !config.capture_world_mesh_draw_stats {
             self.last_world_mesh_draw_stats = WorldMeshDrawStats::default();
         }
+        if !config.capture_world_mesh_view_stats {
+            self.last_world_mesh_view_stats.clear();
+        }
         if !config.capture_world_mesh_draw_state_rows {
             self.last_world_mesh_draw_state_rows.clear();
         }
@@ -85,6 +93,16 @@ impl DebugHudBundle {
         self.per_view_config
     }
 
+    /// Updates whether graph execution should publish HUD-formatted command diagnostics.
+    pub(crate) fn set_capture_graph_command_diagnostics(&mut self, capture: bool) {
+        self.capture_graph_command_diagnostics = capture;
+    }
+
+    /// Returns whether graph execution should publish HUD-formatted command diagnostics.
+    pub(crate) fn capture_graph_command_diagnostics(&self) -> bool {
+        self.capture_graph_command_diagnostics
+    }
+
     /// Clears the current-view Texture2D id set before collecting this frame's submitted draws.
     pub(crate) fn clear_current_view_texture_2d_asset_ids(&mut self) {
         self.current_view_texture_2d_asset_ids.clear();
@@ -104,6 +122,9 @@ impl DebugHudBundle {
         if let Some(stats) = outputs.world_mesh_draw_stats.as_ref() {
             self.set_last_world_mesh_draw_stats(stats);
         }
+        if let Some(view_stats) = outputs.world_mesh_view_stats.as_ref() {
+            self.set_last_world_mesh_view_stats(view_stats.clone());
+        }
         if let Some(rows) = outputs.world_mesh_draw_state_rows.clone() {
             self.set_last_world_mesh_draw_state_rows(rows);
         }
@@ -205,6 +226,22 @@ impl DebugHudBundle {
         self.last_world_mesh_draw_stats
     }
 
+    pub(crate) fn set_last_world_mesh_view_stats(&mut self, stats: WorldMeshViewHudStats) {
+        if let Some(existing) = self
+            .last_world_mesh_view_stats
+            .iter_mut()
+            .find(|existing| existing.view_id == stats.view_id)
+        {
+            *existing = stats;
+        } else {
+            self.last_world_mesh_view_stats.push(stats);
+        }
+    }
+
+    pub(crate) fn last_world_mesh_view_stats(&self) -> Vec<WorldMeshViewHudStats> {
+        self.last_world_mesh_view_stats.clone()
+    }
+
     pub(crate) fn set_last_world_mesh_draw_state_rows(&mut self, rows: Vec<WorldMeshDrawStateRow>) {
         self.last_world_mesh_draw_state_rows = rows;
     }

crates/renderide/src/backend/facade.rs

@@ -466,26 +466,99 @@ impl RenderBackend {
             snapshot.last_world_mesh_draw_state_rows = self.last_world_mesh_draw_state_rows();
         }
 
-        if !interest.wants_stats() {
-            return snapshot;
+        if interest.wants_stats() {
+            self.populate_stats_diagnostics_snapshot(&mut snapshot);
         }
 
+        if interest.wants_graph() {
+            snapshot.command_encoding = self.graph_state.latest_command_encoding();
+        }
+
+        if interest.wants_assets() {
+            self.populate_asset_diagnostics_snapshot(&mut snapshot);
+        }
+
+        if interest.wants_visibility() {
+            self.populate_visibility_diagnostics_snapshot(&mut snapshot);
+        }
+
+        snapshot
+    }
+
+    fn populate_asset_diagnostics_snapshot(
+        &self,
+        snapshot: &mut crate::diagnostics::BackendDiagSnapshot,
+    ) {
+        let asset_diagnostics = self.asset_transfers.diagnostic_snapshot();
+        let worker_diagnostics = crate::assets::worker::diagnostic_snapshot();
+        let material_diagnostics = self.materials.diagnostic_snapshot();
+
+        snapshot.texture_format_registration_count = self.texture_format_registration_count();
+        snapshot.texture_mip0_ready_count = self.texture_mip0_ready_count();
+        snapshot.texture_pool_resident_count = self.texture_pool().len();
+        snapshot.render_texture_pool_len = self.render_texture_pool().len();
+        snapshot.mesh_pool_entry_count = self.mesh_pool().len();
+        snapshot.assets = crate::diagnostics::AssetDiagnosticsSnapshot {
+            main_queued: asset_diagnostics.integrator.main_queued,
+            high_priority_queued: asset_diagnostics.integrator.high_priority_queued,
+            render_queued: asset_diagnostics.integrator.render_queued,
+            normal_priority_queued: asset_diagnostics.integrator.normal_priority_queued,
+            particle_queued: asset_diagnostics.integrator.particle_queued,
+            total_queued: asset_diagnostics.integrator.total_queued,
+            peak_queued: asset_diagnostics.integrator.peak_queued,
+            pending_mesh_uploads: asset_diagnostics.pending_mesh_uploads,
+            pending_texture_uploads: asset_diagnostics.pending_texture_uploads,
+            pending_texture3d_uploads: asset_diagnostics.pending_texture3d_uploads,
+            pending_cubemap_uploads: asset_diagnostics.pending_cubemap_uploads,
+            pending_video_texture_loads: asset_diagnostics.pending_video_texture_loads,
+            worker_queued: worker_diagnostics.queued,
+            worker_running: worker_diagnostics.running,
+            worker_max_queued: worker_diagnostics.max_queued,
+            worker_spawned: worker_diagnostics.spawned,
+            worker_completed: worker_diagnostics.completed,
+            worker_inline_executed: worker_diagnostics.inline_executed,
+            worker_saturated: worker_diagnostics.saturated,
+            pending_material_batches: material_diagnostics.pending_material_batches,
+            pending_shader_routes: material_diagnostics.pending_shader_routes,
+            material_registry_attached: material_diagnostics.material_registry_attached,
+            embedded_bind_attached: material_diagnostics.embedded_bind_attached,
+        };
+    }
+
+    fn populate_visibility_diagnostics_snapshot(
+        &self,
+        snapshot: &mut crate::diagnostics::BackendDiagSnapshot,
+    ) {
+        snapshot.last_world_mesh_draw_stats = self.last_world_mesh_draw_stats();
+        snapshot.last_world_mesh_view_stats = self.last_world_mesh_view_stats();
+        snapshot.gpu_light_count = self.frame_services.frame_resources.frame_lights().len();
+        snapshot.signed_scene_color_active = self.signed_scene_color_active();
+        snapshot.lights = self.light_diagnostics_snapshot();
+    }
+
+    fn populate_stats_diagnostics_snapshot(
+        &self,
+        snapshot: &mut crate::diagnostics::BackendDiagSnapshot,
+    ) {
         let store = self.material_property_store();
         let material_diagnostics = self.materials.diagnostic_snapshot();
         let graph_stats = self
             .graph_state
             .frame_graph_cache
             .compile_stats()
             .unwrap_or_default();
-        snapshot = crate::diagnostics::BackendDiagSnapshot {
+        let shader_routes = std::mem::take(&mut snapshot.shader_routes);
+        let draw_state_rows = std::mem::take(&mut snapshot.last_world_mesh_draw_state_rows);
+        *snapshot = crate::diagnostics::BackendDiagSnapshot {
             texture_format_registration_count: self.texture_format_registration_count(),
             texture_mip0_ready_count: self.texture_mip0_ready_count(),
             texture_pool_resident_count: self.texture_pool().len(),
             render_texture_pool_len: self.render_texture_pool().len(),
             mesh_pool_entry_count: self.mesh_pool().len(),
-            shader_routes: snapshot.shader_routes,
+            shader_routes,
             last_world_mesh_draw_stats: self.last_world_mesh_draw_stats(),
-            last_world_mesh_draw_state_rows: snapshot.last_world_mesh_draw_state_rows,
+            last_world_mesh_view_stats: Vec::new(),
+            last_world_mesh_draw_state_rows: draw_state_rows,
             render_world_maintenance: self.draw_preparation.render_world_maintenance_stats(),
             world_mesh_command_cache: self.draw_preparation.command_cache_stats(),
             world_mesh_instance_plan_cache: self
@@ -509,8 +582,31 @@ impl RenderBackend {
             gpu_light_count: self.frame_services.frame_resources.frame_lights().len(),
             signed_scene_color_active: self.signed_scene_color_active(),
             upload_arena: self.graph_state.latest_upload_stats().into(),
+            command_encoding: Default::default(),
+            assets: Default::default(),
+            lights: Default::default(),
         };
-        snapshot
+    }
+
+    fn light_diagnostics_snapshot(&self) -> crate::diagnostics::LightDiagnosticsSnapshot {
+        let light_visibility = self.frame_services.frame_resources.light_visibility_stats();
+        crate::diagnostics::LightDiagnosticsSnapshot {
+            packed_default_lights: self.frame_services.frame_resources.frame_lights().len(),
+            per_view_light_packs: self
+                .frame_services
+                .frame_resources
+                .per_view_light_pack_count(),
+            max_per_view_lights: self
+                .frame_services
+                .frame_resources
+                .max_per_view_light_count(),
+            signed_scene_color_active: self.signed_scene_color_active(),
+            visibility_indexed_lights: light_visibility.indexed_lights,
+            visibility_fallback_lights: light_visibility.fallback_lights,
+            visibility_rejected_lights: light_visibility.rejected_lights,
+            visibility_bvh_queries: light_visibility.bvh_queries,
+            visibility_linear_queries: light_visibility.linear_queries,
+        }
     }
 
     /// Mutable render-graph transient resource pool.
@@ -569,6 +665,7 @@ impl RenderBackend {
             history_registry,
             upload_arena,
             latest_upload_stats,
+            latest_command_encoding,
             pending_transient_releases,
         ) = self.graph_state.execution_resources_mut();
         let (frame_resources, mesh_preprocess, mesh_deform_scratch, skin_cache) =
@@ -586,6 +683,7 @@ impl RenderBackend {
             history_registry,
             upload_arena,
             latest_upload_stats,
+            latest_command_encoding,
             pending_transient_releases,
             debug_hud: self.diagnostics.bundle_mut(),
             scene_color_format,

crates/renderide/src/backend/facade/diagnostics.rs

@@ -8,6 +8,7 @@ use crate::diagnostics::{
     DebugHudInput, FrameDiagnosticsSnapshot, FrameTimingHudSnapshot, RendererInfoSnapshot,
     SceneTransformsSnapshot, TextureDebugSnapshot,
 };
+use crate::hud_contract::WorldMeshViewHudStats;
 use crate::hud_contract::{DebugHudEncodeError, PerViewHudConfig};
 use crate::world_mesh::{WorldMeshDrawStateRow, WorldMeshDrawStats};
 
@@ -56,6 +57,12 @@ impl BackendDiagnostics {
         self.debug_hud.set_per_view_config(config);
     }
 
+    /// Updates whether graph execution should publish HUD-formatted command diagnostics.
+    pub(super) fn set_capture_graph_command_diagnostics(&mut self, capture: bool) {
+        self.debug_hud
+            .set_capture_graph_command_diagnostics(capture);
+    }
+
     /// Clears the current-view Texture2D set.
     pub(super) fn clear_current_view_texture_2d_asset_ids(&mut self) {
         self.debug_hud.clear_current_view_texture_2d_asset_ids();
@@ -144,6 +151,11 @@ impl BackendDiagnostics {
         self.debug_hud.last_world_mesh_draw_stats()
     }
 
+    /// Last per-view world-mesh draw stats captured by the HUD.
+    pub(super) fn last_world_mesh_view_stats(&self) -> Vec<WorldMeshViewHudStats> {
+        self.debug_hud.last_world_mesh_view_stats()
+    }
+
     /// Last world-mesh draw state rows captured by the HUD.
     pub(super) fn last_world_mesh_draw_state_rows(&self) -> Vec<WorldMeshDrawStateRow> {
         self.debug_hud.last_world_mesh_draw_state_rows()

crates/renderide/src/backend/facade/graph_access.rs

@@ -76,6 +76,8 @@ pub(crate) struct BackendGraphAccess<'a> {
     pub(crate) upload_arena: &'a mut PersistentUploadArena,
     /// Latest frame-upload stats published for diagnostics.
     pub(crate) latest_upload_stats: &'a mut FrameUploadBatchStats,
+    /// Latest graph command-recording stats published for diagnostics.
+    pub(crate) latest_command_encoding: &'a mut crate::render_graph::CommandEncodingHudSnapshot,
     /// Resolved transient resource sets waiting on driver submit before pool release.
     pub(super) pending_transient_releases: &'a mut Vec<PendingTransientRelease>,
     /// Debug HUD state and encoder.
@@ -173,6 +175,14 @@ impl<'a> BackendGraphAccess<'a> {
         *self.latest_upload_stats = stats;
     }
 
+    /// Publishes graph command recording stats for diagnostics.
+    pub(crate) fn record_command_encoding_diagnostics(
+        &mut self,
+        snapshot: crate::render_graph::CommandEncodingHudSnapshot,
+    ) {
+        *self.latest_command_encoding = snapshot;
+    }
+
     /// Scene-color format snapshot selected for this graph frame.
     pub(crate) fn scene_color_format_wgpu(&self) -> wgpu::TextureFormat {
         self.scene_color_format
@@ -228,6 +238,11 @@ impl<'a> BackendGraphAccess<'a> {
         self.debug_hud.per_view_config()
     }
 
+    /// Whether graph execution should publish HUD-formatted command diagnostics.
+    pub(crate) fn capture_graph_command_diagnostics(&self) -> bool {
+        self.debug_hud.capture_graph_command_diagnostics()
+    }
+
     /// Whether the HUD will draw visible content this frame.
     pub(crate) fn debug_hud_has_visible_content(&self) -> bool {
         self.debug_hud.has_visible_content()
@@ -311,6 +326,17 @@ impl GraphExecutionBackend for BackendGraphAccess<'_> {
         BackendGraphAccess::record_frame_upload_stats(self, stats);
     }
 
+    fn record_command_encoding_diagnostics(
+        &mut self,
+        snapshot: crate::render_graph::CommandEncodingHudSnapshot,
+    ) {
+        BackendGraphAccess::record_command_encoding_diagnostics(self, snapshot);
+    }
+
+    fn capture_graph_command_diagnostics(&self) -> bool {
+        BackendGraphAccess::capture_graph_command_diagnostics(self)
+    }
+
     fn scene_color_format_wgpu(&self) -> wgpu::TextureFormat {
         BackendGraphAccess::scene_color_format_wgpu(self)
     }

crates/renderide/src/backend/facade/graph_state.rs

@@ -33,6 +33,8 @@ pub(super) struct RenderGraphState {
     upload_arena: PersistentUploadArena,
     /// Latest upload drain stats published by graph execution for diagnostics.
     latest_upload_stats: FrameUploadBatchStats,
+    /// Latest command-recording stats published by graph execution for diagnostics.
+    latest_command_encoding: crate::render_graph::CommandEncodingHudSnapshot,
     /// Transient resources recorded into queued submits but not yet reusable.
     pending_transient_releases: Vec<PendingTransientRelease>,
     /// Retained logical-view ownership for every backend cache that lives beyond one frame.
@@ -50,6 +52,7 @@ impl RenderGraphState {
             history_registry: HistoryRegistry::new(),
             upload_arena: PersistentUploadArena::new(),
             latest_upload_stats: FrameUploadBatchStats::default(),
+            latest_command_encoding: crate::render_graph::CommandEncodingHudSnapshot::default(),
             pending_transient_releases: Vec::new(),
             view_resources: ViewResourceRegistry::new(),
             post_processing_resources: MainGraphPostProcessingResources::default(),
@@ -80,13 +83,15 @@ impl RenderGraphState {
         &mut HistoryRegistry,
         &mut PersistentUploadArena,
         &mut FrameUploadBatchStats,
+        &mut crate::render_graph::CommandEncodingHudSnapshot,
         &mut Vec<PendingTransientRelease>,
     ) {
         (
             &mut self.transient_pool,
             &mut self.history_registry,
             &mut self.upload_arena,
             &mut self.latest_upload_stats,
+            &mut self.latest_command_encoding,
             &mut self.pending_transient_releases,
         )
     }
@@ -110,6 +115,13 @@ impl RenderGraphState {
         self.latest_upload_stats
     }
 
+    /// Latest command-recording stats published by graph execution.
+    pub(super) fn latest_command_encoding(
+        &self,
+    ) -> crate::render_graph::CommandEncodingHudSnapshot {
+        self.latest_command_encoding.clone()
+    }
+
     /// Long-lived post-processing resources for main-graph rebuilds.
     pub(super) fn post_processing_resources(&self) -> &MainGraphPostProcessingResources {
         &self.post_processing_resources