Struct MessageReader 

pub struct MessageReader<'w, 's, M>
where
    M: Message,
{ /* private fields */ }

Reads Messages of type T in order and tracks which messages have already been read.

Use PopulatedMessageReader<T> to skip the system if there are no messages.

Usage

#[derive(Message)]
pub struct MyMessage(String); // Custom message type.
fn my_system(mut reader: MessageReader<MyMessage>) {
    for msg in reader.read() {
        println!("{}", msg.0)
    }
}

Concurrency

Unlike MessageWriter<T>, systems with MessageReader<T> param can be executed concurrently (but not concurrently with MessageWriter<T> or MessageMutator<T> systems for the same message type).

Implementations

impl<'w, 's, M> MessageReader<'w, 's, M>

where M: Message,

pub fn read(&mut self) -> MessageIterator<'_, M>

Iterates over the messages this MessageReader has not seen yet. This updates the MessageReader’s message counter, which means subsequent message reads will not include messages that happened before now.

Examples found in repository

examples/input/touch_input_events.rs (line 13)

fn touch_event_system(mut touch_inputs: MessageReader<TouchInput>) {
    for touch_input in touch_inputs.read() {
        info!("{:?}", touch_input);
    }
}

examples/input/keyboard_input_events.rs (line 14)

fn print_keyboard_event_system(mut keyboard_inputs: MessageReader<KeyboardInput>) {
    for keyboard_input in keyboard_inputs.read() {
        info!("{:?}", keyboard_input);
    }
}

examples/app/drag_and_drop.rs (line 13)

fn file_drag_and_drop_system(mut drag_and_drop_reader: MessageReader<FileDragAndDrop>) {
    for drag_and_drop in drag_and_drop_reader.read() {
        info!("{:?}", drag_and_drop);
    }
}

examples/2d/dynamic_mip_generation.rs (line 512)

fn handle_window_resize_events(
    mut events: MessageReader<WindowResized>,
    mut regenerate_image_message_writer: MessageWriter<RegenerateImage>,
) {
    for _ in events.read() {
        regenerate_image_message_writer.write(RegenerateImage);
    }
}

/// Recreates the image, as well as all views that show the image, when a
/// [`RegenerateImage`] message is received.
///
/// The views that show the image consist of the animated mesh on the left side
/// of the window and the column of mipmap level views on the right side of the
/// window.
fn regenerate_image_when_requested(
    mut commands: Commands,
    image_views_query: Query<Entity, With<ImageView>>,
    windows_query: Query<&Window, With<PrimaryWindow>>,
    app_assets: Res<AppAssets>,
    mut app_status: ResMut<AppStatus>,
    mut images: ResMut<Assets<Image>>,
    mut single_mip_level_materials: ResMut<Assets<SingleMipLevelMaterial>>,
    mut color_materials: ResMut<Assets<ColorMaterial>>,
    mut message_reader: MessageReader<RegenerateImage>,
) {
    // Only do this at most once per frame, or else the despawn logic below will
    // get confused.
    if message_reader.read().count() == 0 {
        return;
    }

    // Despawn all entities that show the image.
    for entity in image_views_query.iter() {
        commands.entity(entity).despawn();
    }

    // Regenerate the image.
    let image_handle = app_status.regenerate_mipmap_source_image(&mut commands, &mut images);

    // Respawn the animated image view on the left side of the window.
    spawn_animated_mesh(
        &mut commands,
        &app_status,
        &app_assets,
        &windows_query,
        &mut color_materials,
        &image_handle,
    );

    // Respawn the column of mip level views on the right side of the window.
    spawn_mip_level_views(
        &mut commands,
        &app_status,
        &app_assets,
        &windows_query,
        &mut single_mip_level_materials,
        &image_handle,
    );
}

examples/math/cubic_splines.rs (line 300)

