ButtonInput

bevy::input

Struct ButtonInput 

Source 
pub struct ButtonInput<T>
where
    T: Clone + Eq + Hash + Send + Sync + 'static,
{ /* private fields */ }
Expand description

A “press-able” input of type T.

§Usage

This type can be used as a resource to keep the current state of an input, by reacting to events from the input. For a given input value:

§Multiple systems

In case multiple systems are checking for ButtonInput::just_pressed or ButtonInput::just_released but only one should react, for example when modifying a Resource, you should consider clearing the input state, either by:

§Performance

For all operations, the following conventions are used:

  • n is the number of stored inputs.
  • m is the number of input arguments passed to the method.
  • *-suffix denotes an amortized cost.
  • ~-suffix denotes an expected cost.

See Rust’s std::collections doc on performance for more details on the conventions used here.

§Window focus

ButtonInput<KeyCode> is tied to window focus. For example, if the user holds a button while the window loses focus, ButtonInput::just_released will be triggered. Similarly if the window regains focus, ButtonInput::just_pressed will be triggered.

ButtonInput<GamepadButton> is independent of window focus.

§Examples

Reading and checking against the current set of pressed buttons:


fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(
            Update,
            print_mouse.run_if(resource_changed::<ButtonInput<MouseButton>>),
        )
        .add_systems(
            Update,
            print_keyboard.run_if(resource_changed::<ButtonInput<KeyCode>>),
        )
        .run();
}

fn print_mouse(mouse: Res<ButtonInput<MouseButton>>) {
    println!("Mouse: {:?}", mouse.get_pressed().collect::<Vec<_>>());
}

fn print_keyboard(keyboard: Res<ButtonInput<KeyCode>>) {
    if keyboard.any_pressed([KeyCode::ControlLeft, KeyCode::ControlRight])
        && keyboard.any_pressed([KeyCode::AltLeft, KeyCode::AltRight])
        && keyboard.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight])
        && keyboard.any_pressed([KeyCode::SuperLeft, KeyCode::SuperRight])
        && keyboard.pressed(KeyCode::KeyL)
    {
        println!("On Windows this opens LinkedIn.");
    } else {
        println!("keyboard: {:?}", keyboard.get_pressed().collect::<Vec<_>>());
    }
}

§Note

When adding this resource for a new input type, you should:

Note: Calling clear from a ResMut will trigger change detection. It may be preferable to use DetectChangesMut::bypass_change_detection to avoid causing the resource to always be marked as changed.

Implementations§

Source§

impl<T> ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static,

Source

pub fn press(&mut self, input: T)

Registers a press for the given input.

Source

pub fn pressed(&self, input: T) -> bool

Returns true if the input has been pressed.

