Struct ColorStop

Source

pub struct ColorStop {
    pub color: Color,
    pub point: Val,
    pub hint: f32,
}

Expand description

A color stop for a gradient

Fields§

§color: Color

Color

§point: Val

Logical position along the gradient line. Stop positions are relative to the start of the gradient and not other stops.

§hint: f32

Normalized position between this and the following stop of the interpolation midpoint.

Implementations§

Source §

impl ColorStop

Source

pub fn new(color: impl Into<Color>, point: Val) -> Self

Create a new color stop

Examples found in repository ?

examples/radial_gradients.rs (line 21)

19fn setup_grid(mut commands: Commands) {
20    let color_stops = vec![
21        ColorStop::new(Color::BLACK, Val::Px(5.)),
22        ColorStop::new(Color::WHITE, Val::Px(5.)),
23        ColorStop::new(Color::WHITE, Val::Percent(100.)),
24        ColorStop::auto(RED),
25    ];
26
27    commands.spawn(Camera2d);
28    commands
29        .spawn((
30            Node {
31                width: Val::Percent(100.),
32                height: Val::Percent(100.),
33                display: Display::Grid,
34                align_items: AlignItems::Start,
35                align_content: AlignContent::Start,
36                grid_template_columns: vec![RepeatedGridTrack::px(
37                    GridTrackRepetition::AutoFill,
38                    CELL_SIZE,
39                )],
40                grid_auto_flow: GridAutoFlow::Row,
41                row_gap: Val::Px(GAP),
42                column_gap: Val::Px(GAP),
43                margin: UiRect::all(Val::Px(GAP)),
44                ..Default::default()
45            },
46            BackgroundColor(NAVY.into()),
47        ))
48        .with_children(|commands| {
49            for shape in [
50                RadialGradientShape::ClosestSide,
51                RadialGradientShape::FarthestSide,
52                RadialGradientShape::Circle(Val::Percent(55.)),
53                RadialGradientShape::FarthestCorner,
54            ] {
55                for position in [
56                    Position::TOP_LEFT,
57                    Position::LEFT,
58                    Position::BOTTOM_LEFT,
59                    Position::TOP,
60                    Position::CENTER,
61                    Position::BOTTOM,
62                    Position::TOP_RIGHT,
63                    Position::RIGHT,
64                    Position::BOTTOM_RIGHT,
65                ] {
66                    for (w, h) in [(100., 100.), (100., 50.)] {
67                        commands
68                            .spawn((
69                                BackgroundColor(GREEN.into()),
70                                Node {
71                                    display: Display::Grid,
72                                    width: Val::Px(CELL_SIZE),
73                                    ..Default::default()
74                                },
75                            ))
76                            .with_children(|commands| {
77                                commands.spawn((
78                                    Text(format!("{shape:#?}\n{position:#?}")),
79                                    TextFont::from_font_size(10.),
80                                ));
81                                commands.spawn((
82                                    Node {
83                                        width: Val::Px(w),
84                                        height: Val::Px(h),
85                                        ..default()
86                                    },
87                                    BackgroundGradient::from(RadialGradient {
88                                        stops: color_stops.clone(),
89                                        position,
90                                        shape,
91                                    }),
92                                ));
93                            });
94                    }
95                }
96            }
97        });
98}

More examples

Hide additional examples

examples/gradients.rs (line 38)

