Overriding engine systems?

[aleqdev]

Looking through implementation of ui_focus_system, i noticed this comment:

// Interactions are only supported for cameras rendering to a window.

As my ui camera needs to be rendered to texture, interactions don't work (Hover, Click e.t.c)
Luckly, ui_focus_system is fairly easy to modify to support my specific case. So i want to write a modified copy of this system and replace with it original engine variant. Is there a way to disable systems? Or maybe reconfigure system sets? If not, i will try to disable ui plugin and re-add everything by hand, but it is undesirable.

[alice-i-cecile]

You can add run conditions to public systems and system sets. While we don't have true system removal yet, you can just slap a run condition that's always false on there for now.

[aleqdev]

thanks, that did the trick. I will paste some code snippets for people that may face same issue - missing interactions when rendering ui to texture that is rescaled

// override ui_focus engine system
{
    app.add_systems(
        PreUpdate,
        override_engine::custom_ui_focus_system.after(InputSystem),
    );
    app.configure_sets(PreUpdate, UiSystem::Focus.run_if(|| false));
}

pub mod override_engine {
    use bevy::{
        ecs::query::QueryData,
        prelude::*,
        render::camera::NormalizedRenderTarget,
        ui::{FocusPolicy, RelativeCursorPosition},
        utils::HashMap,
        window::PrimaryWindow,
    };
    use smallvec::SmallVec;

    fn pick_rounded_rect(point: Vec2, size: Vec2, border_radius: ResolvedBorderRadius) -> bool {
        let [top, bottom] = if point.x < 0. {
            [border_radius.top_left, border_radius.bottom_left]
        } else {
            [border_radius.top_right, border_radius.bottom_right]
        };
        let r = if point.y < 0. { top } else { bottom };

        let corner_to_point = point.abs() - 0.5 * size;
        let q = corner_to_point + r;
        let l = q.max(Vec2::ZERO).length();
        let m = q.max_element().min(0.);
        l + m - r < 0.
    }

    #[derive(Default)]
    pub struct State {
        entities_to_reset: SmallVec<[Entity; 1]>,
    }

    #[derive(QueryData)]
    #[query_data(mutable)]
    pub struct NodeQuery {
        entity: Entity,
        node: &'static ComputedNode,
        global_transform: &'static GlobalTransform,
        interaction: Option<&'static mut Interaction>,
        relative_cursor_position: Option<&'static mut RelativeCursorPosition>,
        focus_policy: Option<&'static FocusPolicy>,
        calculated_clip: Option<&'static CalculatedClip>,
        view_visibility: Option<&'static ViewVisibility>,
        target_camera: Option<&'static TargetCamera>,
    }