fn handle_mouse_move(
    mut cursor_moved_reader: MessageReader<CursorMoved>,
    mut mouse_position: ResMut<MousePosition>,
) {
    if let Some(cursor_moved) = cursor_moved_reader.read().last() {
        mouse_position.0 = Some(cursor_moved.position);
    }
}

/// This system handles updating the [`MouseEditMove`] resource, orchestrating the logical part
/// of the click-and-drag motion which actually creates new control points.
fn handle_mouse_press(
    mut mouse_button_input_reader: MessageReader<MouseButtonInput>,
    mouse_position: Res<MousePosition>,
    mut edit_move: ResMut<MouseEditMove>,
    mut control_points: ResMut<ControlPoints>,
    camera: Single<(&Camera, &GlobalTransform)>,
) {
    let Some(mouse_pos) = mouse_position.0 else {
        return;
    };

    // Handle click and drag behavior
    for mouse_button_input in mouse_button_input_reader.read() {
        if mouse_button_input.button != MouseButton::Left {
            continue;
        }

        match mouse_button_input.state {
            ButtonState::Pressed => {
                if edit_move.start.is_some() {
                    // If the edit move already has a start, press event should do nothing.
                    continue;
                }
                // This press represents the start of the edit move.
                edit_move.start = Some(mouse_pos);
            }

            ButtonState::Released => {
                // Release is only meaningful if we started an edit move.
                let Some(start) = edit_move.start else {
                    continue;
                };

                let (camera, camera_transform) = *camera;

                // Convert the starting point and end point (current mouse pos) into world coords:
                let Ok(point) = camera.viewport_to_world_2d(camera_transform, start) else {
                    continue;
                };
                let Ok(end_point) = camera.viewport_to_world_2d(camera_transform, mouse_pos) else {
                    continue;
                };
                let tangent = end_point - point;

                // The start of the click-and-drag motion represents the point to add,
                // while the difference with the current position represents the tangent.
                control_points.points_and_tangents.push((point, tangent));

                // Reset the edit move since we've consumed it.
                edit_move.start = None;
            }
        }
    }
}

examples/window/window_resizing.rs (line 79)

fn on_resize_system(
    mut text: Single<&mut Text, With<ResolutionText>>,
    mut resize_reader: MessageReader<WindowResized>,
) {
    for e in resize_reader.read() {
        // When resolution is being changed
        text.0 = format!("{:.1} x {:.1}", e.width, e.height);
    }
}

Additional examples can be found in:

• examples/app/settings.rs
• examples/async_tasks/external_source_external_thread.rs
• examples/input/char_input_events.rs
• examples/2d/texture_atlas.rs
• examples/ecs/message.rs
• examples/2d/pixel_grid_snap.rs
• examples/audio/pitch.rs
• examples/animation/morph_targets.rs
• examples/window/persisting_window_settings.rs
• examples/app/log_layers_ecs.rs
• examples/picking/custom_hit_data.rs
• examples/ui/scroll_and_overflow/scroll.rs
• examples/transforms/align.rs
• examples/math/random_sampling.rs
• examples/3d/split_screen.rs
• examples/3d/tonemapping.rs
• examples/3d/mirror.rs
• examples/input/mouse_input_events.rs
• examples/testbed/full_ui.rs
• examples/input/gamepad_input_events.rs
• examples/3d/ssr.rs
• examples/3d/visibility_range.rs
• examples/ui/render_ui_to_texture.rs
• examples/3d/mixed_lighting.rs
• examples/camera/pan_orbit_camera_custom_input_plugin.rs

pub fn read_with_id(&mut self) -> MessageIteratorWithId<'_, M>

Like read, except also returning the MessageId of the messages.

pub fn par_read(&mut self) -> MessageParIter<'_, M>

Available on crate feature multi_threaded only.

Returns a parallel iterator over the messages this MessageReader has not seen yet. See also for_each.

Example

#[derive(Message)]
struct MyMessage {
    value: usize,
}

#[derive(Resource, Default)]
struct Counter(AtomicUsize);

