Struct MessageReader 

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

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

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, E> MessageReader<'w, 's, E>

where E: Message,

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

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/ecs/send_and_receive_messages.rs (line 60)

fn read_and_write_different_message_types(mut a: MessageWriter<A>, mut b: MessageReader<B>) {
    for _ in b.read() {}
    a.write(A);
}

/// A dummy message type.
#[derive(Debug, Clone, Message)]
struct DebugMessage {
    resend_from_param_set: bool,
    resend_from_local_message_reader: bool,
    times_sent: u8,
}

/// A system that sends all combinations of messages.
fn send_messages(mut debug_messages: MessageWriter<DebugMessage>, frame_count: Res<FrameCount>) {
    println!("Sending messages for frame {}", frame_count.0);

    debug_messages.write(DebugMessage {
        resend_from_param_set: false,
        resend_from_local_message_reader: false,
        times_sent: 1,
    });
    debug_messages.write(DebugMessage {
        resend_from_param_set: true,
        resend_from_local_message_reader: false,
        times_sent: 1,
    });
    debug_messages.write(DebugMessage {
        resend_from_param_set: false,
        resend_from_local_message_reader: true,
        times_sent: 1,
    });
    debug_messages.write(DebugMessage {
        resend_from_param_set: true,
        resend_from_local_message_reader: true,
        times_sent: 1,
    });
}

/// A system that prints all messages sent since the last time this system ran.
///
/// Note that some messages will be printed twice, because they were sent twice.
fn debug_messages(mut messages: MessageReader<DebugMessage>) {
    for message in messages.read() {
        println!("{message:?}");
    }
}

/// A system that both sends and receives messages using [`ParamSet`].
fn send_and_receive_param_set(
    mut param_set: ParamSet<(MessageReader<DebugMessage>, MessageWriter<DebugMessage>)>,
    frame_count: Res<FrameCount>,
) {
    println!(
        "Sending and receiving messages for frame {} with a `ParamSet`",
        frame_count.0
    );

    // We must collect the messages to resend, because we can't access the writer while we're iterating over the reader.
    let mut messages_to_resend = Vec::new();

    // This is p0, as the first parameter in the `ParamSet` is the reader.
    for message in param_set.p0().read() {
        if message.resend_from_param_set {
            messages_to_resend.push(message.clone());
        }
    }

    // This is p1, as the second parameter in the `ParamSet` is the writer.
    for mut message in messages_to_resend {
        message.times_sent += 1;
        param_set.p1().write(message);
    }
}

examples/window/custom_user_event.rs (line 74)

fn handle_event(mut events: MessageReader<CustomEvent>) {
    for evt in events.read() {
        info!("Received event: {evt:?}");
    }
}

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/3d/clustered_decals.rs (line 378)

fn handle_selection_change(
    mut events: MessageReader<WidgetClickEvent<Selection>>,
    mut app_status: ResMut<AppStatus>,
) {
    for event in events.read() {
        app_status.selection = **event;
    }
}

Additional examples can be found in:

• examples/3d/light_textures.rs
• examples/math/cubic_splines.rs
• examples/window/window_resizing.rs
• examples/async_tasks/external_source_external_thread.rs
• examples/input/char_input_events.rs
• examples/2d/tilemap_chunk.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/app/log_layers_ecs.rs
• examples/ui/scroll.rs
• examples/transforms/align.rs
• examples/math/random_sampling.rs
• examples/3d/split_screen.rs
• examples/3d/tonemapping.rs
• examples/input/text_input.rs
• examples/3d/pcss.rs
• examples/input/mouse_input_events.rs
• examples/math/sampling_primitives.rs
• examples/testbed/full_ui.rs
• examples/input/gamepad_input_events.rs
• examples/3d/ssr.rs
• examples/3d/visibility_range.rs
• examples/ui/size_constraints.rs
• examples/ui/render_ui_to_texture.rs
• examples/3d/mixed_lighting.rs

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

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

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

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/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/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();
    }
}

Trait Implementations

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

where E: Debug + Message,

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

Formats the value using the given formatter.

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

where E: Message,

type State = FetchState<E>

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

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

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<'_, '_, E> as SystemParam>::State

Creates a new instance of this param’s State.

fn init_access( state: &<MessageReader<'_, '_, E> as SystemParam>::State, system_meta: &mut SystemMeta, component_access_set: &mut FilteredAccessSet, world: &mut World, )

Registers any World access used by this SystemParam

fn apply( state: &mut <MessageReader<'_, '_, E> 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<'_, '_, E> as SystemParam>::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

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

unsafe fn validate_param<'w, 's>( state: &'s mut <MessageReader<'_, '_, E> as SystemParam>::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'w>, ) -> Result<(), SystemParamValidationError>

Validates that the param can be acquired by the get_param.

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

Creates a parameter to be passed into a SystemParamFunction.

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

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