iris/core/src/ui/draw_state.rs

use crate::{
    ActiveData, Axis, EventsLike, Painter, SizeCtx, StrongWidget, UiRegion, UiRenderState, UiVec2,
    WidgetId, Widgets,
    render::MaskIdx,
    util::{HashSet, forget_ref},
};

/// state maintained between widgets during painting
pub struct Drawer<'a> {
    pub(super) widgets: &'a mut Widgets,
    pub(super) data: &'a mut PainterData,
    pub(super) events: &'a mut dyn EventsLike,
    pub(super) render: &'a mut UiRenderState,
    root: Option<&'a StrongWidget>,
    draw_started: HashSet<WidgetId>,
}

impl<'a> Drawer<'a> {
    /// redraws a widget that's currently active (drawn)
    pub fn redraw(&mut self, id: WidgetId) {
        self.widgets.needs_redraw.remove(&id);
        self.draw_started.remove(&id);
        // check if parent depends on the desired size of this, if so then redraw it first
        for axis in [Axis::X, Axis::Y] {
            if let Some(&(outer, old)) = self.render.cache.size.axis_dyn(axis).get(&id)
                && let Some(current) = self.render.active.get(&id)
                && let Some(pid) = current.parent
            {
                self.render.cache.size.axis_dyn(axis).remove(&id);
                let new = self.size_ctx(id, outer).len_axis(id, axis);
                self.render
                    .cache
                    .size
                    .axis_dyn(axis)
                    .insert(id, (outer, new));
                if new != old {
                    self.redraw(pid);
                }
            }
        }

        if self.draw_started.contains(&id) {
            return;
        }

        let Some(active) = self.remove(id, false) else {
            return;
        };

        self.draw_inner(
            active.layer,
            id,
            active.region,
            active.parent,
            active.mask,
            Some(active.children),
        );
    }

    pub(super) fn size_ctx<'b>(&'b mut self, source: WidgetId, outer: UiVec2) -> SizeCtx<'b> {
        SizeCtx {
            source,
            cache: &mut self.render.cache,
            text: &mut self.data.text,
            textures: &mut self.data.textures,
            widgets: &self.widgets,
            outer,
            output_size: self.render.output_size,
            id: source,
        }
    }

    pub(super) fn draw_inner(
        &mut self,
        layer: usize,
        id: WidgetId,
        region: UiRegion,
        parent: Option<WidgetId>,
        mask: MaskIdx,
        old_children: Option<Vec<WidgetId>>,
    ) {
        let mut old_children = old_children.unwrap_or_default();
        if let Some(active) = self.render.active.get_mut(&id)
            && !self.widgets.needs_redraw.contains(&id)
        {
            // check to see if we can skip drawing first
            if active.region == region {
                return;
            } else if active.region.size() == region.size() {
                // TODO: epsilon?
                let from = active.region;
                self.mov(id, from, region);
                return;
            }
            // if not, then maintain resize and track old children to remove unneeded
            let active = self.remove(id, false).unwrap();
            old_children = active.children;
        }

        // draw widget
        self.draw_started.insert(id);

        let mut painter = Painter {
            drawer: self,
            region,
            mask,
            layer,
            id,
            textures: Vec::new(),
            primitives: Vec::new(),
            children: Vec::new(),
        };

        let mut widget = painter.drawer.widgets.get_dyn_dynamic(id);
        widget.draw(&mut painter);
        drop(widget);

        let Painter {
            drawer: _,
            region,
            mask,
            textures,
            primitives,
            children,
            layer,
            id,
        } = painter;

        // add to active
        let active = ActiveData {
            id,
            region,
            parent,
            textures,
            primitives,
            children,
            mask,
            layer,
        };

        // remove old children that weren't kept
        for c in &old_children {
            if !active.children.contains(c) {
                self.remove_rec(*c);
            }
        }

        // update modules
        self.events.draw(&active);
        self.render.active.insert(id, active);
    }

    fn mov(&mut self, id: WidgetId, from: UiRegion, to: UiRegion) {
        let active = self.render.active.get_mut(&id).unwrap();
        for h in &active.primitives {
            let region = self.render.layers[h.layer].region_mut(h);
            *region = region.outside(&from).within(&to);
        }
        active.region = active.region.outside(&from).within(&to);
        // SAFETY: children cannot be recursive
        let children = unsafe { forget_ref(&active.children) };
        for child in children {
            self.mov(*child, from, to);
        }
    }

    /// NOTE: instance textures are cleared and self.textures freed
    fn remove(&mut self, id: WidgetId, undraw: bool) -> Option<ActiveData> {
        let mut active = self.render.active.remove(&id);
        if let Some(active) = &mut active {
            for h in &active.primitives {
                let mask = self.render.layers.free(h);
                if mask != MaskIdx::NONE {
                    self.data.masks.remove(mask);
                }
            }
            active.textures.clear();
            self.data.textures.free();
            if undraw {
                self.events.undraw(active);
            }
        }
        active
    }

    fn remove_rec(&mut self, id: WidgetId) -> Option<ActiveData> {
        self.render.cache.remove(id);
        let inst = self.remove(id, true);
        if let Some(inst) = &inst {
            for c in &inst.children {
                self.remove_rec(*c);
            }
        }
        inst
    }
}