23fn setup(mut commands: Commands) {
24    commands.spawn(Camera2d);
25
26    commands
27        .spawn(Node {
28            flex_direction: FlexDirection::Column,
29            row_gap: Val::Px(30.),
30            margin: UiRect::all(Val::Px(30.)),
31            ..Default::default()
32        })
33        .with_children(|commands| {
34            for (i, (b, stops)) in [
35                (
36                    5.,
37                    vec![
38                        ColorStop::new(Color::WHITE, Val::Percent(15.)),
39                        ColorStop::new(Color::BLACK, Val::Percent(85.)),
40                    ],
41                ),
42                (5., vec![RED.into(), BLUE.into(), LIME.into()]),
43                (
44                    0.,
45                    vec![
46                        RED.into(),
47                        ColorStop::new(RED, Val::Percent(100. / 7.)),
48                        ColorStop::new(ORANGE, Val::Percent(100. / 7.)),
49                        ColorStop::new(ORANGE, Val::Percent(200. / 7.)),
50                        ColorStop::new(YELLOW, Val::Percent(200. / 7.)),
51                        ColorStop::new(YELLOW, Val::Percent(300. / 7.)),
52                        ColorStop::new(GREEN, Val::Percent(300. / 7.)),
53                        ColorStop::new(GREEN, Val::Percent(400. / 7.)),
54                        ColorStop::new(BLUE, Val::Percent(400. / 7.)),
55                        ColorStop::new(BLUE, Val::Percent(500. / 7.)),
56                        ColorStop::new(INDIGO, Val::Percent(500. / 7.)),
57                        ColorStop::new(INDIGO, Val::Percent(600. / 7.)),
58                        ColorStop::new(VIOLET, Val::Percent(600. / 7.)),
59                        VIOLET.into(),
60                    ],
61                ),
62            ]
63            .into_iter()
64            .enumerate()
65            {
66                commands.spawn(Node::default()).with_children(|commands| {
67                    commands
68                        .spawn(Node {
69                            flex_direction: FlexDirection::Column,
70                            row_gap: Val::Px(10.),
71                            ..Default::default()
72                        })
73                        .with_children(|commands| {
74                            for (w, h) in [(100., 100.), (50., 100.), (100., 50.)] {
75                                commands
76                                    .spawn(Node {
77                                        column_gap: Val::Px(10.),
78                                        ..Default::default()
79                                    })
80                                    .with_children(|commands| {
81                                        for angle in (0..8).map(|i| i as f32 * TAU / 8.) {
82                                            commands.spawn((
83                                                Node {
84                                                    width: Val::Px(w),
85                                                    height: Val::Px(h),
86                                                    border: UiRect::all(Val::Px(b)),
87                                                    ..default()
88                                                },
89                                                BorderRadius::all(Val::Px(20.)),
90                                                BackgroundGradient::from(LinearGradient {
91                                                    angle,
92                                                    stops: stops.clone(),
93                                                }),
94                                                BorderGradient::from(LinearGradient {
95                                                    angle: 3. * TAU / 8.,
96                                                    stops: vec![
97                                                        YELLOW.into(),
98                                                        Color::WHITE.into(),
99                                                        ORANGE.into(),
100                                                    ],
101                                                }),
102                                            ));
103                                        }
104                                    });
105                            }
106                        });
107
108                    commands.spawn(Node::default()).with_children(|commands| {
109                        commands.spawn((
110                            Node {
111                                aspect_ratio: Some(1.),
112                                height: Val::Percent(100.),
113                                border: UiRect::all(Val::Px(b)),
114                                margin: UiRect::left(Val::Px(30.)),
115                                ..default()
116                            },
117                            BorderRadius::all(Val::Px(20.)),
118                            BackgroundGradient::from(LinearGradient {
119                                angle: 0.,
120                                stops: stops.clone(),
121                            }),
122                            BorderGradient::from(LinearGradient {
123                                angle: 3. * TAU / 8.,
124                                stops: vec![YELLOW.into(), Color::WHITE.into(), ORANGE.into()],
125                            }),
126                            AnimateMarker,
127                        ));
128
129                        commands.spawn((
130                            Node {
131                                aspect_ratio: Some(1.),
132                                height: Val::Percent(100.),
133                                border: UiRect::all(Val::Px(b)),
134                                margin: UiRect::left(Val::Px(30.)),
135                                ..default()
136                            },
137                            BorderRadius::all(Val::Px(20.)),
138                            BackgroundGradient::from(RadialGradient {
139                                stops: stops.clone(),
140                                shape: RadialGradientShape::ClosestSide,
141                                position: Position::CENTER,
142                            }),
143                            BorderGradient::from(LinearGradient {
144                                angle: 3. * TAU / 8.,
145                                stops: vec![YELLOW.into(), Color::WHITE.into(), ORANGE.into()],
146                            }),
147                            AnimateMarker,
148                        ));
149                        commands.spawn((
150                            Node {
151                                aspect_ratio: Some(1.),
152                                height: Val::Percent(100.),
153                                border: UiRect::all(Val::Px(b)),
154                                margin: UiRect::left(Val::Px(30.)),
155                                ..default()
156                            },
157                            BorderRadius::all(Val::Px(20.)),
158                            BackgroundGradient::from(ConicGradient {
159                                start: (0.25001) * TAU * i as f32,
160                                stops: stops
161                                    .iter()
162                                    .map(|stop| AngularColorStop::auto(stop.color))
163                                    .collect(),
164                                position: Position::CENTER,
165                            }),
166                            BorderGradient::from(LinearGradient {
167                                angle: 3. * TAU / 8.,
168                                stops: vec![YELLOW.into(), Color::WHITE.into(), ORANGE.into()],
169                            }),
170                            AnimateMarker,
171                        ));
172                    });
173                });
174            }
175        });
176}