Examples found in repository?
examples/input/mouse_input.rs (line 17)
16fn mouse_click_system(mouse_button_input: Res<ButtonInput<MouseButton>>) {
17    if mouse_button_input.pressed(MouseButton::Left) {
18        info!("left mouse currently pressed");
19    }
20
21    if mouse_button_input.just_pressed(MouseButton::Left) {
22        info!("left mouse just pressed");
23    }
24
25    if mouse_button_input.just_released(MouseButton::Left) {
26        info!("left mouse just released");
27    }
28}
More examples
Hide additional examples
examples/input/keyboard_input.rs (line 19)
13fn keyboard_input_system(
14    keyboard_input: Res<ButtonInput<KeyCode>>,
15    key_input: Res<ButtonInput<Key>>,
16) {
17    // KeyCode is used when you want the key location across different keyboard layouts
18    // See https://w3c.github.io/uievents-code/#code-value-tables for the locations
19    if keyboard_input.pressed(KeyCode::KeyA) {
20        info!("'A' currently pressed");
21    }
22
23    if keyboard_input.just_pressed(KeyCode::KeyA) {
24        info!("'A' just pressed");
25    }
26    if keyboard_input.just_released(KeyCode::KeyA) {
27        info!("'A' just released");
28    }
29
30    // Key is used when you want a specific key, no matter where it is located.
31    // This is useful for symbols that have a specific connotation, e.g. '?' for
32    // a help menu or '+'/'-' for zoom
33    let key = Key::Character("?".into());
34    if key_input.pressed(key.clone()) {
35        info!("'?' currently pressed");
36    }
37    if key_input.just_pressed(key.clone()) {
38        info!("'?' just pressed");
39    }
40    if key_input.just_released(key) {
41        info!("'?' just released");
42    }
43}
examples/2d/bloom_2d.rs (line 120)
72fn update_bloom_settings(
73    camera: Single<(Entity, &Tonemapping, Option<&mut Bloom>), With<Camera>>,
74    mut text: Single<&mut Text>,
75    mut commands: Commands,
76    keycode: Res<ButtonInput<KeyCode>>,
77    time: Res<Time>,
78) {
79    let (camera_entity, tonemapping, bloom) = camera.into_inner();
80
81    match bloom {
82        Some(mut bloom) => {
83            text.0 = "Bloom (Toggle: Space)\n".to_string();
84            text.push_str(&format!("(Q/A) Intensity: {:.2}\n", bloom.intensity));
85            text.push_str(&format!(
86                "(W/S) Low-frequency boost: {:.2}\n",
87                bloom.low_frequency_boost
88            ));
89            text.push_str(&format!(
90                "(E/D) Low-frequency boost curvature: {:.2}\n",
91                bloom.low_frequency_boost_curvature
92            ));
93            text.push_str(&format!(
94                "(R/F) High-pass frequency: {:.2}\n",
95                bloom.high_pass_frequency
96            ));
97            text.push_str(&format!(
98                "(T/G) Mode: {}\n",
99                match bloom.composite_mode {
100                    BloomCompositeMode::EnergyConserving => "Energy-conserving",
101                    BloomCompositeMode::Additive => "Additive",
102                }
103            ));
104            text.push_str(&format!(
105                "(Y/H) Threshold: {:.2}\n",
106                bloom.prefilter.threshold
107            ));
108            text.push_str(&format!(
109                "(U/J) Threshold softness: {:.2}\n",
110                bloom.prefilter.threshold_softness
111            ));
112            text.push_str(&format!("(I/K) Horizontal Scale: {:.2}\n", bloom.scale.x));
113
114            if keycode.just_pressed(KeyCode::Space) {
115                commands.entity(camera_entity).remove::<Bloom>();
116            }
117
118            let dt = time.delta_secs();
119
120            if keycode.pressed(KeyCode::KeyA) {
121                bloom.intensity -= dt / 10.0;
122            }
123            if keycode.pressed(KeyCode::KeyQ) {
124                bloom.intensity += dt / 10.0;
125            }
126            bloom.intensity = bloom.intensity.clamp(0.0, 1.0);
127
128            if keycode.pressed(KeyCode::KeyS) {
129                bloom.low_frequency_boost -= dt / 10.0;
130            }
131            if keycode.pressed(KeyCode::KeyW) {
132                bloom.low_frequency_boost += dt / 10.0;
133            }
134            bloom.low_frequency_boost = bloom.low_frequency_boost.clamp(0.0, 1.0);
135
136            if keycode.pressed(KeyCode::KeyD) {
137                bloom.low_frequency_boost_curvature -= dt / 10.0;
138            }
139            if keycode.pressed(KeyCode::KeyE) {
140                bloom.low_frequency_boost_curvature += dt / 10.0;
141            }
142            bloom.low_frequency_boost_curvature =
143                bloom.low_frequency_boost_curvature.clamp(0.0, 1.0);
144
145            if keycode.pressed(KeyCode::KeyF) {
146                bloom.high_pass_frequency -= dt / 10.0;
147            }
148            if keycode.pressed(KeyCode::KeyR) {
149                bloom.high_pass_frequency += dt / 10.0;
150            }
151            bloom.high_pass_frequency = bloom.high_pass_frequency.clamp(0.0, 1.0);
152
153            if keycode.pressed(KeyCode::KeyG) {
154                bloom.composite_mode = BloomCompositeMode::Additive;
155            }
156            if keycode.pressed(KeyCode::KeyT) {
157                bloom.composite_mode = BloomCompositeMode::EnergyConserving;
158            }
159
160            if keycode.pressed(KeyCode::KeyH) {
161                bloom.prefilter.threshold -= dt;
162            }
163            if keycode.pressed(KeyCode::KeyY) {
164                bloom.prefilter.threshold += dt;
165            }
166            bloom.prefilter.threshold = bloom.prefilter.threshold.max(0.0);
167
168            if keycode.pressed(KeyCode::KeyJ) {
169                bloom.prefilter.threshold_softness -= dt / 10.0;
170            }
171            if keycode.pressed(KeyCode::KeyU) {
172                bloom.prefilter.threshold_softness += dt / 10.0;
173            }
174            bloom.prefilter.threshold_softness = bloom.prefilter.threshold_softness.clamp(0.0, 1.0);
175
176            if keycode.pressed(KeyCode::KeyK) {
177                bloom.scale.x -= dt * 2.0;
178            }
179            if keycode.pressed(KeyCode::KeyI) {
180                bloom.scale.x += dt * 2.0;
181            }
182            bloom.scale.x = bloom.scale.x.clamp(0.0, 16.0);
183        }
184
185        None => {
186            text.0 = "Bloom: Off (Toggle: Space)\n".to_string();
187
188            if keycode.just_pressed(KeyCode::Space) {
189                commands.entity(camera_entity).insert(Bloom::default());
190            }
191        }
192    }
193
194    text.push_str(&format!("(O) Tonemapping: {tonemapping:?}\n"));
195    if keycode.just_pressed(KeyCode::KeyO) {
196        commands
197            .entity(camera_entity)
198            .insert(next_tonemap(tonemapping));
199    }
200}
Source

