diff --git a/crates/horizon-client/src/crash.rs b/crates/horizon-client/src/crash.rs index a0b68260d..b361a50ff 100644 --- a/crates/horizon-client/src/crash.rs +++ b/crates/horizon-client/src/crash.rs @@ -164,7 +164,8 @@ fn operating_system() -> String { ) } -fn cpu() -> String { +/// Logical processors and the CPU's name (`12x AMD Ryzen 5 5600X ...`). +pub fn cpu() -> String { let threads = std::thread::available_parallelism().map_or(0, |n| n.get()); let name = if cfg!(target_os = "linux") { read("/proc/cpuinfo").and_then(|t| { diff --git a/crates/horizon-client/src/debug_chart.rs b/crates/horizon-client/src/debug_chart.rs index 68a469415..d006a8ab6 100644 --- a/crates/horizon-client/src/debug_chart.rs +++ b/crates/horizon-client/src/debug_chart.rs @@ -72,6 +72,8 @@ pub struct DebugCharts { pub ping: SampleLogger, /// `bandwidthLogger`: bytes received per tick. pub bandwidth: SampleLogger, + /// `MinecraftServer.smoothedTickTimeMillis`. + pub smoothed_tick_ms: f32, previous_tick: Option, bytes_seen: Option, } @@ -110,6 +112,7 @@ impl DebugCharts { self.bandwidth.reset(); self.previous_tick = None; self.bytes_seen = None; + self.smoothed_tick_ms = 0.0; } /// One integrated server tick that started at `started` and ran its /// tick method for `method` (`MinecraftServer.logFullTickTime` and @@ -123,6 +126,7 @@ impl DebugCharts { .max(method); self.previous_tick = Some(started); self.tick_times.log_full([full, method, 0, full - method]); + self.smoothed_tick_ms = self.smoothed_tick_ms * 0.8 + method as f32 / 1e6 * 0.199_999_99; } /// `BandwidthDebugMonitor.tick`: the bytes received since the last /// tick, from the connection's running total. diff --git a/crates/horizon-client/src/debug_overlay.rs b/crates/horizon-client/src/debug_overlay.rs new file mode 100644 index 000000000..3448ea411 --- /dev/null +++ b/crates/horizon-client/src/debug_overlay.rs @@ -0,0 +1,340 @@ +//! `DebugScreenOverlay`: the F3 text. The entries of the default profile +//! (`DebugScreenEntries.PROFILES`) report priority lines, regular lines and +//! groups; the overlay splits them into a left and a right column and draws +//! them last, over any screen, at the debug GUI scale. +use crate::{ + font::Font, + hud_layout::{GuiDraw, PoseOp, fill}, + text::Text, +}; + +/// `extractLines`'s background: ARGB 0x90505050. +const BACKGROUND: u32 = 0x9050_5050; +/// `extractLines`'s text colour: ARGB 0xFFE0E0E0. +const TEXT: u32 = 0xFFE0_E0E0; +/// `Font.lineHeight`. +const LINE_HEIGHT: i32 = 9; + +/// What the enabled entries reported (`DebugScreenDisplayer`). +#[derive(Default, Debug)] +pub struct Displayer { + left: Vec, + right: Vec, + lines: Vec, + groups: Vec<(&'static str, Vec)>, +} + +impl Displayer { + /// `addPriorityLine`: to the shorter column, the left one first. + pub fn priority(&mut self, line: impl Into) { + if self.left.len() > self.right.len() { + self.right.push(line.into()); + } else { + self.left.push(line.into()); + } + } + /// `addLine`: split between the columns after the priority lines. + pub fn line(&mut self, line: impl Into) { + self.lines.push(line.into()); + } + /// `addToGroup`: lines kept together, groups in the order first added. + pub fn group(&mut self, group: &'static str, lines: impl IntoIterator) { + let index = match self.groups.iter().position(|(g, _)| *g == group) { + Some(i) => i, + None => { + self.groups.push((group, Vec::new())); + self.groups.len() - 1 + } + }; + self.groups[index].1.extend(lines); + } + /// `extractRenderState`: the left and right columns, then `footer` (the + /// chart keys, shown while the overlay is open) under the left one. + pub fn columns(self, footer: &[String]) -> (Vec, Vec) { + let (mut left, mut right) = (self.left, self.right); + if !left.is_empty() { + left.push(String::new()); + } + if !right.is_empty() { + right.push(String::new()); + } + if !self.lines.is_empty() { + let mid = self.lines.len().div_ceil(2); + left.extend_from_slice(&self.lines[..mid]); + right.extend_from_slice(&self.lines[mid..]); + left.push(String::new()); + if mid < self.lines.len() { + right.push(String::new()); + } + } + let mid = self.groups.len().div_ceil(2); + for (i, (_, lines)) in self.groups.into_iter().enumerate() { + if lines.is_empty() { + continue; + } + let column = if i < mid { &mut left } else { &mut right }; + column.extend(lines); + column.push(String::new()); + } + if !footer.is_empty() { + left.push(String::new()); + left.extend_from_slice(footer); + } + (left, right) + } +} + +/// `Mth.wrapDegrees`. +fn wrap_degrees(angle: f32) -> f32 { + let wrapped = angle % 360.0; + if wrapped >= 180.0 { + wrapped - 360.0 + } else if wrapped < -180.0 { + wrapped + 360.0 + } else { + wrapped + } +} + +/// `DebugEntryPosition` and `DebugEntrySectionPosition` for a camera at +/// `pos` looking `yaw`/`pitch` in `dimension` with `forced` force-loaded chunks. +pub fn position( + pos: [f64; 3], + yaw: f32, + pitch: f32, + dimension: &str, + forced: usize, +) -> Vec { + let block = pos.map(|v| v.floor() as i32); + let (cx, sy, cz) = (block[0] >> 4, block[1] >> 4, block[2] >> 4); + // Direction.fromYRot: floor(yRot / 90 + 0.5) & 3 as a 2D data value. + let (direction, towards) = match ((f64::from(yaw) / 90.0 + 0.5).floor() as i32) & 3 { + 0 => ("south", "Towards positive Z"), + 1 => ("west", "Towards negative X"), + 2 => ("north", "Towards negative Z"), + _ => ("east", "Towards positive X"), + }; + vec![ + format!("XYZ: {:.3} / {:.5} / {:.3}", pos[0], pos[1], pos[2]), + format!("Block: {} {} {}", block[0], block[1], block[2]), + format!( + "Chunk: {cx} {sy} {cz} [{} {} in r.{}.{}.mca]", + cx & 31, + cz & 31, + cx >> 5, + cz >> 5 + ), + format!( + "Facing: {direction} ({towards}) ({:.1} / {:.1})", + wrap_degrees(yaw), + wrap_degrees(pitch) + ), + format!("{dimension} FC: {forced}"), + format!( + "Section-relative: {:02} {:02} {:02}", + block[0] & 15, + block[1] & 15, + block[2] & 15 + ), + ] +} + +/// `VideoMode.refreshRateLabel`: whole rates without decimals. +pub fn refresh_rate_label(hz: f64) -> String { + if hz == hz.round() { + format!("{}", hz as i64) + } else { + format!("{hz:.2}") + } +} + +/// `DeviceInfo.vendorName` for a PCI vendor id. +pub fn vendor_name(id: u32) -> String { + match id { + 0x10de => "NVIDIA Corporation".into(), + 0x1002 | 0x1022 => "AMD".into(), + 0x8086 => "Intel".into(), + 0x106b => "Apple".into(), + 0x5143 => "Qualcomm".into(), + 0x13b5 => "ARM".into(), + 0x10005 => "Mesa".into(), + 0 => "unknown".into(), + other => format!("{other:#06x}"), + } +} + +/// The overlay's scale against the GUI scale and the scaled screen size it +/// lays out in. `debugGuiScale`: -1 keeps the GUI scale, 0 (the default) is +/// half the largest automatic scale, n is `calculateScale(n)`; only a scale +/// below the GUI scale applies. +pub fn scale( + framebuffer: [i32; 2], + gui_scale: i32, + option: i32, + unicode: bool, + gui_size: [i32; 2], +) -> (f32, [i32; 2]) { + let scale = match option { + -1 => gui_scale, + 0 => crate::window::calculate_scale(framebuffer, 0, unicode) / 2, + n => crate::window::calculate_scale(framebuffer, n, unicode), + }; + if scale < gui_scale && scale > 0 { + ( + scale as f32 / gui_scale as f32, + [framebuffer[0] / scale, framebuffer[1] / scale], + ) + } else { + (1.0, gui_size) + } +} + +/// `extractLines` for both columns under the overlay's pose: each line's +/// background first, then the text, right-aligned in the right column. +pub fn draw(font: &Font, columns: [&[String]; 2], scale: f32, width: i32) -> Vec { + let mut out = vec![GuiDraw::Push(vec![PoseOp::Scale(scale, scale)])]; + for (lines, align_left) in [(columns[0], true), (columns[1], false)] { + let placed: Vec<(&String, i32, i32)> = lines + .iter() + .enumerate() + .filter(|(_, l)| !l.is_empty()) + .map(|(i, l)| { + let w = font.width(l) as i32; + let left = if align_left { 2 } else { width - 2 - w }; + (l, left, 2 + LINE_HEIGHT * i as i32) + }) + .collect(); + for (line, left, top) in &placed { + let w = font.width(line) as i32; + out.push(fill( + left - 1, + top - 1, + left + w + 1, + top + LINE_HEIGHT - 1, + BACKGROUND, + )); + } + for (line, left, top) in placed { + out.push(GuiDraw::Text { + text: Text::literal(line.clone()), + x: left, + y: top, + color: TEXT, + shadow: false, + }); + } + } + out.push(GuiDraw::Pop); + out +} + +#[cfg(test)] +mod tests { + use super::*; + + fn lines(v: &[&str]) -> Vec { + v.iter().map(|s| (*s).to_owned()).collect() + } + + #[test] + fn columns_follow_the_vanilla_split() { + // The default profile's entries, sorted by identifier as + // DebugScreenEntryList.rebuildCurrentList does: fps, game_version, + // memory, player_position, player_section_position, + // simple_performance_impactors, system_specs, tps. + let mut d = Displayer::default(); + d.priority("112 fps T: 120 (fifo) @165Hz"); + d.priority("Minecraft 26.3 (26.3/vanilla)"); + d.group("memory", lines(&["Mem: 25% 1046/4096MiB"])); + d.group("position", lines(&["XYZ: 1 / 2 / 3", "Block: 1 2 3"])); + d.group("position", lines(&["Section-relative: 01 02 03"])); + d.line("fancy-clouds B: 2"); + d.line("Filtering: RGSS"); + d.line("Terrain Rendering: multidrawindirect"); + d.group( + "system", + lines(&["CPU: 12x Ryzen", "Display: 854x709 (NVIDIA)"]), + ); + d.line("Integrated server @ 6.6/50.0 ms, 28 tx, 492 rx"); + let footer = lines(&["Debug charts: ...", "To edit: press [F3+F6]"]); + let (left, right) = d.columns(&footer); + // As the issue's vanilla screenshot (#376) shows them. + assert_eq!( + left, + lines(&[ + "112 fps T: 120 (fifo) @165Hz", + "", + "fancy-clouds B: 2", + "Filtering: RGSS", + "", + "Mem: 25% 1046/4096MiB", + "", + "XYZ: 1 / 2 / 3", + "Block: 1 2 3", + "Section-relative: 01 02 03", + "", + "", + "Debug charts: ...", + "To edit: press [F3+F6]", + ]) + ); + assert_eq!( + right, + lines(&[ + "Minecraft 26.3 (26.3/vanilla)", + "", + "Terrain Rendering: multidrawindirect", + "Integrated server @ 6.6/50.0 ms, 28 tx, 492 rx", + "", + "CPU: 12x Ryzen", + "Display: 854x709 (NVIDIA)", + "", + ]) + ); + } + + #[test] + fn position_lines_match_vanilla() { + // The issue's vanilla screenshot (#376). + assert_eq!( + position([108.5, 104.0, -51.5], -1.0, 7.1, "minecraft:overworld", 0), + lines(&[ + "XYZ: 108.500 / 104.00000 / -51.500", + "Block: 108 104 -52", + "Chunk: 6 6 -4 [6 28 in r.0.-1.mca]", + "Facing: south (Towards positive Z) (-1.0 / 7.1)", + "minecraft:overworld FC: 0", + "Section-relative: 12 08 12", + ]) + ); + assert_eq!( + position([0.0, 64.0, 0.0], 450.0, 0.0, "minecraft:the_nether", 2)[3], + "Facing: west (Towards negative X) (90.0 / 0.0)" + ); + assert_eq!(refresh_rate_label(165.0), "165"); + assert_eq!(refresh_rate_label(59.94), "59.94"); + } + + #[test] + fn debug_scale_is_half_the_automatic_scale() { + // The issue's window: 854x709 at GUI scale 2 draws F3 at scale 1. + assert_eq!( + scale([854, 709], 2, 0, false, [427, 355]), + (0.5, [854, 709]) + ); + // 1920x1080 at GUI scale 4: auto is 4, so F3 is at 2. + assert_eq!( + scale([1920, 1080], 4, 0, false, [480, 270]), + (0.5, [960, 540]) + ); + // A GUI scale already at or under the debug scale is kept. + assert_eq!( + scale([1920, 1080], 2, 0, false, [960, 540]), + (1.0, [960, 540]) + ); + assert_eq!( + scale([1920, 1080], 3, -1, false, [640, 360]), + (1.0, [640, 360]) + ); + } +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 03f6b23db..2df65342b 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -3611,6 +3611,9 @@ impl Game<'_> { } fn hud(&mut self, size: [u32; 2]) -> HudBatch { let mut batch = self.hud_layers(size); + // Gui.extractRenderState: the debug overlay comes after the screen + // and the toasts, so it is over everything, menus included. + self.draw_debug_overlay(&mut batch, size); self.frame_graph .draw(self.settings.horizon.overlay, &mut batch, &self.res.atlas); self.draw_pad_cursor(&mut batch); @@ -3791,117 +3794,6 @@ impl Game<'_> { } } let atlas = &self.res.atlas; - if self.debug { - let p = self - .player - .as_ref() - .map(|p| p.position) - .unwrap_or(Vec3::ZERO); - let block = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32]; - let biome = self - .world - .chunks - .get(&(block[0] >> 4, block[2] >> 4)) - .map(|c| { - self.res - .biomes - .get(c.biome(block[0], block[1], block[2])) - .name - .clone() - }) - .unwrap_or_default(); - let light = self.world.light(block[0], block[1], block[2]); - let facing = match ((self.yaw.rem_euclid(360.0) + 45.0) / 90.0) as i32 % 4 { - 0 => "south (Towards positive Z)", - 1 => "west (Towards negative X)", - 2 => "north (Towards negative Z)", - _ => "east (Towards positive X)", - }; - let mut lines = vec![ - format!("Horizon 26.3 (Rust) {:.0} fps", self.fps), - format!( - "C: {} chunks, {} sections drawn / {}", - self.world.chunks.len(), - self.renderer.as_ref().map_or(0, |r| r.drawn_sections), - self.renderer.as_ref().map_or(0, |r| r.section_count()) - ), - format!("Pending jobs: {}", self.streaming.pending()), - String::new(), - format!("XYZ: {:.3} / {:.5} / {:.3}", p.x, p.y, p.z), - format!("Block: {} {} {}", block[0], block[1], block[2]), - format!( - "Chunk: {} {} {} in {} {} {}", - block[0] & 15, - block[1] & 15, - block[2] & 15, - block[0] >> 4, - block[1] >> 4, - block[2] >> 4 - ), - format!( - "Facing: {facing} ({:.1} / {:.1})", - self.yaw.rem_euclid(360.0) - - if self.yaw.rem_euclid(360.0) > 180.0 { - 360.0 - } else { - 0.0 - }, - self.pitch - ), - format!( - "Light: {} (sky {}, block {})", - (light >> 4).max(light & 15), - light >> 4, - light & 15 - ), - format!("Biome: {biome}"), - format!( - "Day {} time {}", - self.world.day_time / 24000, - self.world.day_time % 24000 - ), - String::new(), - ]; - lines.extend(self.debug_chart_lines()); - for (i, line) in lines.iter().enumerate() { - if line.is_empty() { - continue; - } - let tw = HudBatch::text_width(atlas, line); - batch.fill( - atlas, - 1.0, - 2.0 + i as f32 * 9.0 - 1.0, - tw + 2.0, - 9.0, - rgba(80, 80, 80, 144), - ); - batch.text( - atlas, - line, - 2.0, - 2.0 + i as f32 * 9.0, - rgba(224, 224, 224, 255), - false, - ); - } - let charts = self.debug_charts.draw( - &atlas.font, - w as i32, - h as i32, - self.settings.max_fps, - 1000.0 / self.clock.rate(), - self.remote.is_some(), - ); - hud_layout::paint(&mut batch, atlas, &charts); - if self.debug_charts.lightmap - && let Some(r) = &self.renderer - { - let view = - horizon_client::debug_chart::lightmap(&r.lightmap_pixels, w as i32, h as i32); - hud_layout::paint(&mut batch, atlas, &view); - } - } if !self.ui.hide_gui && let Some((text, at)) = &self.message && at.elapsed() < Duration::from_secs(3) diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs index 6f38e2704..d2337947a 100644 --- a/crates/horizon-client/src/game/debug_keys.rs +++ b/crates/horizon-client/src/game/debug_keys.rs @@ -6,8 +6,11 @@ use horizon_client::{ Result, command::args::GameMode, debug_keys::{CrashNotice, DebugAction, DebugHost, KeyAction, OpenScreen}, + debug_overlay, gizmos::Gizmos, - keybinds, + hud::HudBatch, + hud_layout, keybinds, + save::VERSION_NAME, text::Text, }; use horizon_core::geometry::Axis; @@ -253,6 +256,199 @@ impl Game<'_> { format!("To edit: press {}", key("key.debug.debugOptions")), ] } + /// `DebugScreenOverlay.extractRenderState` with the default profile's + /// entries, over everything the frame drew (menus too), at the debug GUI + /// scale. F1 hides it unless a screen is open. + pub(super) fn draw_debug_overlay(&self, batch: &mut HudBatch, size: [u32; 2]) { + let screen_open = self.title.is_some() || self.screen != Screen::Playing; + if !self.debug || (self.ui.hide_gui && !screen_open) { + return; + } + let framebuffer = size.map(|v| v as i32); + let (scale, [width, height]) = debug_overlay::scale( + framebuffer, + batch.scale as i32, + self.settings.file.int("debugGuiScale"), + self.settings.force_unicode, + [batch.width as i32, batch.height as i32], + ); + let mut d = debug_overlay::Displayer::default(); + // fps: DebugEntryFps. + let limit = self.framerate_limit(); + let present = self + .renderer + .as_ref() + .map_or("", |r| match r.config.present_mode { + wgpu::PresentMode::Immediate => " (immediate)", + wgpu::PresentMode::Mailbox => " (mailbox)", + wgpu::PresentMode::Fifo => " (fifo)", + wgpu::PresentMode::FifoRelaxed => " (fifo relaxed)", + _ => "", + }); + let refresh = self + .window + .as_ref() + .and_then(|w| w.current_monitor()) + .and_then(|m| m.refresh_rate_millihertz()) + .map_or("0".into(), |mhz| { + debug_overlay::refresh_rate_label(f64::from(mhz) / 1000.0) + }); + d.priority(format!( + "{} fps T: {}{present} @{refresh}Hz", + self.fps.round() as i32, + if limit == 260 { + "inf".into() + } else { + limit.to_string() + }, + )); + // game_version: DebugEntryVersion (the launched version and brand). + d.priority(format!("Minecraft {VERSION_NAME} ({VERSION_NAME}/horizon)")); + // player_position, player_section_position. + if let Some(p) = self.player.as_ref() { + let mut lines = debug_overlay::position( + [p.position.x, p.position.y, p.position.z], + self.yaw, + self.pitch, + self.dim.id(), + self.streaming.forced.len(), + ); + let section = lines.pop().unwrap_or_default(); + if !self.reduced_debug_info() { + d.group("position", lines); + } + d.group("position", [section]); + } + // simple_performance_impactors. + let s = &self.settings; + d.line(format!( + "{}{}B: {}", + if s.improved_transparency { + "improved-transparency " + } else { + "" + }, + match s.clouds.as_str() { + "false" => "", + "fast" => "fast-clouds ", + _ => "fancy-clouds ", + }, + s.biome_blend + )); + d.line("Filtering: None"); + d.line(format!( + "Terrain Rendering: {}", + if self.renderer.as_ref().is_some_and(|r| r.multi_draw) { + "multidrawindirect" + } else { + "naive" + } + )); + // system_specs (no Java line: Horizon has no JVM). + if let Some(r) = self.renderer.as_ref() { + static CPU: std::sync::OnceLock = std::sync::OnceLock::new(); + d.group( + "system", + [format!( + "CPU: {}", + CPU.get_or_init(horizon_client::crash::cpu) + )], + ); + let info = &r.info; + d.group( + "system", + [format!( + "Display: {}x{} ({})", + framebuffer[0], + framebuffer[1], + // Metal adapters report no PCI vendor. + if info.vendor == 0 && info.backend == wgpu::Backend::Metal { + "Apple".into() + } else { + debug_overlay::vendor_name(info.vendor) + } + )], + ); + if let Some(w) = self.window.as_ref() { + let density = w.scale_factor(); + let logical = w.inner_size().to_logical::(density); + d.group( + "system", + [format!( + "Window: {}x{} ({density:.2}x pixel density)", + logical.width.round() as i32, + logical.height.round() as i32 + )], + ); + } + let kind = match info.device_type { + wgpu::DeviceType::IntegratedGpu => " (iGPU)", + wgpu::DeviceType::DiscreteGpu => " (dGPU)", + wgpu::DeviceType::VirtualGpu => " (vGPU)", + wgpu::DeviceType::Cpu => " (software)", + wgpu::DeviceType::Other => "", + }; + let driver = format!("{} {}", info.driver, info.driver_info); + d.group( + "system", + [ + format!("{}{kind}", info.name), + format!( + "{:?} {}", + info.backend, + driver.trim().lines().next().unwrap_or("") + ) + .trim_end() + .to_owned(), + ], + ); + } + // tps: DebugEntryTps for the integrated server (it counts no packets). + if self.player.is_some() && self.remote.is_none() { + let (target, status) = if self.clock.sprinting() { + ("-".to_owned(), " (sprinting)") + } else if self.clock.stepping() { + ( + format!("{:.1}", 1000.0 / self.clock.rate()), + " (frozen - stepping)", + ) + } else if self.clock.frozen() { + (format!("{:.1}", 1000.0 / self.clock.rate()), " (frozen)") + } else { + (format!("{:.1}", 1000.0 / self.clock.rate()), "") + }; + d.line(format!( + "Integrated server @ {:.1}/{target} ms{status}, 0 tx, 0 rx", + self.debug_charts.smoothed_tick_ms + )); + } + let (left, right) = d.columns(&self.debug_chart_lines()); + let atlas = &self.res.atlas; + let mut draws = debug_overlay::draw(&atlas.font, [&left, &right], scale, width); + let charts = self.debug_charts.draw( + &atlas.font, + width, + height, + self.settings.max_fps, + 1000.0 / self.clock.rate(), + self.remote.is_some(), + ); + draws.push(hud_layout::GuiDraw::Push(vec![hud_layout::PoseOp::Scale( + scale, scale, + )])); + draws.extend(charts); + if self.debug_charts.lightmap + && let Some(r) = &self.renderer + { + draws.extend(horizon_client::debug_chart::lightmap( + &r.lightmap_pixels, + width, + height, + )); + } + draws.push(hud_layout::GuiDraw::Pop); + hud_layout::paint(batch, atlas, &draws); + } /// `KeyMapping.getTranslatedKeyMessage`. fn key_text(&self, mapping: &str) -> Text { keybinds::display_name(self.settings.keys.get(mapping)) diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 1120830e6..b72fc210b 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -292,7 +292,7 @@ pub struct Renderer { indirect: wgpu::Buffer, indirect_capacity: u64, /// Indirect draws may set `first_instance` (the section origin). - multi_draw: bool, + pub multi_draw: bool, /// Per-frame scratch, kept to avoid allocating every frame. visible: Vec, origins: Vec<[f32; 4]>, diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 266bde023..67dc15c81 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -47,6 +47,7 @@ pub mod data_cmd; pub mod datapack; pub mod debug_chart; pub mod debug_keys; +pub mod debug_overlay; pub mod effects; pub mod enchant; pub mod end_crystal;