    // Supports render-to-texture ui cameras
    pub fn custom_ui_focus_system(
        mut state: Local<State>,
        camera_query: Query<(Entity, &Camera)>,
        default_ui_camera: DefaultUiCamera,
        primary_window: Query<Entity, With<PrimaryWindow>>,
        windows: Query<&Window>,
        mouse_button_input: Res<ButtonInput<MouseButton>>,
        touches_input: Res<Touches>,
        ui_stack: Res<bevy::ui::UiStack>,
        mut node_query: Query<NodeQuery>,
        textures: Res<Assets<Image>>,
    ) {
        let primary_window = primary_window.iter().next();

        // reset entities that were both clicked and released in the last frame
        for entity in state.entities_to_reset.drain(..) {
            if let Ok(NodeQueryItem {
                interaction: Some(mut interaction),
                ..
            }) = node_query.get_mut(entity)
            {
                *interaction = Interaction::None;
            }
        }

        let mouse_released = mouse_button_input.just_released(MouseButton::Left)
            || touches_input.any_just_released();
        if mouse_released {
            for node in &mut node_query {
                if let Some(mut interaction) = node.interaction {
                    if *interaction == Interaction::Pressed {
                        *interaction = Interaction::None;
                    }
                }
            }
        }

        let mouse_clicked =
            mouse_button_input.just_pressed(MouseButton::Left) || touches_input.any_just_pressed();

        let camera_cursor_positions: HashMap<Entity, Vec2> = camera_query
            .iter()
            .filter_map(
                |(entity, camera)| match camera.target.normalize(primary_window) {
                    Some(NormalizedRenderTarget::Window(window_ref)) => {
                        let window = windows.get(window_ref.entity()).ok()?;

                        let viewport_position = camera
                            .physical_viewport_rect()
                            .map(|rect| rect.min.as_vec2())
                            .unwrap_or_default();
                        window
                            .physical_cursor_position()
                            .or_else(|| {
                                touches_input
                                    .first_pressed_position()
                                    .map(|pos| pos * window.scale_factor())
                            })
                            .map(|cursor_position| (entity, cursor_position - viewport_position))
                    }
                    Some(NormalizedRenderTarget::Image(handle)) => {
                        let texture = textures.get(&handle).unwrap();

                        let Some(primary_window) = primary_window else {
                            return None;
                        };

                        let window = windows.get(primary_window).ok()?;

                        let viewport_position = camera
                            .physical_viewport_rect()
                            .map(|rect| rect.min.as_vec2())
                            .unwrap_or_default();

                        window
                            .physical_cursor_position()
                            .or_else(|| {
                                touches_input
                                    .first_pressed_position()
                                    .map(|pos| pos * window.scale_factor())
                            })
                            .map(|cursor_position| {
                                (
                                    entity,
                                    (cursor_position - viewport_position)
                                        / window.physical_size().as_vec2()
                                        * texture.size_f32(),
                                )
                            })
                    }
                    _ => return None,
                },
            )
            .collect();

        // prepare an iterator that contains all the nodes that have the cursor in their rect,
        // from the top node to the bottom one. this will also reset the interaction to `None`
        // for all nodes encountered that are no longer hovered.
        let mut hovered_nodes = ui_stack
            .uinodes
            .iter()
            // reverse the iterator to traverse the tree from closest nodes to furthest
            .rev()
            .filter_map(|entity| {
                let Ok(node) = node_query.get_mut(*entity) else {
                    return None;
                };

                let view_visibility = node.view_visibility?;
                // Nodes that are not rendered should not be interactable
                if !view_visibility.get() {
                    // Reset their interaction to None to avoid strange stuck state
                    if let Some(mut interaction) = node.interaction {
                        // We cannot simply set the interaction to None, as that will trigger change detection repeatedly
                        interaction.set_if_neq(Interaction::None);
                    }
                    return None;
                }
                let camera_entity = node
                    .target_camera
                    .map(TargetCamera::entity)
                    .or(default_ui_camera.get())?;

                let node_rect = Rect::from_center_size(
                    node.global_transform.translation().truncate(),
                    node.node.size(),
                );

                // Intersect with the calculated clip rect to find the bounds of the visible region of the node
                let visible_rect = node
                    .calculated_clip
                    .map(|clip| node_rect.intersect(clip.clip))
                    .unwrap_or(node_rect);

                let cursor_position = camera_cursor_positions.get(&camera_entity);

                // The mouse position relative to the node
                // (0., 0.) is the top-left corner, (1., 1.) is the bottom-right corner
                // Coordinates are relative to the entire node, not just the visible region.
                let relative_cursor_position = cursor_position.and_then(|cursor_position| {
                    // ensure node size is non-zero in all dimensions, otherwise relative position will be
                    // +/-inf. if the node is hidden, the visible rect min/max will also be -inf leading to
                    // false positives for mouse_over (#12395)
                    (node_rect.size().cmpgt(Vec2::ZERO).all())
                        .then_some((*cursor_position - node_rect.min) / node_rect.size())
                });

                // If the current cursor position is within the bounds of the node's visible area, consider it for
                // clicking
                let relative_cursor_position_component = RelativeCursorPosition {
                    normalized_visible_node_rect: visible_rect.normalize(node_rect),
                    normalized: relative_cursor_position,
                };

                let contains_cursor = relative_cursor_position_component.mouse_over()
                    && cursor_position
                        .map(|point| {
                            pick_rounded_rect(
                                *point - node_rect.center(),
                                node_rect.size(),
                                node.node.border_radius(),
                            )
                        })
                        .unwrap_or(false);

                // Save the relative cursor position to the correct component
                if let Some(mut node_relative_cursor_position_component) =
                    node.relative_cursor_position
                {
                    *node_relative_cursor_position_component = relative_cursor_position_component;
                }

                if contains_cursor {
                    Some(*entity)
                } else {
                    if let Some(mut interaction) = node.interaction {
                        if *interaction == Interaction::Hovered
                            || (relative_cursor_position.is_none())
                        {
                            interaction.set_if_neq(Interaction::None);
                        }
                    }
                    None
                }
            })
            .collect::<Vec<Entity>>()
            .into_iter();

        // set Pressed or Hovered on top nodes. as soon as a node with a `Block` focus policy is detected,
        // the iteration will stop on it because it "captures" the interaction.
        let mut iter = node_query.iter_many_mut(hovered_nodes.by_ref());
        while let Some(node) = iter.fetch_next() {
            if let Some(mut interaction) = node.interaction {
                if mouse_clicked {
                    // only consider nodes with Interaction "pressed"
                    if *interaction != Interaction::Pressed {
                        *interaction = Interaction::Pressed;
                        // if the mouse was simultaneously released, reset this Interaction in the next
                        // frame
                        if mouse_released {
                            state.entities_to_reset.push(node.entity);
                        }
                    }
                } else if *interaction == Interaction::None {
                    *interaction = Interaction::Hovered;
                }
            }

            match node.focus_policy.unwrap_or(&FocusPolicy::Block) {
                FocusPolicy::Block => {
                    break;
                }
                FocusPolicy::Pass => { /* allow the next node to be hovered/pressed */ }
            }
        }
        // reset `Interaction` for the remaining lower nodes to `None`. those are the nodes that remain in
        // `moused_over_nodes` after the previous loop is exited.
        let mut iter = node_query.iter_many_mut(hovered_nodes);
        while let Some(node) = iter.fetch_next() {
            if let Some(mut interaction) = node.interaction {
                // don't reset pressed nodes because they're handled separately
                if *interaction != Interaction::Pressed {
                    interaction.set_if_neq(Interaction::None);
                }
            }
        }
    }
}