use crate::overlay::Overlay;
use crate::ui::damage::{self, Damage};
use crate::ui::region::Culled;
use crate::ui::{OverlayPainter, Rect, Ui};
use super::{MetalError, MetalRenderer, PassAttachments};
pub struct MetalUi {
overlay: Overlay,
last: Vec<damage::Node>,
scale: f32,
stale: bool,
scratch: Overlay,
}
impl Default for MetalUi {
fn default() -> Self {
Self::new()
}
}
impl MetalUi {
pub fn new() -> Self {
Self { overlay: Overlay::new(1, 1), last: Vec::new(), scale: 0.0, stale: true, scratch: Overlay::new(1, 1) }
}
pub fn update(&mut self, ui: &mut Ui, width: u32, height: u32, scale: f32) -> bool {
let (width, height, scale) = (width.max(1), height.max(1), scale.max(0.01));
if self.overlay.size() != (width, height) {
self.overlay.resize(width, height);
self.stale = true;
}
if scale != self.scale {
self.scale = scale;
self.stale = true;
}
let (w, h) = (width as f32 / scale, height as f32 / scale);
ui.layout(w, h, &mut OverlayPainter::with_scale(&mut self.overlay, scale));
let now = damage::collect(ui);
let damage = if self.stale { Damage::Full } else { damage::diff(&self.last, &now, w, h) };
self.last = now;
self.stale = false;
match damage {
Damage::None => false,
Damage::Full => {
self.overlay.clear();
ui.paint(&mut OverlayPainter::with_scale(&mut self.overlay, scale));
true
}
Damage::Regions(regions) => {
for r in regions {
self.repaint(ui, r);
}
true
}
}
}
fn repaint(&mut self, ui: &Ui, r: Rect) {
const SHADOW: f32 = 12.0;
let r = Rect { x: r.x - SHADOW, y: r.y - SHADOW, width: r.width + 2.0 * SHADOW, height: r.height + 2.0 * SHADOW };
let k = self.scale;
let (fw, fh) = self.overlay.size();
let (x0, y0) = (((r.x * k).floor() as i32).max(0), ((r.y * k).floor() as i32).max(0));
let (x1, y1) = ((((r.x + r.width) * k).ceil() as i32).min(fw as i32), (((r.y + r.height) * k).ceil() as i32).min(fh as i32));
let (w, h) = ((x1 - x0).max(0) as u32, (y1 - y0).max(0) as u32);
if w == 0 || h == 0 {
return;
}
if self.scratch.size() != (fw, fh) {
self.scratch.resize(fw, fh);
}
self.scratch.put_image_data(x0, y0, w, h, &vec![0; w as usize * h as usize * 4]);
let reach = Rect { x: x0 as f32 / k, y: y0 as f32 / k, width: w as f32 / k, height: h as f32 / k };
ui.paint(&mut Culled::new(&mut OverlayPainter::with_scale(&mut self.scratch, k), reach));
let row = fw as usize * 4;
let src = self.scratch.pixels();
let mut out = Vec::with_capacity(w as usize * h as usize * 4);
for y in y0 as usize..y1 as usize {
out.extend_from_slice(&src[y * row + x0 as usize * 4..y * row + x1 as usize * 4]);
}
self.overlay.put_image_data(x0, y0, w, h, &out);
}
pub fn invalidate(&mut self) {
self.stale = true;
}
pub fn pixels(&self) -> &[u8] {
self.overlay.pixels()
}
pub fn size(&self) -> (u32, u32) {
self.overlay.size()
}
pub fn draw(&mut self, renderer: &mut MetalRenderer, pass: &PassAttachments) -> Result<(), MetalError> {
renderer.draw_overlay(&mut self.overlay, pass)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ui::style;
fn ui_with(blue: bool) -> Ui {
let mut ui = Ui::new();
let root = ui.root();
ui.add_box(root, style! { width: 40px; height: 20px; background: #ff0000; border-radius: 6px; });
if blue {
ui.add_box(root, style! { width: 40px; height: 20px; background: #0000ff; });
} else {
ui.add_box(root, style! { width: 40px; height: 20px; background: #00ff00; });
}
ui
}
#[test]
fn a_change_repaints_as_a_whole_paint_would() {
let mut hud = MetalUi::new();
let mut ui = ui_with(false);
assert!(hud.update(&mut ui, 100, 100, 2.0));
assert!(!hud.update(&mut ui, 100, 100, 2.0), "nothing changed, nothing painted");
let mut ui = ui_with(true);
assert!(hud.update(&mut ui, 100, 100, 2.0));
let whole = crate::ui::paint_to_rgba(&ui, 2.0, 100, 100);
assert_eq!(hud.pixels(), &whole[..]);
}
fn shadow_at(x: f32) -> Ui {
let mut ui = Ui::new();
let root = ui.root();
let b = ui.add_box(root, style! { position: absolute; top: 20px; width: 20px; height: 20px; border-radius: 10px; background: #ffffff; box-shadow: 0 1px 4px rgba(0,0,0,0.4); });
ui.update_style(b, |s| s.left = crate::ui::Length::Px(x));
ui
}
#[test]
fn a_moved_shadow_leaves_nothing_behind() {
let mut hud = MetalUi::new();
let mut ui = shadow_at(10.0);
assert!(hud.update(&mut ui, 160, 120, 2.0));
let mut ui = shadow_at(60.0);
assert!(hud.update(&mut ui, 160, 120, 2.0));
let whole = crate::ui::paint_to_rgba(&ui, 2.0, 160, 120);
assert_eq!(hud.pixels(), &whole[..]);
}
fn corner_with(blue: bool) -> Ui {
let mut ui = Ui::new();
let root = ui.root();
ui.add_box(root, style! { position: absolute; left: 10px; top: 10px; width: 60px; height: 40px; background: #ffffff; border-radius: 16px; });
let over = ui.add_box(root, style! { position: absolute; left: 0px; top: 0px; width: 16px; height: 16px; });
ui.update_style(over, |s| s.background = Some(if blue { [0.0, 0.0, 1.0, 0.5] } else { [0.0, 1.0, 0.0, 0.5] }));
ui
}
#[test]
fn a_rounded_corner_cut_by_the_damage_stays_round() {
let mut hud = MetalUi::new();
let mut ui = corner_with(false);
assert!(hud.update(&mut ui, 160, 120, 2.0));
let mut ui = corner_with(true);
assert!(hud.update(&mut ui, 160, 120, 2.0));
let whole = crate::ui::paint_to_rgba(&ui, 2.0, 160, 120);
assert_eq!(hud.pixels(), &whole[..]);
}
}