Source

pub fn auto(color: impl Into<Color>) -> Self

An automatic color stop. The positions of automatic stops are interpolated evenly between explicit stops.

Examples found in repository ?

examples/stacked_gradients.rs (line 37)

17fn setup(mut commands: Commands) {
18    commands.spawn(Camera2d);
19    commands
20        .spawn(Node {
21            display: Display::Grid,
22            width: Val::Percent(100.),
23            height: Val::Percent(100.),
24
25            ..Default::default()
26        })
27        .with_children(|commands| {
28            commands.spawn((
29                Node {
30                    width: Val::Percent(100.),
31                    height: Val::Percent(100.),
32                    ..Default::default()
33                },
34                BackgroundColor(Color::BLACK),
35                BackgroundGradient(vec![
36                    LinearGradient::to_top_right(vec![
37                        ColorStop::auto(RED),
38                        ColorStop::auto(RED.with_alpha(0.)),
39                    ])
40                    .into(),
41                    LinearGradient::to_top_left(vec![
42                        ColorStop::auto(BLUE),
43                        ColorStop::auto(BLUE.with_alpha(0.)),
44                    ])
45                    .into(),
46                    ConicGradient {
47                        start: 0.,
48                        position: Position::CENTER,
49                        stops: vec![
50                            AngularColorStop::auto(YELLOW.with_alpha(0.)),
51                            AngularColorStop::auto(YELLOW.with_alpha(0.)),
52                            AngularColorStop::auto(YELLOW),
53                            AngularColorStop::auto(YELLOW.with_alpha(0.)),
54                            AngularColorStop::auto(YELLOW.with_alpha(0.)),
55                        ],
56                    }
57                    .into(),
58                    RadialGradient {
59                        position: Position::TOP.at_x(Val::Percent(5.)),
60                        shape: RadialGradientShape::Circle(Val::Vh(30.)),
61                        stops: vec![
62                            ColorStop::auto(Color::WHITE),
63                            ColorStop::auto(YELLOW),
64                            ColorStop::auto(YELLOW.with_alpha(0.1)),
65                            ColorStop::auto(YELLOW.with_alpha(0.)),
66                        ],
67                    }
68                    .into(),
69                    LinearGradient {
70                        angle: TAU / 16.,
71                        stops: vec![
72                            ColorStop::auto(Color::BLACK),
73                            ColorStop::auto(Color::BLACK.with_alpha(0.)),
74                        ],
75                    }
76                    .into(),
77                    LinearGradient {
78                        angle: 15. * TAU / 16.,
79                        stops: vec![
80                            ColorStop::auto(Color::BLACK),
81                            ColorStop::auto(Color::BLACK.with_alpha(0.)),
82                        ],
83                    }
84                    .into(),
85                ]),
86            ));
87        });
88}

More examples

Hide additional examples

examples/radial_gradients.rs (line 24)