pub fn any_pressed(&self, inputs: impl IntoIterator<Item = T>) -> bool

Returns true if any item in inputs has been pressed.

Examples found in repository?
examples/input/keyboard_modifiers.rs (line 14)
13fn keyboard_input_system(input: Res<ButtonInput<KeyCode>>) {
14    let shift = input.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight]);
15    let ctrl = input.any_pressed([KeyCode::ControlLeft, KeyCode::ControlRight]);
16
17    if ctrl && shift && input.just_pressed(KeyCode::KeyA) {
18        info!("Just pressed Ctrl + Shift + A!");
19    }
20}
Source

pub fn all_pressed(&self, inputs: impl IntoIterator<Item = T>) -> bool

Returns true if all items in inputs have been pressed.

Source

pub fn release(&mut self, input: T)

Registers a release for the given input.

Source

pub fn release_all(&mut self)

Registers a release for all currently pressed inputs.

Source

pub fn just_pressed(&self, input: T) -> bool

Returns true if the input has been pressed during the current frame.

Note: This function does not imply information regarding the current state of ButtonInput::pressed or ButtonInput::just_released.

Examples found in repository?
examples/app/logs.rs (line 34)
33fn panic_on_p(keys: Res<ButtonInput<KeyCode>>) {
34    if keys.just_pressed(KeyCode::KeyP) {
35        panic!("P pressed, panicking");
36    }
37}
More examples
Hide additional examples
examples/ui/window_fallthrough.rs (line 51)
47fn toggle_mouse_passthrough(
48    keyboard_input: Res<ButtonInput<KeyCode>>,
49    mut cursor_options: Single<&mut CursorOptions>,
50) {
51    if keyboard_input.just_pressed(KeyCode::KeyP) {
52        cursor_options.hit_test = !cursor_options.hit_test;
53    }
54}
examples/audio/audio_control.rs (line 80)
72fn pause(
73    keyboard_input: Res<ButtonInput<KeyCode>>,
74    music_controller: Query<&AudioSink, With<MyMusic>>,
75) {
76    let Ok(sink) = music_controller.single() else {
77        return;
78    };
79
80    if keyboard_input.just_pressed(KeyCode::Space) {
81        sink.toggle_playback();
82    }
83}
84
85fn mute(
86    keyboard_input: Res<ButtonInput<KeyCode>>,
87    mut music_controller: Query<&mut AudioSink, With<MyMusic>>,
88) {
89    let Ok(mut sink) = music_controller.single_mut() else {
90        return;
91    };
92
93    if keyboard_input.just_pressed(KeyCode::KeyM) {
94        sink.toggle_mute();
95    }
96}
97
98fn volume(
99    keyboard_input: Res<ButtonInput<KeyCode>>,
100    mut music_controller: Query<&mut AudioSink, With<MyMusic>>,
101) {
102    let Ok(mut sink) = music_controller.single_mut() else {
103        return;
104    };
105
106    if keyboard_input.just_pressed(KeyCode::Equal) {
107        let current_volume = sink.volume();
108        sink.set_volume(current_volume.increase_by_percentage(10.0));
109    } else if keyboard_input.just_pressed(KeyCode::Minus) {
110        let current_volume = sink.volume();
111        sink.set_volume(current_volume.increase_by_percentage(-10.0));
112    }
113}
examples/window/scale_factor_override.rs (line 82)
81fn toggle_override(input: Res<ButtonInput<KeyCode>>, mut window: Single<&mut Window>) {
82    if input.just_pressed(KeyCode::Enter) {
83        let scale_factor_override = window.resolution.scale_factor_override();
84        window
85            .resolution
86            .set_scale_factor_override(scale_factor_override.xor(Some(1.0)));
87    }
88}
89
90/// This system changes the scale factor override when up or down is pressed
91fn change_scale_factor(input: Res<ButtonInput<KeyCode>>, mut window: Single<&mut Window>) {
92    let scale_factor_override = window.resolution.scale_factor_override();
93    if input.just_pressed(KeyCode::ArrowUp) {
94        window
95            .resolution
96            .set_scale_factor_override(scale_factor_override.map(|n| n + 1.0));
97    } else if input.just_pressed(KeyCode::ArrowDown) {
98        window
99            .resolution
100            .set_scale_factor_override(scale_factor_override.map(|n| (n - 1.0).max(1.0)));
101    }
102}
examples/input/keyboard_modifiers.rs (line 17)
13fn keyboard_input_system(input: Res<ButtonInput<KeyCode>>) {
14    let shift = input.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight]);
15    let ctrl = input.any_pressed([KeyCode::ControlLeft, KeyCode::ControlRight]);
16
17    if ctrl && shift && input.just_pressed(KeyCode::KeyA) {
18        info!("Just pressed Ctrl + Shift + A!");
19    }
20}
examples/window/screenshot.rs (line 22)
17fn screenshot_on_spacebar(
18    mut commands: Commands,
19    input: Res<ButtonInput<KeyCode>>,
20    mut counter: Local<u32>,
21) {
22    if input.just_pressed(KeyCode::Space) {
23        let path = format!("./screenshot-{}.png", *counter);
24        *counter += 1;
25        commands
26            .spawn(Screenshot::primary_window())
27            .observe(save_to_disk(path));
28    }
29}
Additional examples can be found in:
Source

