Struct Single 

pub struct Single<'w, 's, D, F = ()>
where
    D: QueryData,
    F: QueryFilter,
{ /* private fields */ }

System parameter that provides access to single entity’s components, much like Query::single/Query::single_mut.

This SystemParam fails validation if zero or more than one matching entity exists. This will cause the system to be skipped, according to the rules laid out in SystemParamValidationError.

Use Option<Single<D, F>> instead if zero or one matching entities can exist.

See Query for more details.

Example

#[derive(Component)]
struct Boss {
   health: f32
};

fn hurt_boss(mut boss: Single<&mut Boss>) {
   boss.health -= 4.0;
}

Note that because Single implements Deref and DerefMut, methods and fields like health can be accessed directly. You can also access the underlying data manually, by calling .deref/.deref_mut, or by using the * operator.

Implementations

impl<'w, 's, D, F> Single<'w, 's, D, F>

where D: QueryData, F: QueryFilter,

pub fn into_inner(self) -> <D as QueryData>::Item<'w, 's>

Returns the inner item with ownership.

Examples found in repository

examples/2d/bloom_2d.rs (line 79)

fn update_bloom_settings(
    camera: Single<(Entity, &Tonemapping, Option<&mut Bloom>), With<Camera>>,
    mut text: Single<&mut Text>,
    mut commands: Commands,
    keycode: Res<ButtonInput<KeyCode>>,
    time: Res<Time>,
) {
    let (camera_entity, tonemapping, bloom) = camera.into_inner();

    match bloom {
        Some(mut bloom) => {
            text.0 = "Bloom (Toggle: Space)\n".to_string();
            text.push_str(&format!("(Q/A) Intensity: {:.2}\n", bloom.intensity));
            text.push_str(&format!(
                "(W/S) Low-frequency boost: {:.2}\n",
                bloom.low_frequency_boost
            ));
            text.push_str(&format!(
                "(E/D) Low-frequency boost curvature: {:.2}\n",
                bloom.low_frequency_boost_curvature
            ));
            text.push_str(&format!(
                "(R/F) High-pass frequency: {:.2}\n",
                bloom.high_pass_frequency
            ));
            text.push_str(&format!(
                "(T/G) Mode: {}\n",
                match bloom.composite_mode {
                    BloomCompositeMode::EnergyConserving => "Energy-conserving",
                    BloomCompositeMode::Additive => "Additive",
                }
            ));
            text.push_str(&format!(
                "(Y/H) Threshold: {:.2}\n",
                bloom.prefilter.threshold
            ));
            text.push_str(&format!(
                "(U/J) Threshold softness: {:.2}\n",
                bloom.prefilter.threshold_softness
            ));
            text.push_str(&format!("(I/K) Horizontal Scale: {:.2}\n", bloom.scale.x));

            if keycode.just_pressed(KeyCode::Space) {
                commands.entity(camera_entity).remove::<Bloom>();
            }

            let dt = time.delta_secs();

            if keycode.pressed(KeyCode::KeyA) {
                bloom.intensity -= dt / 10.0;
            }
            if keycode.pressed(KeyCode::KeyQ) {
                bloom.intensity += dt / 10.0;
            }
            bloom.intensity = bloom.intensity.clamp(0.0, 1.0);

            if keycode.pressed(KeyCode::KeyS) {
                bloom.low_frequency_boost -= dt / 10.0;
            }
            if keycode.pressed(KeyCode::KeyW) {
                bloom.low_frequency_boost += dt / 10.0;
            }
            bloom.low_frequency_boost = bloom.low_frequency_boost.clamp(0.0, 1.0);

            if keycode.pressed(KeyCode::KeyD) {
                bloom.low_frequency_boost_curvature -= dt / 10.0;
            }
            if keycode.pressed(KeyCode::KeyE) {
                bloom.low_frequency_boost_curvature += dt / 10.0;
            }
            bloom.low_frequency_boost_curvature =
                bloom.low_frequency_boost_curvature.clamp(0.0, 1.0);

            if keycode.pressed(KeyCode::KeyF) {
                bloom.high_pass_frequency -= dt / 10.0;
            }
            if keycode.pressed(KeyCode::KeyR) {
                bloom.high_pass_frequency += dt / 10.0;
            }
            bloom.high_pass_frequency = bloom.high_pass_frequency.clamp(0.0, 1.0);

            if keycode.pressed(KeyCode::KeyG) {
                bloom.composite_mode = BloomCompositeMode::Additive;
            }
            if keycode.pressed(KeyCode::KeyT) {
                bloom.composite_mode = BloomCompositeMode::EnergyConserving;
            }

            if keycode.pressed(KeyCode::KeyH) {
                bloom.prefilter.threshold -= dt;
            }
            if keycode.pressed(KeyCode::KeyY) {
                bloom.prefilter.threshold += dt;
            }
            bloom.prefilter.threshold = bloom.prefilter.threshold.max(0.0);

            if keycode.pressed(KeyCode::KeyJ) {
                bloom.prefilter.threshold_softness -= dt / 10.0;
            }
            if keycode.pressed(KeyCode::KeyU) {
                bloom.prefilter.threshold_softness += dt / 10.0;
            }
            bloom.prefilter.threshold_softness = bloom.prefilter.threshold_softness.clamp(0.0, 1.0);

            if keycode.pressed(KeyCode::KeyK) {
                bloom.scale.x -= dt * 2.0;
            }
            if keycode.pressed(KeyCode::KeyI) {
                bloom.scale.x += dt * 2.0;
            }
            bloom.scale.x = bloom.scale.x.clamp(0.0, 16.0);
        }

        None => {
            text.0 = "Bloom: Off (Toggle: Space)\n".to_string();

            if keycode.just_pressed(KeyCode::Space) {
                commands.entity(camera_entity).insert(Bloom::default());
            }
        }
    }

    text.push_str(&format!("(O) Tonemapping: {tonemapping:?}\n"));
    if keycode.just_pressed(KeyCode::KeyO) {
        commands
            .entity(camera_entity)
            .insert(next_tonemap(tonemapping));
    }
}