// setup
let mut world = World::new();
world.init_resource::<Messages<MyMessage>>();
world.insert_resource(Counter::default());

let mut schedule = Schedule::default();
schedule.add_systems(|mut messages: MessageReader<MyMessage>, counter: Res<Counter>| {
    messages.par_read().for_each(|MyMessage { value }| {
        counter.0.fetch_add(*value, Ordering::Relaxed);
    });
});
for value in 0..100 {
    world.write_message(MyMessage { value });
}
schedule.run(&mut world);
let Counter(counter) = world.remove_resource::<Counter>().unwrap();
// all messages were processed
assert_eq!(counter.into_inner(), 4950);

pub fn len(&self) -> usize

Determines the number of messages available to be read from this MessageReader without consuming any.

pub fn is_empty(&self) -> bool

Returns true if there are no messages available to read.

Example

The following example shows a useful pattern where some behavior is triggered if new messages are available. MessageReader::clear() is used so the same messages don’t re-trigger the behavior the next time the system runs.

#[derive(Message)]
struct Collision;

fn play_collision_sound(mut messages: MessageReader<Collision>) {
    if !messages.is_empty() {
        messages.clear();
        // Play a sound
    }
}

Examples found in repository

examples/ecs/extraction.rs (line 124)

fn extract_components(
    b: Extract<Query<(RenderEntity, &B)>>,
    c: Extract<Query<(RenderEntity, &C)>>,
    mut reader: Extract<MessageReader<ExtractMessage>>,
    mut commands: Commands,
) {
    for (entity, b) in &b {
        commands.entity(entity).insert(b.clone());
    }

    if !reader.is_empty() {
        for (entity, c) in &c {
            commands.entity(entity).insert(c.clone());
        }
        reader.clear();
    }
}

examples/asset/processing/asset_processing.rs (line 254)

fn print_text(
    handles: Res<TextAssets>,
    texts: Res<Assets<Text>>,
    mut asset_events: MessageReader<AssetEvent<Text>>,
) {
    if !asset_events.is_empty() {
        // This prints the current values of the assets
        // Hot-reloading is supported, so try modifying the source assets (and their meta files)!
        println!("Current Values:");
        println!("  a: {:?}", texts.get(&handles.a));
        println!("  b: {:?}", texts.get(&handles.b));
        println!("  c: {:?}", texts.get(&handles.c));
        println!("  d: {:?}", texts.get(&handles.d));
        println!("  e: {:?}", texts.get(&handles.e));
        println!("(You can modify source assets and their .meta files to hot-reload changes!)");
        println!();
        asset_events.clear();
    }
}

pub fn clear(&mut self)

Consumes all available messages.

This means these messages will not appear in calls to MessageReader::read() or MessageReader::read_with_id() and MessageReader::is_empty() will return true.

For usage, see MessageReader::is_empty().

Examples found in repository

examples/ecs/extraction.rs (line 128)

fn extract_components(
    b: Extract<Query<(RenderEntity, &B)>>,
    c: Extract<Query<(RenderEntity, &C)>>,
    mut reader: Extract<MessageReader<ExtractMessage>>,
    mut commands: Commands,
) {
    for (entity, b) in &b {
        commands.entity(entity).insert(b.clone());
    }

    if !reader.is_empty() {
        for (entity, c) in &c {
            commands.entity(entity).insert(c.clone());
        }
        reader.clear();
    }
}

examples/asset/processing/asset_processing.rs (line 265)

fn print_text(
    handles: Res<TextAssets>,
    texts: Res<Assets<Text>>,
    mut asset_events: MessageReader<AssetEvent<Text>>,
) {
    if !asset_events.is_empty() {
        // This prints the current values of the assets
        // Hot-reloading is supported, so try modifying the source assets (and their meta files)!
        println!("Current Values:");
        println!("  a: {:?}", texts.get(&handles.a));
        println!("  b: {:?}", texts.get(&handles.b));
        println!("  c: {:?}", texts.get(&handles.c));
        println!("  d: {:?}", texts.get(&handles.d));
        println!("  e: {:?}", texts.get(&handles.e));
        println!("(You can modify source assets and their .meta files to hot-reload changes!)");
        println!();
        asset_events.clear();
    }
}