pub fn any_just_pressed(&self, inputs: impl IntoIterator<Item = T>) -> bool

Returns true if any item in inputs has been pressed during the current frame.

Source

pub fn clear_just_pressed(&mut self, input: T) -> bool

Clears the just_pressed state of the input and returns true if the input has just been pressed.

Future calls to ButtonInput::just_pressed for the given input will return false until a new press event occurs.

Source

pub fn just_released(&self, input: T) -> bool

Returns true if the input has been released during the current frame.

Note: This function does not imply information regarding the current state of ButtonInput::pressed or ButtonInput::just_pressed.

Examples found in repository?
examples/input/mouse_input.rs (line 25)
16fn mouse_click_system(mouse_button_input: Res<ButtonInput<MouseButton>>) {
17    if mouse_button_input.pressed(MouseButton::Left) {
18        info!("left mouse currently pressed");
19    }
20
21    if mouse_button_input.just_pressed(MouseButton::Left) {
22        info!("left mouse just pressed");
23    }
24
25    if mouse_button_input.just_released(MouseButton::Left) {
26        info!("left mouse just released");
27    }
28}
More examples
Hide additional examples
examples/dev_tools/fps_overlay.rs (line 92)
74fn customize_config(input: Res<ButtonInput<KeyCode>>, mut overlay: ResMut<FpsOverlayConfig>) {
75    if input.just_pressed(KeyCode::Digit1) {
76        // Changing resource will affect overlay
77        if overlay.text_color == OverlayColor::GREEN {
78            overlay.text_color = OverlayColor::RED;
79        } else {
80            overlay.text_color = OverlayColor::GREEN;
81        }
82    }
83    if input.just_pressed(KeyCode::Digit2) {
84        overlay.text_config.font_size -= 2.0;
85    }
86    if input.just_pressed(KeyCode::Digit3) {
87        overlay.text_config.font_size += 2.0;
88    }
89    if input.just_pressed(KeyCode::Digit4) {
90        overlay.enabled = !overlay.enabled;
91    }
92    if input.just_released(KeyCode::Digit5) {
93        overlay.frame_time_graph_config.enabled = !overlay.frame_time_graph_config.enabled;
94    }
95}
examples/input/keyboard_input.rs (line 26)
13fn keyboard_input_system(
14    keyboard_input: Res<ButtonInput<KeyCode>>,
15    key_input: Res<ButtonInput<Key>>,
16) {
17    // KeyCode is used when you want the key location across different keyboard layouts
18    // See https://w3c.github.io/uievents-code/#code-value-tables for the locations
19    if keyboard_input.pressed(KeyCode::KeyA) {
20        info!("'A' currently pressed");
21    }
22
23    if keyboard_input.just_pressed(KeyCode::KeyA) {
24        info!("'A' just pressed");
25    }
26    if keyboard_input.just_released(KeyCode::KeyA) {
27        info!("'A' just released");
28    }
29
30    // Key is used when you want a specific key, no matter where it is located.
31    // This is useful for symbols that have a specific connotation, e.g. '?' for
32    // a help menu or '+'/'-' for zoom
33    let key = Key::Character("?".into());
34    if key_input.pressed(key.clone()) {
35        info!("'?' currently pressed");
36    }
37    if key_input.just_pressed(key.clone()) {
38        info!("'?' just pressed");
39    }
40    if key_input.just_released(key) {
41        info!("'?' just released");
42    }
43}
Source

