//! Screen-space 2D overlay drawn after the 3D scene. //! //! The overlay is a list of rectangles, lines and text in target pixels with the //! origin at the top-left. One triangle batch draws all of it with depth testing //! disabled and alpha blending: solid shapes sample a white texel of the glyph //! atlas, text samples glyph coverage. mod atlas; mod pass; mod text; #[cfg(test)] mod tests; pub(crate) use pass::{OverlayRenderer, Target}; /// A filled rectangle in target pixels. #[derive(Debug, Clone, Copy, PartialEq)] pub struct OverlayRect { pub x: f32, pub y: f32, pub w: f32, pub h: f32, pub color: [f32; 4], } impl OverlayRect { /// A rectangle at `(x, y)` with a size and a linear RGBA colour. #[must_use] pub fn new(x: f32, y: f32, w: f32, h: f32, color: [f32; 4]) -> Self { Self { x, y, w, h, color } } } /// A straight line of a given width in target pixels. #[derive(Debug, Clone, Copy, PartialEq)] pub struct OverlayLine { pub from: [f32; 2], pub to: [f32; 2], pub width: f32, pub color: [f32; 4], } impl OverlayLine { /// A line from `from` to `to` with a width and a linear RGBA colour. #[must_use] pub fn new(from: [f32; 2], to: [f32; 2], width: f32, color: [f32; 4]) -> Self { Self { from, to, width, color, } } } /// One line of ASCII text, anchored at its top-left corner. #[derive(Debug, Clone, PartialEq)] pub struct OverlayText { pub x: f32, pub y: f32, pub size: f32, pub color: [f32; 4], pub text: String, } impl OverlayText { /// Text at `(x, y)` in pixels with a font size and a linear RGBA colour. #[must_use] pub fn new(x: f32, y: f32, size: f32, color: [f32; 4], text: impl Into) -> Self { Self { x, y, size, color, text: text.into(), } } } /// Everything the overlay pass draws in one frame. #[derive(Debug, Clone, Default, PartialEq)] pub struct Overlay { pub rects: Vec, pub lines: Vec, pub texts: Vec, } impl Overlay { /// An empty overlay. #[must_use] pub fn new() -> Self { Self::default() } /// Drops all shapes but keeps the allocated buffers. pub fn clear(&mut self) { self.rects.clear(); self.lines.clear(); self.texts.clear(); } /// Whether the overlay would draw nothing. #[must_use] pub fn is_empty(&self) -> bool { self.rects.is_empty() && self.lines.is_empty() && self.texts.is_empty() } /// Queues a filled rectangle. pub fn push_rect(&mut self, rect: OverlayRect) { self.rects.push(rect); } /// Queues a line. pub fn push_line(&mut self, line: OverlayLine) { self.lines.push(line); } /// Queues a text line. pub fn push_text(&mut self, text: OverlayText) { self.texts.push(text); } }