cranpose_ui/modifier/
slices.rs

1use std::fmt;
2use std::rc::Rc;
3
4use cranpose_foundation::{ModifierNodeChain, NodeCapabilities, PointerEvent};
5use cranpose_ui_graphics::{ColorFilter, GraphicsLayer, RenderEffect};
6
7use super::{ModifierChainHandle, Point};
8use crate::draw::DrawCommand;
9use crate::modifier::Modifier;
10use crate::modifier_nodes::{
11    BackgroundNode, ClipToBoundsNode, CornerShapeNode, DrawCommandNode, GraphicsLayerNode,
12    PaddingNode,
13};
14use crate::text::{TextLayoutOptions, TextStyle};
15use crate::text_field_modifier_node::TextFieldModifierNode;
16use crate::text_modifier_node::{TextModifierNode, TextPreparedLayoutHandle};
17use cranpose_ui_graphics::EdgeInsets;
18
19/// Snapshot of modifier node slices that impact draw and pointer subsystems.
20#[derive(Default)]
21pub struct ModifierNodeSlices {
22    draw_commands: Vec<DrawCommand>,
23    pointer_inputs: Vec<Rc<dyn Fn(PointerEvent)>>,
24    click_handlers: Vec<Rc<dyn Fn(Point)>>,
25    clip_to_bounds: bool,
26    text_content: Option<Rc<crate::text::AnnotatedString>>,
27    text_style: Option<TextStyle>,
28    text_layout_options: Option<TextLayoutOptions>,
29    prepared_text_layout: Option<TextPreparedLayoutHandle>,
30    graphics_layer: Option<GraphicsLayer>,
31    graphics_layer_resolver: Option<Rc<dyn Fn() -> GraphicsLayer>>,
32    chain_guard: Option<Rc<ChainGuard>>,
33}
34
35struct ChainGuard {
36    _handle: ModifierChainHandle,
37}
38
39impl Clone for ModifierNodeSlices {
40    fn clone(&self) -> Self {
41        Self {
42            draw_commands: self.draw_commands.clone(),
43            pointer_inputs: self.pointer_inputs.clone(),
44            click_handlers: self.click_handlers.clone(),
45            clip_to_bounds: self.clip_to_bounds,
46            text_content: self.text_content.clone(),
47            text_style: self.text_style.clone(),
48            text_layout_options: self.text_layout_options,
49            prepared_text_layout: self.prepared_text_layout.clone(),
50            graphics_layer: self.graphics_layer.clone(),
51            graphics_layer_resolver: self.graphics_layer_resolver.clone(),
52            chain_guard: self.chain_guard.clone(),
53        }
54    }
55}
56
57/// Compose two nested graphics layers (`base` outer, `overlay` inner) into one
58/// flattened layer snapshot used by render pipelines.
59///
60/// Composition rules follow how nested transforms/effects behave visually:
61/// - Multiplicative: `alpha`, `scale`, `scale_x`, `scale_y`
62/// - Additive: `rotation_*`, `translation_*`
63/// - Boolean OR: `clip`
64/// - Overlay-wins when explicitly set: camera distance, transform origin,
65///   shadow elevation/colors, shape, compositing strategy, blend mode
66/// - Filters/effects are composed in draw order:
67///   - color filters are multiplied where possible
68///   - render effects chain inner-first then outer (`inner.then(outer)`)
69/// - Backdrop effect keeps the most local explicit backdrop effect because
70///   backdrop sampling cannot be safely flattened as a deterministic chain.
71fn merge_graphics_layers(base: GraphicsLayer, overlay: GraphicsLayer) -> GraphicsLayer {
72    GraphicsLayer {
73        alpha: (base.alpha * overlay.alpha).clamp(0.0, 1.0),
74        scale: base.scale * overlay.scale,
75        scale_x: base.scale_x * overlay.scale_x,
76        scale_y: base.scale_y * overlay.scale_y,
77        rotation_x: base.rotation_x + overlay.rotation_x,
78        rotation_y: base.rotation_y + overlay.rotation_y,
79        rotation_z: base.rotation_z + overlay.rotation_z,
80        camera_distance: overlay.camera_distance,
81        transform_origin: overlay.transform_origin,
82        translation_x: base.translation_x + overlay.translation_x,
83        translation_y: base.translation_y + overlay.translation_y,
84        shadow_elevation: overlay.shadow_elevation,
85        ambient_shadow_color: overlay.ambient_shadow_color,
86        spot_shadow_color: overlay.spot_shadow_color,
87        shape: overlay.shape,
88        clip: base.clip || overlay.clip,
89        compositing_strategy: overlay.compositing_strategy,
90        blend_mode: overlay.blend_mode,
91        color_filter: compose_color_filters(base.color_filter, overlay.color_filter),
92        // Modifiers are traversed outer -> inner. Layer effects therefore compose
93        // inner-first, then outer, matching nested layer rendering semantics.
94        render_effect: compose_render_effects(base.render_effect, overlay.render_effect),
95        // Backdrop effects cannot be represented as a deterministic chain on a
96        // flattened single layer, so keep the most local explicit backdrop.
97        backdrop_effect: overlay.backdrop_effect.or(base.backdrop_effect),
98    }
99}
100
101fn compose_render_effects(
102    outer: Option<RenderEffect>,
103    inner: Option<RenderEffect>,
104) -> Option<RenderEffect> {
105    match (outer, inner) {
106        (None, None) => None,
107        (Some(effect), None) | (None, Some(effect)) => Some(effect),
108        (Some(outer_effect), Some(inner_effect)) => Some(inner_effect.then(outer_effect)),
109    }
110}
111
112fn compose_color_filters(
113    base: Option<ColorFilter>,
114    overlay: Option<ColorFilter>,
115) -> Option<ColorFilter> {
116    match (base, overlay) {
117        (None, None) => None,
118        (Some(filter), None) | (None, Some(filter)) => Some(filter),
119        (Some(filter), Some(next)) => Some(filter.compose(next)),
120    }
121}
122
123impl ModifierNodeSlices {
124    pub fn draw_commands(&self) -> &[DrawCommand] {
125        &self.draw_commands
126    }
127
128    pub fn pointer_inputs(&self) -> &[Rc<dyn Fn(PointerEvent)>] {
129        &self.pointer_inputs
130    }
131
132    pub fn click_handlers(&self) -> &[Rc<dyn Fn(Point)>] {
133        &self.click_handlers
134    }
135
136    pub fn clip_to_bounds(&self) -> bool {
137        self.clip_to_bounds
138    }
139
140    pub fn text_content(&self) -> Option<&str> {
141        self.text_content.as_ref().map(|a| a.text.as_str())
142    }
143
144    pub fn annotated_text(&self) -> Option<&crate::text::AnnotatedString> {
145        self.text_content.as_deref()
146    }
147
148    pub fn annotated_string(&self) -> Option<crate::text::AnnotatedString> {
149        self.annotated_text().cloned()
150    }
151
152    pub fn text_style(&self) -> Option<&TextStyle> {
153        self.text_style.as_ref()
154    }
155
156    pub fn text_layout_options(&self) -> Option<TextLayoutOptions> {
157        self.text_layout_options
158    }
159
160    pub fn prepare_text_layout(
161        &self,
162        max_width: Option<f32>,
163    ) -> Option<crate::text::PreparedTextLayout> {
164        if let Some(handle) = &self.prepared_text_layout {
165            return Some(handle.prepare(max_width));
166        }
167
168        let text = self.annotated_text()?;
169        let style = self.text_style.clone().unwrap_or_default();
170        Some(crate::text::prepare_text_layout(
171            text,
172            &style,
173            self.text_layout_options.unwrap_or_default(),
174            max_width,
175        ))
176    }
177
178    pub fn graphics_layer(&self) -> Option<GraphicsLayer> {
179        if let Some(resolve) = &self.graphics_layer_resolver {
180            Some(resolve())
181        } else {
182            self.graphics_layer.clone()
183        }
184    }
185
186    fn push_graphics_layer(
187        &mut self,
188        layer: GraphicsLayer,
189        resolver: Option<Rc<dyn Fn() -> GraphicsLayer>>,
190    ) {
191        let existing_snapshot = self.graphics_layer();
192        let next_snapshot = existing_snapshot
193            .as_ref()
194            .map(|current| merge_graphics_layers(current.clone(), layer.clone()))
195            .unwrap_or_else(|| layer.clone());
196        let existing_resolver = self.graphics_layer_resolver.clone();
197
198        self.graphics_layer = Some(next_snapshot);
199        self.graphics_layer_resolver = match (existing_resolver, resolver) {
200            (None, None) => None,
201            (Some(current_resolver), None) => {
202                let layer = layer.clone();
203                Some(Rc::new(move || {
204                    merge_graphics_layers(current_resolver(), layer.clone())
205                }))
206            }
207            (None, Some(next_resolver)) => {
208                let base = existing_snapshot.unwrap_or_default();
209                Some(Rc::new(move || {
210                    merge_graphics_layers(base.clone(), next_resolver())
211                }))
212            }
213            (Some(current_resolver), Some(next_resolver)) => Some(Rc::new(move || {
214                merge_graphics_layers(current_resolver(), next_resolver())
215            })),
216        };
217    }
218
219    pub fn with_chain_guard(mut self, handle: ModifierChainHandle) -> Self {
220        self.chain_guard = Some(Rc::new(ChainGuard { _handle: handle }));
221        self
222    }
223
224    /// Resets the slice collection for reuse, retaining vector capacity.
225    pub fn clear(&mut self) {
226        self.draw_commands.clear();
227        self.pointer_inputs.clear();
228        self.click_handlers.clear();
229        self.clip_to_bounds = false;
230        self.text_content = None;
231        self.text_style = None;
232        self.text_layout_options = None;
233        self.prepared_text_layout = None;
234        self.graphics_layer = None;
235        self.graphics_layer_resolver = None;
236        self.chain_guard = None;
237    }
238}
239
240impl fmt::Debug for ModifierNodeSlices {
241    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
242        f.debug_struct("ModifierNodeSlices")
243            .field("draw_commands", &self.draw_commands.len())
244            .field("pointer_inputs", &self.pointer_inputs.len())
245            .field("click_handlers", &self.click_handlers.len())
246            .field("clip_to_bounds", &self.clip_to_bounds)
247            .field("text_content", &self.text_content)
248            .field("text_style", &self.text_style)
249            .field("text_layout_options", &self.text_layout_options)
250            .field("prepared_text_layout", &self.prepared_text_layout.is_some())
251            .field("graphics_layer", &self.graphics_layer)
252            .field(
253                "graphics_layer_resolver",
254                &self.graphics_layer_resolver.is_some(),
255            )
256            .finish()
257    }
258}
259
260/// Collects modifier node slices directly from a reconciled [`ModifierNodeChain`].
261pub fn collect_modifier_slices(chain: &ModifierNodeChain) -> ModifierNodeSlices {
262    let mut slices = ModifierNodeSlices::default();
263    collect_modifier_slices_into(chain, &mut slices);
264    slices
265}
266
267/// Collects modifier node slices into an existing buffer to reuse allocations.
268///
269/// Single-pass: iterates the chain once instead of 4 separate capability-filtered
270/// traversals, reducing per-node `RefCell::borrow()` overhead.
271pub fn collect_modifier_slices_into(chain: &ModifierNodeChain, slices: &mut ModifierNodeSlices) {
272    slices.clear();
273
274    let caps = chain.capabilities();
275    let has_pointer = caps.intersects(NodeCapabilities::POINTER_INPUT);
276    let has_draw = caps.intersects(NodeCapabilities::DRAW);
277    let has_layout = caps.intersects(NodeCapabilities::LAYOUT);
278
279    if !has_pointer && !has_draw && !has_layout {
280        return;
281    }
282
283    let mut background_color = None;
284    let mut background_insert_index = None::<usize>;
285    let mut corner_shape = None;
286    let mut padding = EdgeInsets::default();
287
288    for node_ref in chain.head_to_tail() {
289        let node_caps = node_ref.kind_set();
290
291        node_ref.with_node(|node| {
292            let any = node.as_any();
293
294            // POINTER_INPUT collection
295            if has_pointer && node_caps.intersects(NodeCapabilities::POINTER_INPUT) {
296                if let Some(handler) = node
297                    .as_pointer_input_node()
298                    .and_then(|n| n.pointer_input_handler())
299                {
300                    slices.pointer_inputs.push(handler);
301                }
302            }
303
304            // DRAW collection
305            if has_draw && node_caps.intersects(NodeCapabilities::DRAW) {
306                if let Some(bg_node) = any.downcast_ref::<BackgroundNode>() {
307                    background_color = Some(bg_node.color());
308                    background_insert_index = Some(slices.draw_commands.len());
309                    if bg_node.shape().is_some() {
310                        corner_shape = bg_node.shape();
311                    }
312                }
313
314                if let Some(shape_node) = any.downcast_ref::<CornerShapeNode>() {
315                    corner_shape = Some(shape_node.shape());
316                }
317
318                if let Some(commands) = any.downcast_ref::<DrawCommandNode>() {
319                    slices
320                        .draw_commands
321                        .extend(commands.commands().iter().cloned());
322                }
323
324                if let Some(draw_node) = node.as_draw_node() {
325                    if let Some(closure) = draw_node.create_draw_closure() {
326                        slices.draw_commands.push(DrawCommand::Overlay(closure));
327                    } else {
328                        use cranpose_ui_graphics::{DrawScope as _, DrawScopeDefault};
329                        let mut scope = DrawScopeDefault::new(crate::modifier::Size {
330                            width: 0.0,
331                            height: 0.0,
332                        });
333                        draw_node.draw(&mut scope);
334                        let primitives = scope.into_primitives();
335                        if !primitives.is_empty() {
336                            let draw_cmd =
337                                Rc::new(move |_size: crate::modifier::Size| primitives.clone());
338                            slices.draw_commands.push(DrawCommand::Overlay(draw_cmd));
339                        }
340                    }
341                }
342
343                if let Some(layer_node) = any.downcast_ref::<GraphicsLayerNode>() {
344                    slices.push_graphics_layer(layer_node.layer(), layer_node.layer_resolver());
345                }
346
347                if any.is::<ClipToBoundsNode>() {
348                    slices.clip_to_bounds = true;
349                }
350            }
351
352            // LAYOUT collection (padding + text)
353            if has_layout && node_caps.intersects(NodeCapabilities::LAYOUT) {
354                if let Some(padding_node) = any.downcast_ref::<PaddingNode>() {
355                    let p = padding_node.padding();
356                    padding.left += p.left;
357                    padding.top += p.top;
358                    padding.right += p.right;
359                    padding.bottom += p.bottom;
360                }
361
362                if let Some(text_node) = any.downcast_ref::<TextModifierNode>() {
363                    slices.text_content = Some(text_node.annotated_text());
364                    slices.text_style = Some(text_node.style().clone());
365                    slices.text_layout_options = Some(text_node.options());
366                    slices.prepared_text_layout = Some(text_node.prepared_layout_handle());
367                }
368
369                if let Some(text_field_node) = any.downcast_ref::<TextFieldModifierNode>() {
370                    let text = text_field_node.text();
371                    slices.text_content = Some(Rc::new(crate::text::AnnotatedString::from(text)));
372                    slices.text_style = Some(text_field_node.style().clone());
373                    slices.text_layout_options = Some(TextLayoutOptions::default());
374                    slices.prepared_text_layout = None;
375
376                    text_field_node.set_content_offset(padding.left);
377                    text_field_node.set_content_y_offset(padding.top);
378                }
379            }
380        });
381    }
382
383    // Convert background + shape into a draw command
384    if let Some(color) = background_color {
385        let draw_cmd = Rc::new(move |size: crate::modifier::Size| {
386            use crate::modifier::{Brush, Rect};
387            use cranpose_ui_graphics::DrawPrimitive;
388
389            let brush = Brush::solid(color);
390            let rect = Rect {
391                x: 0.0,
392                y: 0.0,
393                width: size.width,
394                height: size.height,
395            };
396
397            if let Some(shape) = corner_shape {
398                let radii = shape.resolve(size.width, size.height);
399                vec![DrawPrimitive::RoundRect { rect, brush, radii }]
400            } else {
401                vec![DrawPrimitive::Rect { rect, brush }]
402            }
403        });
404
405        let insert_index = background_insert_index
406            .unwrap_or(0)
407            .min(slices.draw_commands.len());
408        slices
409            .draw_commands
410            .insert(insert_index, DrawCommand::Behind(draw_cmd));
411    }
412}
413
414/// Collects modifier node slices by instantiating a temporary node chain from a [`Modifier`].
415pub fn collect_slices_from_modifier(modifier: &Modifier) -> ModifierNodeSlices {
416    let mut handle = ModifierChainHandle::new();
417    let _ = handle.update(modifier);
418    collect_modifier_slices(handle.chain()).with_chain_guard(handle)
419}
cranpose_ui/modifier/slices.rs

cranpose_ui/modifier/
slices.rs