pub fn any_just_released(&self, inputs: impl IntoIterator<Item = T>) -> bool

Returns true if any item in inputs has just been released.

Source

pub fn all_just_released(&self, inputs: impl IntoIterator<Item = T>) -> bool

Returns true if all items in inputs have just been released.

Source

pub fn all_just_pressed(&self, inputs: impl IntoIterator<Item = T>) -> bool

Returns true if all items in inputs have been just pressed.

Source

pub fn clear_just_released(&mut self, input: T) -> bool

Clears the just_released state of the input and returns true if the input has just been released.

Future calls to ButtonInput::just_released for the given input will return false until a new release event occurs.

Source

pub fn reset(&mut self, input: T)

Clears the pressed, just_pressed and just_released data of the input.

Source

pub fn reset_all(&mut self)

Clears the pressed, just_pressed, and just_released data for every input.

See also ButtonInput::clear for simulating elapsed time steps.

Source

pub fn clear(&mut self)

Clears the just pressed and just released data for every input.

See also ButtonInput::reset_all for a full reset.

Source

pub fn get_pressed(&self) -> impl ExactSizeIterator

An iterator visiting every pressed input in arbitrary order.

Source

pub fn get_just_pressed(&self) -> impl ExactSizeIterator

An iterator visiting every just pressed input in arbitrary order.

Note: Returned elements do not imply information regarding the current state of ButtonInput::pressed or ButtonInput::just_released.

Source

pub fn get_just_released(&self) -> impl ExactSizeIterator

An iterator visiting every just released input in arbitrary order.

Note: Returned elements do not imply information regarding the current state of ButtonInput::pressed or ButtonInput::just_pressed.

Trait Implementations§

Source§

impl<T> Clone for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static,

Source§

fn clone(&self) -> ButtonInput<T>

Returns a duplicate of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl<T> Debug for ButtonInput<T>
where T: Debug + Clone + Eq + Hash + Send + Sync + 'static,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<T> Default for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static,

Source§

fn default() -> ButtonInput<T>

Returns the “default value” for a type. Read more
Source§

impl<T> FromArg for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