examples/camera/pan_orbit_camera_custom_input_plugin.rs (line 144)

pub fn custom_camera_inputs(
    pointers: Query<(&PointerId, &PointerLocation)>,
    pointer_map: Res<CameraPointerMap>,
    mut controller: MessageWriter<PanOrbitCameraInputMessage>,
    mut mouse_wheel: MessageReader<MouseWheel>,
    mouse_input: Res<ButtonInput<MouseButton>>,
    cameras: Query<(Entity, &Camera, &RenderTarget, &PanOrbitCamera)>,
    primary_window: Query<Entity, With<PrimaryWindow>>,
) {
    let orbit_start = MouseButton::Right;
    let pan_start = MouseButton::Left;
    let zoom_stop = 0.0;

    if let Some(&camera) = pointer_map.get(&PointerId::Mouse) {
        let camera_query = cameras.get(camera).ok();
        let is_in_zoom_mode = camera_query
            .map(|(.., editor_cam)| editor_cam.current_motion.is_zooming_only())
            .unwrap_or_default();
        let zoom_amount_abs = camera_query
            .and_then(|(.., editor_cam)| {
                editor_cam
                    .current_motion
                    .inputs()
                    .map(|inputs| inputs.zoom_velocity_abs(editor_cam.smoothing.zoom.mul_f32(2.0)))
            })
            .unwrap_or(0.0);
        let should_zoom_end = is_in_zoom_mode && zoom_amount_abs <= zoom_stop;

        if mouse_input.any_just_released([orbit_start, pan_start]) || should_zoom_end {
            controller.write(PanOrbitCameraInputMessage::End { camera });
        }
    }

    for (&pointer, pointer_location) in pointers
        .iter()
        .filter_map(|(id, loc)| loc.location().map(|loc| (id, loc)))
    {
        match pointer {
            PointerId::Mouse => {
                let Some((camera, ..)) = cameras.iter().find(|(_, camera, render_target, _)| {
                    pointer_location.is_in_viewport(camera, render_target, &primary_window)
                }) else {
                    continue; // Pointer must be in viewport to start a motion.
                };

                if mouse_input.just_pressed(orbit_start) {
                    controller.write(PanOrbitCameraInputMessage::Start {
                        kind: MotionKind::OrbitZoom,
                        camera,
                        pointer,
                    });
                } else if mouse_input.just_pressed(pan_start) {
                    controller.write(PanOrbitCameraInputMessage::Start {
                        kind: MotionKind::PanZoom,
                        camera,
                        pointer,
                    });
                } else if mouse_wheel.read().map(|mw| mw.y.abs()).sum::<f32>() > 0.0 {
                    // Note we can't just check if the mouse wheel inputs are empty, we need to
                    // check if the y value abs greater than zero, otherwise we get a bunch of false
                    // positives, which can cause issues with figuring out what the user is trying
                    // to do.
                    controller.write(PanOrbitCameraInputMessage::Start {
                        kind: MotionKind::Zoom,
                        camera,
                        pointer,
                    });
                }
            }
            PointerId::Touch(_) | PointerId::Custom(_) => continue,
        }
    }

    // This must be cleared manually because reading these inputs is conditional - we are not
    // guaranteed to be flushing the events every frame.
    mouse_wheel.clear();
}

/// Maps pointers to the camera they are currently controlling.
///
/// This is needed so we can automatically track pointer movements and update camera movement after
/// a [`PanOrbitCameraInputMessage::Start`] has been received.
#[derive(Debug, Clone, Default, Deref, DerefMut, Resource)]
pub struct CameraPointerMap(HashMap<PointerId, Entity>);