19fn setup_grid(mut commands: Commands) {
20    let color_stops = vec![
21        ColorStop::new(Color::BLACK, Val::Px(5.)),
22        ColorStop::new(Color::WHITE, Val::Px(5.)),
23        ColorStop::new(Color::WHITE, Val::Percent(100.)),
24        ColorStop::auto(RED),
25    ];
26
27    commands.spawn(Camera2d);
28    commands
29        .spawn((
30            Node {
31                width: Val::Percent(100.),
32                height: Val::Percent(100.),
33                display: Display::Grid,
34                align_items: AlignItems::Start,
35                align_content: AlignContent::Start,
36                grid_template_columns: vec![RepeatedGridTrack::px(
37                    GridTrackRepetition::AutoFill,
38                    CELL_SIZE,
39                )],
40                grid_auto_flow: GridAutoFlow::Row,
41                row_gap: Val::Px(GAP),
42                column_gap: Val::Px(GAP),
43                margin: UiRect::all(Val::Px(GAP)),
44                ..Default::default()
45            },
46            BackgroundColor(NAVY.into()),
47        ))
48        .with_children(|commands| {
49            for shape in [
50                RadialGradientShape::ClosestSide,
51                RadialGradientShape::FarthestSide,
52                RadialGradientShape::Circle(Val::Percent(55.)),
53                RadialGradientShape::FarthestCorner,
54            ] {
55                for position in [
56                    Position::TOP_LEFT,
57                    Position::LEFT,
58                    Position::BOTTOM_LEFT,
59                    Position::TOP,
60                    Position::CENTER,
61                    Position::BOTTOM,
62                    Position::TOP_RIGHT,
63                    Position::RIGHT,
64                    Position::BOTTOM_RIGHT,
65                ] {
66                    for (w, h) in [(100., 100.), (100., 50.)] {
67                        commands
68                            .spawn((
69                                BackgroundColor(GREEN.into()),
70                                Node {
71                                    display: Display::Grid,
72                                    width: Val::Px(CELL_SIZE),
73                                    ..Default::default()
74                                },
75                            ))
76                            .with_children(|commands| {
77                                commands.spawn((
78                                    Text(format!("{shape:#?}\n{position:#?}")),
79                                    TextFont::from_font_size(10.),
80                                ));
81                                commands.spawn((
82                                    Node {
83                                        width: Val::Px(w),
84                                        height: Val::Px(h),
85                                        ..default()
86                                    },
87                                    BackgroundGradient::from(RadialGradient {
88                                        stops: color_stops.clone(),
89                                        position,
90                                        shape,
91                                    }),
92                                ));
93                            });
94                    }
95                }
96            }
97        });
98}

Source

pub fn with_hint(self, hint: f32) -> Self

Trait Implementations§

Source §

impl Clone for ColorStop

Source §

fn clone(&self) -> ColorStop

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 Debug for ColorStop

Source §

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

Formats the value using the given formatter. Read more

Source §

impl Default for ColorStop

Source §

fn default() -> Self

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

Source §

impl From<(Color, Val)> for ColorStop

Source §

fn from((color, stop): (Color, Val)) -> Self

Converts to this type from the input type.

Source §

impl From<Color> for ColorStop

Source §

fn from(color: Color) -> Self

Converts to this type from the input type.

Source §

impl From<Srgba> for ColorStop

Source §

fn from(color: Srgba) -> Self

Converts to this type from the input type.

Source §

impl FromReflect for ColorStop
where ColorStop: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source §

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

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 GetTypeRegistration for ColorStop
where ColorStop: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: 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 PartialEq for ColorStop

Source §

fn eq(&self, other: &ColorStop) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

Source §

impl PartialReflect for ColorStop
where ColorStop: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: 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) -> 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<Self>) -> ReflectOwned

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

Source §

fn try_into_reflect( self: Box<Self>, ) -> 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>

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

Source §

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

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

Source §

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

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

Source §

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value. Read more

Source §

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

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

Source §

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

Returns a “partial equality” comparison result. Read more

Source §

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

Debug formatter for the value. 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 clone_value(&self) -> Box<dyn PartialReflect>

👎Deprecated since 0.16.0: to clone reflected values, prefer using reflect_clone. To convert reflected values to dynamic ones, use to_dynamic.

Clones Self into its dynamic representation. 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_hash(&self) -> Option<u64>

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

Source §

fn is_dynamic(&self) -> bool

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

Source §

impl Reflect for ColorStop
where ColorStop: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source §

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

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

Source §

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any. Read more

Source §

fn as_any_mut(&mut self) -> &mut dyn Any

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

Source §

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

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

Source §

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

Source §

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

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 Struct for ColorStop
where ColorStop: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source §

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

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>

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>

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>

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

Source §

fn clone_dynamic(&self) -> DynamicStruct

👎Deprecated since 0.16.0: use to_dynamic_struct instead

Clones the struct into a DynamicStruct.

Source §

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

Will return None if TypeInfo is not available.

Source §

impl TypePath for ColorStop
where ColorStop: 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 Typed for ColorStop
where ColorStop: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source §

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

Source §

impl Copy for ColorStop

Source §

impl StructuralPartialEq for ColorStop

Auto Trait Implementations§

§

impl UnwindSafe for ColorStop

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 for T
where U: ShaderType, &'a T: for<'a> Into,

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> Downcast<T> for T

Source §

fn downcast(&self) -> &T

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> 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> 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> 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> 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 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 §