Trait Implementations

impl<'w, 's, D, F> Deref for Single<'w, 's, D, F>

where D: QueryData, F: QueryFilter,

type Target = <D as QueryData>::Item<'w, 's>

The resulting type after dereferencing.

fn deref(&self) -> &<Single<'w, 's, D, F> as Deref>::Target

Dereferences the value.

impl<'w, 's, D, F> DerefMut for Single<'w, 's, D, F>

where D: QueryData, F: QueryFilter,

fn deref_mut(&mut self) -> &mut <Single<'w, 's, D, F> as Deref>::Target

Mutably dereferences the value.

impl<'a, 'b, D, F> SystemParam for Single<'a, 'b, D, F>

where D: QueryData + 'static, F: QueryFilter + 'static,

type State = QueryState<D, F>

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

type Item<'w, 's> = Single<'w, 's, D, F>

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) -> <Single<'a, 'b, D, F> as SystemParam>::State

Creates a new instance of this param’s State.

fn init_access( state: &<Single<'a, 'b, D, F> as SystemParam>::State, system_meta: &mut SystemMeta, component_access_set: &mut FilteredAccessSet, world: &mut World, )

Registers any World access used by this SystemParam

unsafe fn get_param<'w, 's>( state: &'s mut <Single<'a, 'b, D, F> as SystemParam>::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick, ) -> <Single<'a, 'b, D, F> as SystemParam>::Item<'w, 's>

Creates a parameter to be passed into a SystemParamFunction.

unsafe fn validate_param( state: &mut <Single<'a, 'b, D, F> as SystemParam>::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'_>, ) -> Result<(), SystemParamValidationError>

Validates that the param can be acquired by the get_param.

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

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

impl<'a, 'b, D, F> ReadOnlySystemParam for Single<'a, 'b, D, F>

where D: ReadOnlyQueryData + 'static, F: QueryFilter + 'static,