/// Messages used when implementing input systems for the [`PanOrbitCamera`].
#[derive(Debug, Clone, Message)]
pub enum PanOrbitCameraInputMessage {
    /// Send this event to start moving the camera. The anchor and inputs will be computed
    /// automatically until the [`PanOrbitCameraInputMessage::End`] event is received.
    Start {
        /// The kind of camera movement that is being started.
        kind: MotionKind,
        /// The camera to move.
        camera: Entity,
        /// The pointer that will be controlling the camera. The rotation anchor point in the world
        /// will be automatically computed using picking backends.
        pointer: PointerId,
    },
    /// Send this event when a user's input ends, e.g. the button is released.
    End {
        /// The entity of the camera that should end its current input motion.
        camera: Entity,
    },
}

impl PanOrbitCameraInputMessage {
    /// Get the camera entity associated with this event.
    pub fn camera(&self) -> Entity {
        match self {
            PanOrbitCameraInputMessage::Start { camera, .. }
            | PanOrbitCameraInputMessage::End { camera } => *camera,
        }
    }

    /// Receive [`PanOrbitCameraInputMessage`]s, and use these to start and end moves on the [`PanOrbitCamera`].
    pub fn receive_messages(
        mut events: MessageReader<Self>,
        mut controllers: Query<(&mut PanOrbitCamera, &GlobalTransform)>,
        mut camera_map: ResMut<CameraPointerMap>,
        pointer_map: Res<PointerMap>,
        pointer_interactions: Query<&PointerInteraction>,
        pointer_locations: Query<&PointerLocation>,
        cameras: Query<(&Camera, &Projection)>,
        windows: Query<&Window>,
    ) {
        for event in events.read() {
            let Ok((mut controller, cam_transform)) = controllers.get_mut(event.camera()) else {
                continue;
            };

            match event {
                PanOrbitCameraInputMessage::Start { kind, pointer, .. } => {
                    if controller.is_actively_controlled() {
                        continue;
                    }
                    let anchor = pointer_map
                        .get_entity(*pointer)
                        .and_then(|entity| pointer_interactions.get(entity).ok())
                        .and_then(|interaction| interaction.get_nearest_hit())
                        // Since `bevy` 0.17.3:
                        //
                        // If the current hit is on a window, we cannot use the `hit.position` as an anchor
                        // as the `hit.position` is in viewport coordinates.
                        .filter(|(entity, _hit)| !windows.contains(*entity))
                        .and_then(|(_, hit)| hit.position)
                        .map(|world_space_hit| {
                            // Convert the world space hit to view (camera) space
                            cam_transform
                                .to_matrix()
                                .as_dmat4()
                                .inverse()
                                .transform_point3(world_space_hit.into())
                        })
                        .filter(|p| {
                            #[cfg(debug_assertions)]
                            if !p.is_finite() {
                                bevy::log::warn!(
                                    "Non-finite input fed to camera controller: {p:?}"
                                );
                            }
                            p.is_finite()
                        })
                        .or_else(|| {
                            let camera = cameras.get(event.camera()).ok();
                            let pointer_location = pointer_map
                                .get_entity(*pointer)
                                .and_then(|entity| pointer_locations.get(entity).ok())
                                .and_then(|l| l.location());
                            if let Some(((camera, proj), pointer_location)) =
                                camera.zip(pointer_location)
                            {
                                screen_to_view_space(
                                    camera,
                                    proj,
                                    &controller,
                                    pointer_location.position,
                                )
                            } else {
                                None
                            }
                        })
                        .filter(|p| p.is_finite());

                    match kind {
                        MotionKind::OrbitZoom => controller.start_orbit(anchor),
                        MotionKind::PanZoom => controller.start_pan(anchor),
                        MotionKind::Zoom => controller.start_zoom(anchor),
                    }
                    camera_map.insert(*pointer, event.camera());
                }
                PanOrbitCameraInputMessage::End { .. } => {
                    controller.end_move();
                    if let Some(pointer) = camera_map
                        .iter()
                        .find(|(.., camera)| **camera == event.camera())
                        .map(|(&pointer, ..)| pointer)
                    {
                        camera_map.remove(&pointer);
                    }
                }
            }
        }
    }