type This<'from_arg> = ButtonInput<T>

The type to convert into. Read more
Source§

fn from_arg( arg: Arg<'_>, ) -> Result<<ButtonInput<T> as FromArg>::This<'_>, ArgError>

Creates an item from an argument. Read more
Source§

impl<T> FromReflect for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn from_reflect( reflect: &(dyn PartialReflect + 'static), ) -> Option<ButtonInput<T>>

Constructs a concrete instance of Self from a reflected value.
Source§

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails. Read more
Source§

impl<T> GetOwnership for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn ownership() -> Ownership

Returns the ownership of Self.
Source§

impl<T> GetTypeRegistration for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.
Source§

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type. Read more
Source§

impl<T> IntoReturn for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn into_return<'into_return>(self) -> Return<'into_return>
where ButtonInput<T>: 'into_return,

Converts Self into a Return value.
Source§

impl<T> PartialReflect for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value. Read more
Source§

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value. Read more
Source§

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type. Read more
Source§

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type. Read more
Source§

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type. Read more
Source§

fn reflect_owned(self: Box<ButtonInput<T>>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type. Read more
Source§

fn try_into_reflect( self: Box<ButtonInput<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.
Source§

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.
Source§

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.
Source§

fn into_partial_reflect(self: Box<ButtonInput<T>>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value. Read more
Source§

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value. Read more
Source§

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value. Read more
Source§

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result. Read more
Source§

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection. Read more
Source§

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value. Read more
Source§

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind. Read more
Source§

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>
where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails. Read more
Source§

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type). Read more
Source§

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

Debug formatter for the value. Read more
Source§

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type. Read more
Source§

impl<T> Reflect for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn into_any(self: Box<ButtonInput<T>>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>. Read more
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any. Read more
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any. Read more
Source§

fn into_reflect(self: Box<ButtonInput<T>>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.
Source§

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.
Source§

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.
Source§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value. Read more
Source§

impl<T> Struct for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field named name as a &dyn PartialReflect.
Source§

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.
Source§

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn PartialReflect.
Source§

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.
Source§

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.
Source§

fn field_len(&self) -> usize

Returns the number of fields in the struct.
Source§

fn iter_fields(&self) -> FieldIter<'_> ⓘ

Returns an iterator over the values of the reflectable fields for this struct.
Source§

fn to_dynamic_struct(&self) -> DynamicStruct

Creates a new DynamicStruct from this struct.
Source§

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.
Source§

impl<T> TypePath for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync,

Source§

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type. Read more
Source§

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type. Read more
Source§

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous. Read more
Source§

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous. Read more
Source§

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous. Read more
Source§

impl<T> Typed for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.
Source§

impl<T> Resource for ButtonInput<T>
where T: Clone + Eq + Hash + Send + Sync + 'static, ButtonInput<T>: Send + Sync + 'static,

Auto Trait Implementations§

§

impl<T> Freeze for ButtonInput<T>

§

impl<T> RefUnwindSafe for ButtonInput<T>
where T: RefUnwindSafe,

§

impl<T> Send for ButtonInput<T>

§

impl<T> Sync for ButtonInput<T>

§

impl<T> Unpin for ButtonInput<T>
where T: Unpin,

§

impl<T> UnwindSafe for ButtonInput<T>
where T: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

Source§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

Return the T ShaderType for self. When used in AsBindGroup derives, it is safe to assume that all images in self exist.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> Conv for T

Source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> DowncastSend for T
where T: Any + Send,

Source§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

Source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> DynamicTypePath for T
where T: TypePath,

Source§

fn reflect_type_path(&self) -> &str

See TypePath::type_path.
Source§

fn reflect_short_type_path(&self) -> &str

See TypePath::short_type_path.
Source§

fn reflect_type_ident(&self) -> Option<&str>

See TypePath::type_ident.
Source§

fn reflect_crate_name(&self) -> Option<&str>

See TypePath::crate_name.
Source§

fn reflect_module_path(&self) -> Option<&str>

See TypePath::module_path.
Source§

impl<T> DynamicTyped for T
where T: Typed,

Source§

fn reflect_type_info(&self) -> &'static TypeInfo

See Typed::type_info.
Source§

impl<T> FmtForward for T

Source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
Source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
Source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
Source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
Source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
Source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
Source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
Source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
Source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<S> FromSample<S> for S

Source§

fn from_sample_(s: S) -> S

Source§

impl<T> FromWorld for T
where T: Default,

Source§

fn from_world(_world: &mut World) -> T

Creates Self using default().

Source§

impl<S> GetField for S
where S: Struct,

Source§

fn get_field<T>(&self, name: &str) -> Option<&T>
where T: Reflect,

Returns a reference to the value of the field named name, downcast to T.
Source§

fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>
where T: Reflect,

Returns a mutable reference to the value of the field named name, downcast to T.
Source§

impl<T> GetPath for T
where T: Reflect + ?Sized,

Source§

fn reflect_path<'p>( &self, path: impl ReflectPath<'p>, ) -> Result<&(dyn PartialReflect + 'static), ReflectPathError<'p>>

Returns a reference to the value specified by path. Read more
Source§

fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut (dyn PartialReflect + 'static), ReflectPathError<'p>>

Returns a mutable reference to the value specified by path. Read more
Source§

fn path<'p, T>( &self, path: impl ReflectPath<'p>, ) -> Result<&T, ReflectPathError<'p>>
where T: Reflect,

Returns a statically typed reference to the value specified by path. Read more
Source§

fn path_mut<'p, T>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut T, ReflectPathError<'p>>
where T: Reflect,

Returns a statically typed mutable reference to the value specified by path. Read more
Source§

impl<T, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

Source§

const WITNESS: W = W::MAKE

A constant of the type witness
Source§

impl<T> Identity for T
where T: ?Sized,

Source§

const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.
Source§

type Type = T

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).
Source§

impl<T> InitializeFromFunction<T> for T

Source§

fn initialize_from_function(f: fn() -> T) -> T

Create an instance of this type from an initialization function
Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> IntoResult<T> for T

Source§

fn into_result(self) -> Result<T, RunSystemError>

Converts this type into the system output type.
Source§

impl<F, T> IntoSample<T> for F
where T: FromSample<F>,

Source§

fn into_sample(self) -> T

Source§

impl<A> Is for A
where A: Any,

Source§

fn is<T>() -> bool
where T: Any,

Checks if the current type “is” another type, using a TypeId equality comparison. This is most useful in the context of generic logic. Read more
Source§

impl<T> NoneValue for T
where T: Default,

Source§

type NoneType = T

Source§

fn null_value() -> T

The none-equivalent value.
Source§

impl<T> Pipe for T
where T: ?Sized,

Source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
Source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
Source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
Source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
Source§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
Source§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
Source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
Source§

impl<R, P> ReadPrimitive<R> for P
where R: Read + ReadEndian<P>, P: Default,

Source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
Source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
Source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<Ret> SpawnIfAsync<(), Ret> for Ret

Source§

fn spawn(self) -> Ret

Spawn the value into the dioxus runtime if it is an async block
Source§

impl<T, O> SuperFrom<T> for O
where O: From<T>,

Source§

fn super_from(input: T) -> O

Convert from a type to another type.
Source§

impl<T, O, M> SuperInto<O, M> for T
where O: SuperFrom<T, M>,

Source§

fn super_into(self) -> O

Convert from a type to another type.
Source§

impl<T> Tap for T

Source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
Source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
Source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
Source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
Source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
Source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
Source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
Source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
Source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
Source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

Source§

fn to_sample_(self) -> U

Source§

impl<T> TryConv for T

Source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> TypeData for T
where T: 'static + Send + Sync + Clone,

Source§

fn clone_type_data(&self) -> Box<dyn TypeData>

Creates a type-erased clone of this value.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> ConditionalSend for T
where T: Send,

Source§

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,

Source§

impl<T> Reflectable for T
where T: Reflect + GetTypeRegistration + Typed + TypePath,

Source§

impl<T> Settings for T
where T: 'static + Send + Sync,

Source§

impl<T> WasmNotSend for T
where T: Send,

Source§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

Source§

impl<T> WasmNotSync for T
where T: Sync,