Enhance layout engine with RTL support and performance optimizations

[geom3trik]

No description provided.

[Copilot]

Pull request overview

This PR extends Morphorm’s layout engine with inline RTL support, introduces Row/Column wrapping behavior, and adds cross-pass layout memoization to improve steady-state performance.

Changes:

• Add Direction (LTR/RTL) and LayoutWrap (Wrap/NoWrap) and wire them through the Node API and ECS demo world.
• Implement wrapped layout (layout_wrap) for Row/Column containers, including gaps, padding, alignment, and RTL placement.
• Add layout-result memoization hooks to Cache, implement them in the ECS NodeCache, and add tests/examples/benchmarks.

Reviewed changes

Copilot reviewed 13 out of 13 changed files in this pull request and generated 9 comments.

Show a summary per file

File	Description
src/types.rs	Adds Direction and LayoutWrap public types.
src/node.rs	Extends Node with direction()/wrap(); changes root layout axis selection.
src/layout.rs	Adds wrap layout algorithm, RTL alignment flipping, and layout-result caching/optimizations.
src/cache.rs	Adds optional memoization hooks (begin_layout_pass, get_layout_result, set_layout_result).
ecs/src/world.rs	Adds setters for direction/wrap and bumps layout revision on mutations.
ecs/src/store.rs	Stores direction/wrap components.
ecs/src/implementations.rs	Implements direction()/wrap() and layout memoization in NodeCache.
tests/wrap.rs	Adds comprehensive wrapping tests (including RTL + auto-height behavior).
tests/direction.rs	Adds RTL behavioral tests (order, padding swap, alignment flipping).
tests/auto.rs	Adds regression test for nested auto min-width propagation after flex clamping.
tests/size_constraints.rs	Updates expectations for absolute + auto-min sizing behavior.
examples/wrap.rs	Adds a runnable wrap/RTL demo.
benches/stack.rs	Adds steady-state benchmark group intended to compare cached vs baseline layout.

Comments suppressed due to low confidence (1)

src/layout.rs:1244

• In the main-axis flex loop, StretchItem.measured is never set (unlike the grid flex loops), but later it’s used in the freeze phase to decide whether to re-layout ((item.computed - item.measured).abs() > EPSILON). Since measured stays at its default (0.0), this condition will be true for most items, causing unnecessary extra layouts and undermining the intended optimization. Set item.measured to the unclamped actual_main before computing item.computed.

            for item in main_axis.iter_mut().filter(|item| !item.frozen) {
                let mut actual_main = (item.factor * free_main_space / main_flex_sum).round();

                let child = &mut children[item.index];

                if item.item_type == ItemType::Size {
                    let target_cross = if child.node.cross(store, layout_type).is_stretch() {
                        child.cross
                    } else {
                        parent_cross
                    };

                    if !child.has_layout_constraints
                        || !same_f32(child.last_layout_main, actual_main)
                        || !same_f32(child.last_layout_cross, target_cross)
                    {
                        let child_size = layout(
                            child.node,
                            layout_type,
                            actual_main,
                            target_cross,
                            cache,
                            tree,
                            store,
                            sublayout,
                        );
                        child.cross = child_size.cross;
                        actual_main = child_size.main;
                        child.last_layout_main = actual_main;
                        child.last_layout_cross = target_cross;
                        child.has_layout_constraints = true;
                    } else {
                        actual_main = child.main;
                    }

                    if child.node.min_main(store, layout_type).is_auto() {
                        item.min = child.main;
                    }
                }

                let clamped = actual_main.min(item.max).max(item.min);
                item.violation = clamped - actual_main;
                total_violation += item.violation;
                item.computed = clamped;
            }

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Pull request overview

Copilot reviewed 15 out of 15 changed files in this pull request and generated 5 comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Pull request overview

Copilot reviewed 15 out of 15 changed files in this pull request and generated 1 comment.

Comments suppressed due to low confidence (1)

src/node.rs:301

• RTL padding swapping is only applied when parent_layout_type == LayoutType::Row. For LayoutType::Column, the horizontal axis is the cross axis, so padding_cross_before/after (and likely other horizontal semantics like cross_before/after and border_cross_before/after) should also be direction-aware; otherwise Direction::RightToLeft will flip alignment but still treat left/right padding as physical, leading to inconsistent RTL behavior in column layouts and wrapped columns.

    fn padding_main_before(&self, store: &Self::Store, parent_layout_type: LayoutType) -> Units {
        if parent_layout_type == LayoutType::Row && self.direction(store).unwrap_or_default() == Direction::RightToLeft
        {
            self.padding_right(store).unwrap_or_default()
        } else {
            parent_layout_type.select_unwrap(store, |store| self.padding_left(store), |store| self.padding_top(store))
        }
    }

    fn padding_main_after(&self, store: &Self::Store, parent_layout_type: LayoutType) -> Units {
        if parent_layout_type == LayoutType::Row && self.direction(store).unwrap_or_default() == Direction::RightToLeft
        {
            self.padding_left(store).unwrap_or_default()
        } else {
            parent_layout_type.select_unwrap(
                store,
                |store| self.padding_right(store),
                |store| self.padding_bottom(store),
            )
        }
    }

    fn padding_cross_before(&self, store: &Self::Store, parent_layout_type: LayoutType) -> Units {
        parent_layout_type.select_unwrap(store, |store| self.padding_top(store), |store| self.padding_left(store))
    }

    fn padding_cross_after(&self, store: &Self::Store, parent_layout_type: LayoutType) -> Units {
        parent_layout_type.select_unwrap(store, |store| self.padding_bottom(store), |store| self.padding_right(store))
    }

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.