    /// While a camera motion is active, this system will take care of sending new pointer motion to
    /// the camera controller. The camera controller assumes that pan and orbit movements are tied
    /// to screen space pointer motion.
    ///
    /// This is because some of the pixel-perfect features of the controller require that data be
    /// passed in as screen space deltas, to compute perfect first-order control. This is also
    /// because the plugin uses pointer information to know which camera is being controlled.
    ///
    /// If you want to control the camera with different inputs, you will need to replace this
    /// system with one that tracks other input methods, and sends the required zoom and screenspace
    /// movement information.
    pub fn send_pointer_inputs(
        camera_map: Res<CameraPointerMap>,
        mut camera_controllers: Query<&mut PanOrbitCamera>,
        mut mouse_wheel: MessageReader<MouseWheel>,
        mut moves: MessageReader<PointerInput>,
    ) {
        let moves_list: Vec<_> = moves.read().collect();
        for (pointer, camera) in camera_map.iter() {
            let Ok(mut camera_controller) = camera_controllers.get_mut(*camera) else {
                continue;
            };

            let screenspace_input = moves_list
                .iter()
                .filter(|m| m.pointer_id.eq(pointer))
                .filter_map(|m| match m.action {
                    PointerAction::Move { delta } => Some(delta),
                    _ => None,
                })
                .sum();

            let zoom_amount = match pointer {
                // TODO: add pinch zoom support
                PointerId::Mouse => mouse_wheel
                    .read()
                    .map(|mw| {
                        let scroll_multiplier = match mw.unit {
                            MouseScrollUnit::Line => 150.0,
                            MouseScrollUnit::Pixel => 1.0,
                        };
                        mw.y * scroll_multiplier
                    })
                    .sum::<f32>(),
                _ => 0.0,
            };

            camera_controller.send_screenspace_input(screenspace_input);
            camera_controller.send_zoom_input(zoom_amount);
        }
        // This must be cleared manually because reading these inputs is conditional - we are not
        // guaranteed to be flushing the events every frame.
        mouse_wheel.clear();
    }

Trait Implementations

impl<'w, 's, M> Debug for MessageReader<'w, 's, M>

where M: Debug + Message,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'w, 's, M> ReadOnlySystemParam for MessageReader<'w, 's, M>

where M: Message, Local<'s, MessageCursor<M>>: ReadOnlySystemParam, Res<'w, Messages<M>>: ReadOnlySystemParam,

impl<M> SystemParam for MessageReader<'_, '_, M>

where M: Message,

type State = FetchState<M>

Used to store data which persists across invocations of a system.

type Item<'w, 's> = MessageReader<'w, 's, M>

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes.

fn init_state( world: &mut World, ) -> <MessageReader<'_, '_, M> as SystemParam>::State

Creates a new instance of this param’s State.

fn init_access( state: &<MessageReader<'_, '_, M> as SystemParam>::State, system_meta: &mut SystemMeta, system_access: &mut SystemAccess, world: &mut World, )

Registers any World access used by this SystemParam.

fn apply( state: &mut <MessageReader<'_, '_, M> as SystemParam>::State, system_meta: &SystemMeta, world: &mut World, )

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during ApplyDeferred.

fn queue( state: &mut <MessageReader<'_, '_, M> as SystemParam>::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

Queues any deferred mutations to be applied at the next ApplyDeferred.

unsafe fn get_param<'w, 's>( state: &'s mut <MessageReader<'_, '_, M> as SystemParam>::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick, ) -> Result<<MessageReader<'_, '_, M> as SystemParam>::Item<'w, 's>, SystemParamValidationError>

Creates a parameter to be passed into a SystemParamFunction.