Trait Reflect

Source
pub trait Reflect:
    PartialReflect
    + DynamicTyped
    + Any {
    // Required methods
    fn into_any(self: Box<Self>) -> Box<dyn Any>;
    fn as_any(&self) -> &(dyn Any + 'static);
    fn as_any_mut(&mut self) -> &mut (dyn Any + 'static);
    fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>;
    fn as_reflect(&self) -> &(dyn Reflect + 'static);
    fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static);
    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>;
}
Expand description

A core trait of bevy_reflect, used for downcasting to concrete types.

This is a subtrait of PartialReflect, meaning any type which implements Reflect implements PartialReflect by definition.

It’s recommended to use the derive macro rather than manually implementing this trait. Doing so will automatically implement this trait, PartialReflect, and many other useful traits for reflection, including one of the appropriate subtraits: Struct, TupleStruct or Enum.

If you need to use this trait as a generic bound along with other reflection traits, for your convenience, consider using Reflectable instead.

See the crate-level documentation to see how this trait can be used.

Required Methods§

Source

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

Returns the value as a Box<dyn Any>.

For remote wrapper types, this will return the remote type instead.

Source

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

Returns the value as a &dyn Any.

For remote wrapper types, this will return the remote type instead.

Source

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

Returns the value as a &mut dyn Any.

For remote wrapper types, this will return the remote type instead.

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 + '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.

If value does not contain a value of type T, returns an Err containing the trait object.

Implementations§

Source§

impl dyn Reflect

Source

pub fn downcast<T>(self: Box<dyn Reflect>) -> Result<Box<T>, Box<dyn Reflect>>
where T: Any,

Downcasts the value to type T, consuming the trait object.

If the underlying value is not of type T, returns Err(self).

For remote types, T should be the type itself rather than the wrapper type.

Source

pub fn take<T>(self: Box<dyn Reflect>) -> Result<T, Box<dyn Reflect>>
where T: Any,

Downcasts the value to type T, unboxing and consuming the trait object.

If the underlying value is not of type T, returns Err(self).

For remote types, T should be the type itself rather than the wrapper type.

Examples found in repository?
examples/reflection/type_data.rs (line 64)
10fn main() {
11    trait Damageable {
12        type Health;
13        fn damage(&mut self, damage: Self::Health);
14    }
15
16    #[derive(Reflect, PartialEq, Debug)]
17    struct Zombie {
18        health: u32,
19    }
20
21    impl Damageable for Zombie {
22        type Health = u32;
23        fn damage(&mut self, damage: Self::Health) {
24            self.health -= damage;
25        }
26    }
27
28    // Let's say we have a reflected value.
29    // Here we know it's a `Zombie`, but for demonstration purposes let's pretend we don't.
30    // Pretend it's just some `Box<dyn Reflect>` value.
31    let mut value: Box<dyn Reflect> = Box::new(Zombie { health: 100 });
32
33    // We think `value` might contain a type that implements `Damageable`
34    // and now we want to call `Damageable::damage` on it.
35    // How can we do this without knowing in advance the concrete type is `Zombie`?
36
37    // This is where type data comes in.
38    // Type data is a way of associating type-specific data with a type for use in dynamic contexts.
39    // This type data can then be used at runtime to perform type-specific operations.
40
41    // Let's create a type data struct for `Damageable` that we can associate with `Zombie`!
42
43    // Firstly, type data must be cloneable.
44    #[derive(Clone)]
45    // Next, they are usually named with the `Reflect` prefix (we'll see why in a bit).
46    struct ReflectDamageable {
47        // Type data can contain whatever you want, but it's common to include function pointers
48        // to the type-specific operations you want to perform (such as trait methods).
49        // Just remember that we're working with `Reflect` data,
50        // so we can't use `Self`, generics, or associated types.
51        // In those cases, we'll have to use `dyn Reflect` trait objects.
52        damage: fn(&mut dyn Reflect, damage: Box<dyn Reflect>),
53    }
54
55    // Now, we can create a blanket implementation of the `FromType` trait to construct our type data
56    // for any type that implements `Reflect` and `Damageable`.
57    impl<T: Reflect + Damageable<Health: Reflect>> FromType<T> for ReflectDamageable {
58        fn from_type() -> Self {
59            Self {
60                damage: |reflect, damage| {
61                    // This requires that `reflect` is `T` and not a dynamic representation like `DynamicStruct`.
62                    // We could have the function pointer return a `Result`, but we'll just `unwrap` for simplicity.
63                    let damageable = reflect.downcast_mut::<T>().unwrap();
64                    let damage = damage.take::<T::Health>().unwrap();
65                    damageable.damage(damage);
66                },
67            }
68        }
69    }
70
71    // It's also common to provide convenience methods for calling the type-specific operations.
72    impl ReflectDamageable {
73        pub fn damage(&self, reflect: &mut dyn Reflect, damage: Box<dyn Reflect>) {
74            (self.damage)(reflect, damage);
75        }
76    }
77
78    // With all this done, we're ready to make use of `ReflectDamageable`!
79    // It starts with registering our type along with its type data:
80    let mut registry = TypeRegistry::default();
81    registry.register::<Zombie>();
82    registry.register_type_data::<Zombie, ReflectDamageable>();
83
84    // Then at any point we can retrieve the type data from the registry:
85    let type_id = value.reflect_type_info().type_id();
86    let reflect_damageable = registry
87        .get_type_data::<ReflectDamageable>(type_id)
88        .unwrap();
89
90    // And call our method:
91    reflect_damageable.damage(value.as_reflect_mut(), Box::new(25u32));
92    assert_eq!(value.take::<Zombie>().unwrap(), Zombie { health: 75 });
93
94    // This is a simple example, but type data can be used for much more complex operations.
95    // Bevy also provides some useful shorthand for working with type data.
96
97    // For example, we can have the type data be automatically registered when we register the type
98    // by using the `#[reflect(MyTrait)]` attribute when defining our type.
99    #[derive(Reflect)]
100    // Notice that we don't need to type out `ReflectDamageable`.
101    // This is why we named it with the `Reflect` prefix:
102    // the derive macro will automatically look for a type named `ReflectDamageable` in the current scope.
103    #[reflect(Damageable)]
104    struct Skeleton {
105        health: u32,
106    }
107
108    impl Damageable for Skeleton {
109        type Health = u32;
110        fn damage(&mut self, damage: Self::Health) {
111            self.health -= damage;
112        }
113    }
114
115    // This will now register `Skeleton` along with its `ReflectDamageable` type data.
116    registry.register::<Skeleton>();
117
118    // And for object-safe traits (see https://doc.rust-lang.org/reference/items/traits.html#object-safety),
119    // Bevy provides a convenience macro for generating type data that converts `dyn Reflect` into `dyn MyTrait`.
120    #[reflect_trait]
121    trait Health {
122        fn health(&self) -> u32;
123    }
124
125    impl Health for Skeleton {
126        fn health(&self) -> u32 {
127            self.health
128        }
129    }
130
131    // Using the `#[reflect_trait]` macro we're able to automatically generate a `ReflectHealth` type data struct,
132    // which can then be registered like any other type data:
133    registry.register_type_data::<Skeleton, ReflectHealth>();
134
135    // Now we can use `ReflectHealth` to convert `dyn Reflect` into `dyn Health`:
136    let value: Box<dyn Reflect> = Box::new(Skeleton { health: 50 });
137
138    let type_id = value.reflect_type_info().type_id();
139    let reflect_health = registry.get_type_data::<ReflectHealth>(type_id).unwrap();
140
141    // Type data generated by `#[reflect_trait]` comes with a `get`, `get_mut`, and `get_boxed` method,
142    // which convert `&dyn Reflect` into `&dyn MyTrait`, `&mut dyn Reflect` into `&mut dyn MyTrait`,
143    // and `Box<dyn Reflect>` into `Box<dyn MyTrait>`, respectively.
144    let value: &dyn Health = reflect_health.get(value.as_reflect()).unwrap();
145    assert_eq!(value.health(), 50);
146
147    // Lastly, here's a list of some useful type data provided by Bevy that you might want to register for your types:
148    // - `ReflectDefault` for types that implement `Default`
149    // - `ReflectFromWorld` for types that implement `FromWorld`
150    // - `ReflectComponent` for types that implement `Component`
151    // - `ReflectResource` for types that implement `Resource`
152    // - `ReflectSerialize` for types that implement `Serialize`
153    // - `ReflectDeserialize` for types that implement `Deserialize`
154    //
155    // And here are some that are automatically registered by the `Reflect` derive macro:
156    // - `ReflectFromPtr`
157    // - `ReflectFromReflect` (if not `#[reflect(from_reflect = false)]`)
158}
More examples
Hide additional examples
examples/reflection/reflection_types.rs (line 140)
67fn setup() {
68    let mut z = <HashMap<_, _>>::default();
69    z.insert("Hello".to_string(), 1.0);
70    let value: Box<dyn Reflect> = Box::new(A {
71        x: 1,
72        y: vec![1, 2],
73        z,
74    });
75
76    // There are a number of different "reflect traits", which each expose different operations on
77    // the underlying type
78    match value.reflect_ref() {
79        // `Struct` is a trait automatically implemented for structs that derive Reflect. This trait
80        // allows you to interact with fields via their string names or indices
81        ReflectRef::Struct(value) => {
82            info!(
83                "This is a 'struct' type with an 'x' value of {}",
84                value.get_field::<usize>("x").unwrap()
85            );
86        }
87        // `TupleStruct` is a trait automatically implemented for tuple structs that derive Reflect.
88        // This trait allows you to interact with fields via their indices
89        ReflectRef::TupleStruct(_) => {}
90        // `Tuple` is a special trait that can be manually implemented (instead of deriving
91        // Reflect). This exposes "tuple" operations on your type, allowing you to interact
92        // with fields via their indices. Tuple is automatically implemented for tuples of
93        // arity 12 or less.
94        ReflectRef::Tuple(_) => {}
95        // `Enum` is a trait automatically implemented for enums that derive Reflect. This trait allows you
96        // to interact with the current variant and its fields (if it has any)
97        ReflectRef::Enum(_) => {}
98        // `List` is a special trait that can be manually implemented (instead of deriving Reflect).
99        // This exposes "list" operations on your type, such as insertion. `List` is automatically
100        // implemented for relevant core types like Vec<T>.
101        ReflectRef::List(_) => {}
102        // `Array` is a special trait that can be manually implemented (instead of deriving Reflect).
103        // This exposes "array" operations on your type, such as indexing. `Array`
104        // is automatically implemented for relevant core types like [T; N].
105        ReflectRef::Array(_) => {}
106        // `Map` is a special trait that can be manually implemented (instead of deriving Reflect).
107        // This exposes "map" operations on your type, such as getting / inserting by key.
108        // Map is automatically implemented for relevant core types like HashMap<K, V>
109        ReflectRef::Map(_) => {}
110        // `Set` is a special trait that can be manually implemented (instead of deriving Reflect).
111        // This exposes "set" operations on your type, such as getting / inserting by value.
112        // Set is automatically implemented for relevant core types like HashSet<T>
113        ReflectRef::Set(_) => {}
114        // `Function` is a special trait that can be manually implemented (instead of deriving Reflect).
115        // This exposes "function" operations on your type, such as calling it with arguments.
116        // This trait is automatically implemented for types like DynamicFunction.
117        // This variant only exists if the `reflect_functions` feature is enabled.
118        #[cfg(feature = "reflect_functions")]
119        ReflectRef::Function(_) => {}
120        // `Opaque` types do not implement any of the other traits above. They are simply a Reflect
121        // implementation. Opaque is implemented for opaque types like String and Instant,
122        // but also include primitive types like i32, usize, and f32 (despite not technically being opaque).
123        ReflectRef::Opaque(_) => {}
124        #[expect(
125            clippy::allow_attributes,
126            reason = "`unreachable_patterns` is not always linted"
127        )]
128        #[allow(
129            unreachable_patterns,
130            reason = "This example cannot always detect when `bevy_reflect/functions` is enabled."
131        )]
132        _ => {}
133    }
134
135    let mut dynamic_list = DynamicList::default();
136    dynamic_list.push(3u32);
137    dynamic_list.push(4u32);
138    dynamic_list.push(5u32);
139
140    let mut value: A = value.take::<A>().unwrap();
141    value.y.apply(&dynamic_list);
142    assert_eq!(value.y, vec![3u32, 4u32, 5u32]);
143}
Source

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

Returns true if the underlying value is of type T, or false otherwise.

The underlying value is the concrete type that is stored in this dyn object; it can be downcasted to. In the case that this underlying value “represents” a different type, like the Dynamic*** types do, you can call represents to determine what type they represent. Represented types cannot be downcasted to, but you can use FromReflect to create a value of the represented type from them.

For remote types, T should be the type itself rather than the wrapper type.

Source

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: Any,

Downcasts the value to type T by reference.

If the underlying value is not of type T, returns None.

For remote types, T should be the type itself rather than the wrapper type.

Examples found in repository?
examples/reflection/custom_attributes.rs (line 63)
6fn main() {
7    // Bevy supports statically registering custom attribute data on reflected types,
8    // which can then be accessed at runtime via the type's `TypeInfo`.
9    // Attributes are registered using the `#[reflect(@...)]` syntax,
10    // where the `...` is any expression that resolves to a value which implements `Reflect`.
11    // Note that these attributes are stored based on their type:
12    // if two attributes have the same type, the second one will overwrite the first.
13
14    // Here is an example of registering custom attributes on a type:
15    #[derive(Reflect)]
16    struct Slider {
17        #[reflect(@RangeInclusive::<f32>::new(0.0, 1.0))]
18        // Alternatively, we could have used the `0.0..=1.0` syntax,
19        // but remember to ensure the type is the one you want!
20        #[reflect(@0.0..=1.0_f32)]
21        value: f32,
22    }
23
24    // Now, we can access the custom attributes at runtime:
25    let TypeInfo::Struct(type_info) = Slider::type_info() else {
26        panic!("expected struct");
27    };
28
29    let field = type_info.field("value").unwrap();
30
31    let range = field.get_attribute::<RangeInclusive<f32>>().unwrap();
32    assert_eq!(*range, 0.0..=1.0);
33
34    // And remember that our attributes can be any type that implements `Reflect`:
35    #[derive(Reflect)]
36    struct Required;
37
38    #[derive(Reflect, PartialEq, Debug)]
39    struct Tooltip(String);
40
41    impl Tooltip {
42        fn new(text: &str) -> Self {
43            Self(text.to_string())
44        }
45    }
46
47    #[derive(Reflect)]
48    #[reflect(@Required, @Tooltip::new("An ID is required!"))]
49    struct Id(u8);
50
51    let TypeInfo::TupleStruct(type_info) = Id::type_info() else {
52        panic!("expected struct");
53    };
54
55    // We can check if an attribute simply exists on our type:
56    assert!(type_info.has_attribute::<Required>());
57
58    // We can also get attribute data dynamically:
59    let some_type_id = TypeId::of::<Tooltip>();
60
61    let tooltip: &dyn Reflect = type_info.get_attribute_by_id(some_type_id).unwrap();
62    assert_eq!(
63        tooltip.downcast_ref::<Tooltip>(),
64        Some(&Tooltip::new("An ID is required!"))
65    );
66
67    // And again, attributes of the same type will overwrite each other:
68    #[derive(Reflect)]
69    enum Status {
70        // This will result in `false` being stored:
71        #[reflect(@true)]
72        #[reflect(@false)]
73        Disabled,
74        // This will result in `true` being stored:
75        #[reflect(@false)]
76        #[reflect(@true)]
77        Enabled,
78    }
79
80    let TypeInfo::Enum(type_info) = Status::type_info() else {
81        panic!("expected enum");
82    };
83
84    let disabled = type_info.variant("Disabled").unwrap();
85    assert!(!disabled.get_attribute::<bool>().unwrap());
86
87    let enabled = type_info.variant("Enabled").unwrap();
88    assert!(enabled.get_attribute::<bool>().unwrap());
89}
More examples
Hide additional examples
examples/reflection/reflection.rs (line 76)
56fn setup(type_registry: Res<AppTypeRegistry>) {
57    let mut value = Foo {
58        a: 1,
59        _ignored: NonReflectedValue { _a: 10 },
60        nested: Bar { b: 8 },
61    };
62
63    // You can set field values like this. The type must match exactly or this will fail.
64    *value.get_field_mut("a").unwrap() = 2usize;
65    assert_eq!(value.a, 2);
66    assert_eq!(*value.get_field::<usize>("a").unwrap(), 2);
67
68    // You can also get the `&dyn PartialReflect` value of a field like this
69    let field = value.field("a").unwrap();
70
71    // But values introspected via `PartialReflect` will not return `dyn Reflect` trait objects
72    // (even if the containing type does implement `Reflect`), so we need to convert them:
73    let fully_reflected_field = field.try_as_reflect().unwrap();
74
75    // Now, you can downcast your `Reflect` value like this:
76    assert_eq!(*fully_reflected_field.downcast_ref::<usize>().unwrap(), 2);
77
78    // For this specific case, we also support the shortcut `try_downcast_ref`:
79    assert_eq!(*field.try_downcast_ref::<usize>().unwrap(), 2);
80
81    // `DynamicStruct` also implements the `Struct` and `Reflect` traits.
82    let mut patch = DynamicStruct::default();
83    patch.insert("a", 4usize);
84
85    // You can "apply" Reflect implementations on top of other Reflect implementations.
86    // This will only set fields with the same name, and it will fail if the types don't match.
87    // You can use this to "patch" your types with new values.
88    value.apply(&patch);
89    assert_eq!(value.a, 4);
90
91    let type_registry = type_registry.read();
92    // By default, all derived `Reflect` types can be Serialized using serde. No need to derive
93    // Serialize!
94    let serializer = ReflectSerializer::new(&value, &type_registry);
95    let ron_string =
96        ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
97    info!("{}\n", ron_string);
98
99    // Dynamic properties can be deserialized
100    let reflect_deserializer = ReflectDeserializer::new(&type_registry);
101    let mut deserializer = ron::de::Deserializer::from_str(&ron_string).unwrap();
102    let reflect_value = reflect_deserializer.deserialize(&mut deserializer).unwrap();
103
104    // Deserializing returns a `Box<dyn PartialReflect>` value.
105    // Generally, deserializing a value will return the "dynamic" variant of a type.
106    // For example, deserializing a struct will return the DynamicStruct type.
107    // "Opaque types" will be deserialized as themselves.
108    assert_eq!(
109        reflect_value.reflect_type_path(),
110        DynamicStruct::type_path(),
111    );
112
113    // Reflect has its own `partial_eq` implementation, named `reflect_partial_eq`. This behaves
114    // like normal `partial_eq`, but it treats "dynamic" and "non-dynamic" types the same. The
115    // `Foo` struct and deserialized `DynamicStruct` are considered equal for this reason:
116    assert!(reflect_value.reflect_partial_eq(&value).unwrap());
117
118    // By "patching" `Foo` with the deserialized DynamicStruct, we can "Deserialize" Foo.
119    // This means we can serialize and deserialize with a single `Reflect` derive!
120    value.apply(&*reflect_value);
121}
examples/reflection/dynamic_types.rs (line 43)
12fn main() {
13    #[derive(Reflect, Default, PartialEq, Debug)]
14    #[reflect(Identifiable, Default)]
15    struct Player {
16        id: u32,
17    }
18
19    #[reflect_trait]
20    trait Identifiable {
21        fn id(&self) -> u32;
22    }
23
24    impl Identifiable for Player {
25        fn id(&self) -> u32 {
26            self.id
27        }
28    }
29
30    // Normally, when instantiating a type, you get back exactly that type.
31    // This is because the type is known at compile time.
32    // We call this the "concrete" or "canonical" type.
33    let player: Player = Player { id: 123 };
34
35    // When working with reflected types, however, we often "erase" this type information
36    // using the `Reflect` trait object.
37    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
38    // The underlying type is still the same (in this case, `Player`),
39    // but now we've hidden that information from the compiler.
40    let reflected: Box<dyn Reflect> = Box::new(player);
41
42    // Because it's the same type under the hood, we can still downcast it back to the original type.
43    assert!(reflected.downcast_ref::<Player>().is_some());
44
45    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
46    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
47    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
48    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
49    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));
50
51    // Another way we can "clone" our data is by converting it to a dynamic type.
52    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
53    // This is because it returns a dynamic type that simply represents the original type.
54    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
55    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
56    assert!(dynamic.is_dynamic());
57
58    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
59    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
60    assert!(dynamic.try_as_reflect().is_none());
61
62    // Generally dynamic types are used to represent (or "proxy") the original type,
63    // so that we can continue to access its fields and overall structure.
64    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
65    let id = dynamic_ref.field("id").unwrap().try_downcast_ref::<u32>();
66    assert_eq!(id, Some(&123));
67
68    // It also enables us to create a representation of a type without having compile-time
69    // access to the actual type. This is how the reflection deserializers work.
70    // They generally can't know how to construct a type ahead of time,
71    // so they instead build and return these dynamic representations.
72    let input = "(id: 123)";
73    let mut registry = TypeRegistry::default();
74    registry.register::<Player>();
75    let registration = registry.get(std::any::TypeId::of::<Player>()).unwrap();
76    let deserialized = TypedReflectDeserializer::new(registration, &registry)
77        .deserialize(&mut ron::Deserializer::from_str(input).unwrap())
78        .unwrap();
79
80    // Our deserialized output is a `DynamicStruct` that proxies/represents a `Player`.
81    assert!(deserialized.represents::<Player>());
82
83    // And while this does allow us to access the fields and structure of the type,
84    // there may be instances where we need the actual type.
85    // For example, if we want to convert our `dyn Reflect` into a `dyn Identifiable`,
86    // we can't use the `DynamicStruct` proxy.
87    let reflect_identifiable = registration
88        .data::<ReflectIdentifiable>()
89        .expect("`ReflectIdentifiable` should be registered");
90
91    // Trying to access the registry with our `deserialized` will give a compile error
92    // since it doesn't implement `Reflect`, only `PartialReflect`.
93    // Similarly, trying to force the operation will fail.
94    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
95    assert!(deserialized
96        .try_as_reflect()
97        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
98        .is_none());
99
100    // So how can we go from a dynamic type to a concrete type?
101    // There are two ways:
102
103    // 1. Using `PartialReflect::apply`.
104    {
105        // If you know the type at compile time, you can construct a new value and apply the dynamic
106        // value to it.
107        let mut value = Player::default();
108        value.apply(deserialized.as_ref());
109        assert_eq!(value.id, 123);
110
111        // If you don't know the type at compile time, you need a dynamic way of constructing
112        // an instance of the type. One such way is to use the `ReflectDefault` type data.
113        let reflect_default = registration
114            .data::<ReflectDefault>()
115            .expect("`ReflectDefault` should be registered");
116
117        let mut value: Box<dyn Reflect> = reflect_default.default();
118        value.apply(deserialized.as_ref());
119
120        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
121        assert_eq!(identifiable.id(), 123);
122    }
123
124    // 2. Using `FromReflect`
125    {
126        // If you know the type at compile time, you can use the `FromReflect` trait to convert the
127        // dynamic value into the concrete type directly.
128        let value: Player = Player::from_reflect(deserialized.as_ref()).unwrap();
129        assert_eq!(value.id, 123);
130
131        // If you don't know the type at compile time, you can use the `ReflectFromReflect` type data
132        // to perform the conversion dynamically.
133        let reflect_from_reflect = registration
134            .data::<ReflectFromReflect>()
135            .expect("`ReflectFromReflect` should be registered");
136
137        let value: Box<dyn Reflect> = reflect_from_reflect
138            .from_reflect(deserialized.as_ref())
139            .unwrap();
140        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
141        assert_eq!(identifiable.id(), 123);
142    }
143
144    // Lastly, while dynamic types are commonly generated via reflection methods like
145    // `PartialReflect::to_dynamic` or via the reflection deserializers,
146    // you can also construct them manually.
147    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);
148
149    // This is useful when you just need to apply some subset of changes to a type.
150    let mut my_list: Vec<u32> = Vec::new();
151    my_list.apply(&my_dynamic_list);
152    assert_eq!(my_list, vec![1, 2, 3]);
153
154    // And if you want it to actually proxy a type, you can configure it to do that as well:
155    assert!(!my_dynamic_list
156        .as_partial_reflect()
157        .represents::<Vec<u32>>());
158    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
159    assert!(my_dynamic_list
160        .as_partial_reflect()
161        .represents::<Vec<u32>>());
162
163    // ============================= REFERENCE ============================= //
164    // For reference, here are all the available dynamic types:
165
166    // 1. `DynamicTuple`
167    {
168        let mut dynamic_tuple = DynamicTuple::default();
169        dynamic_tuple.insert(1u32);
170        dynamic_tuple.insert(2u32);
171        dynamic_tuple.insert(3u32);
172
173        let mut my_tuple: (u32, u32, u32) = (0, 0, 0);
174        my_tuple.apply(&dynamic_tuple);
175        assert_eq!(my_tuple, (1, 2, 3));
176    }
177
178    // 2. `DynamicArray`
179    {
180        let dynamic_array = DynamicArray::from_iter([1u32, 2u32, 3u32]);
181
182        let mut my_array = [0u32; 3];
183        my_array.apply(&dynamic_array);
184        assert_eq!(my_array, [1, 2, 3]);
185    }
186
187    // 3. `DynamicList`
188    {
189        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);
190
191        let mut my_list: Vec<u32> = Vec::new();
192        my_list.apply(&dynamic_list);
193        assert_eq!(my_list, vec![1, 2, 3]);
194    }
195
196    // 4. `DynamicSet`
197    {
198        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
199        assert!(dynamic_set.contains(&"x"));
200
201        dynamic_set.remove(&"y");
202
203        let mut my_set: HashSet<&str> = HashSet::default();
204        my_set.apply(&dynamic_set);
205        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
206    }
207
208    // 5. `DynamicMap`
209    {
210        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);
211
212        let mut my_map: HashMap<&str, u32> = HashMap::default();
213        my_map.apply(&dynamic_map);
214        assert_eq!(my_map.get("x"), Some(&1));
215        assert_eq!(my_map.get("y"), Some(&2));
216        assert_eq!(my_map.get("z"), Some(&3));
217    }
218
219    // 6. `DynamicStruct`
220    {
221        #[derive(Reflect, Default, Debug, PartialEq)]
222        struct MyStruct {
223            x: u32,
224            y: u32,
225            z: u32,
226        }
227
228        let mut dynamic_struct = DynamicStruct::default();
229        dynamic_struct.insert("x", 1u32);
230        dynamic_struct.insert("y", 2u32);
231        dynamic_struct.insert("z", 3u32);
232
233        let mut my_struct = MyStruct::default();
234        my_struct.apply(&dynamic_struct);
235        assert_eq!(my_struct, MyStruct { x: 1, y: 2, z: 3 });
236    }
237
238    // 7. `DynamicTupleStruct`
239    {
240        #[derive(Reflect, Default, Debug, PartialEq)]
241        struct MyTupleStruct(u32, u32, u32);
242
243        let mut dynamic_tuple_struct = DynamicTupleStruct::default();
244        dynamic_tuple_struct.insert(1u32);
245        dynamic_tuple_struct.insert(2u32);
246        dynamic_tuple_struct.insert(3u32);
247
248        let mut my_tuple_struct = MyTupleStruct::default();
249        my_tuple_struct.apply(&dynamic_tuple_struct);
250        assert_eq!(my_tuple_struct, MyTupleStruct(1, 2, 3));
251    }
252
253    // 8. `DynamicEnum`
254    {
255        #[derive(Reflect, Default, Debug, PartialEq)]
256        enum MyEnum {
257            #[default]
258            Empty,
259            Xyz(u32, u32, u32),
260        }
261
262        let mut values = DynamicTuple::default();
263        values.insert(1u32);
264        values.insert(2u32);
265        values.insert(3u32);
266
267        let dynamic_variant = DynamicVariant::Tuple(values);
268        let dynamic_enum = DynamicEnum::new("Xyz", dynamic_variant);
269
270        let mut my_enum = MyEnum::default();
271        my_enum.apply(&dynamic_enum);
272        assert_eq!(my_enum, MyEnum::Xyz(1, 2, 3));
273    }
274}
Source

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>
where T: Any,

Downcasts the value to type T by mutable reference.

If the underlying value is not of type T, returns None.

For remote types, T should be the type itself rather than the wrapper type.

Examples found in repository?
examples/reflection/type_data.rs (line 63)
58        fn from_type() -> Self {
59            Self {
60                damage: |reflect, damage| {
61                    // This requires that `reflect` is `T` and not a dynamic representation like `DynamicStruct`.
62                    // We could have the function pointer return a `Result`, but we'll just `unwrap` for simplicity.
63                    let damageable = reflect.downcast_mut::<T>().unwrap();
64                    let damage = damage.take::<T::Health>().unwrap();
65                    damageable.damage(damage);
66                },
67            }
68        }

Trait Implementations§

Source§

impl Debug for dyn Reflect

Source§

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

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

impl TypePath for dyn Reflect

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 dyn Reflect

Source§

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

Implementations on Foreign Types§

Source§

impl Reflect for &'static str

Source§

fn into_any(self: Box<&'static str>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<&'static str>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for &'static Location<'static>

Source§

fn into_any(self: Box<&'static Location<'static>>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<&'static Location<'static>>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for &'static Path

Source§

fn into_any(self: Box<&'static Path>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<&'static Path>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for Cow<'static, str>

Source§

fn into_any(self: Box<Cow<'static, str>>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<Cow<'static, str>>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for Cow<'static, Path>

Source§

fn into_any(self: Box<Cow<'static, Path>>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<Cow<'static, Path>>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for SocketAddr
where SocketAddr: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for bool
where bool: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for char
where char: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for f32
where f32: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for f64
where f64: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for i8
where i8: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for i16
where i16: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for i32
where i32: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for i64
where i64: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for i128
where i128: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for isize
where isize: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for u8
where u8: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for u16
where u16: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for u32
where u32: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for u64
where u64: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for u128
where u128: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for ()

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for usize
where usize: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for TypeId
where TypeId: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NonZero<i8>
where NonZero<i8>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NonZero<i16>
where NonZero<i16>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NonZero<i32>
where NonZero<i32>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NonZero<i64>
where NonZero<i64>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NonZero<i128>
where NonZero<i128>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NonZero<isize>
where NonZero<isize>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NonZero<u8>
where NonZero<u8>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NonZero<u16>
where NonZero<u16>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NonZero<u32>
where NonZero<u32>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NonZero<u64>
where NonZero<u64>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NonZero<u128>
where NonZero<u128>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NonZero<usize>
where NonZero<usize>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for RangeFull
where RangeFull: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for Duration
where Duration: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for OsString
where OsString: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for PathBuf
where PathBuf: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for NodeIndex
where NodeIndex: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Reflect for SmolStr
where SmolStr: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<A> Reflect for (A,)
where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<A, B> Reflect for (A, B)
where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<(A, B)>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<(A, B)>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<A, B, C> Reflect for (A, B, C)
where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<(A, B, C)>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<(A, B, C)>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<A, B, C, D> Reflect for (A, B, C, D)
where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<(A, B, C, D)>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<(A, B, C, D)>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<A, B, C, D, E> Reflect for (A, B, C, D, E)
where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<(A, B, C, D, E)>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<(A, B, C, D, E)>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<A, B, C, D, E, F> Reflect for (A, B, C, D, E, F)
where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<(A, B, C, D, E, F)>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<(A, B, C, D, E, F)>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<A, B, C, D, E, F, G> Reflect for (A, B, C, D, E, F, G)
where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<(A, B, C, D, E, F, G)>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<(A, B, C, D, E, F, G)>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<A, B, C, D, E, F, G, H> Reflect for (A, B, C, D, E, F, G, H)
where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<(A, B, C, D, E, F, G, H)>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<(A, B, C, D, E, F, G, H)>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<A, B, C, D, E, F, G, H, I> Reflect for (A, B, C, D, E, F, G, H, I)
where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration, I: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<(A, B, C, D, E, F, G, H, I)>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<(A, B, C, D, E, F, G, H, I)>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<A, B, C, D, E, F, G, H, I, J> Reflect for (A, B, C, D, E, F, G, H, I, J)
where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration, I: Reflect + MaybeTyped + TypePath + GetTypeRegistration, J: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<(A, B, C, D, E, F, G, H, I, J)>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<(A, B, C, D, E, F, G, H, I, J)>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<A, B, C, D, E, F, G, H, I, J, K> Reflect for (A, B, C, D, E, F, G, H, I, J, K)
where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration, I: Reflect + MaybeTyped + TypePath + GetTypeRegistration, J: Reflect + MaybeTyped + TypePath + GetTypeRegistration, K: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<(A, B, C, D, E, F, G, H, I, J, K)>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect( self: Box<(A, B, C, D, E, F, G, H, I, J, K)>, ) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L> Reflect for (A, B, C, D, E, F, G, H, I, J, K, L)
where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration, I: Reflect + MaybeTyped + TypePath + GetTypeRegistration, J: Reflect + MaybeTyped + TypePath + GetTypeRegistration, K: Reflect + MaybeTyped + TypePath + GetTypeRegistration, L: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<(A, B, C, D, E, F, G, H, I, J, K, L)>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect( self: Box<(A, B, C, D, E, F, G, H, I, J, K, L)>, ) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<K, V> Reflect for BTreeMap<K, V>
where K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Ord, V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<BTreeMap<K, V>>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<BTreeMap<K, V>>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<K, V, S> Reflect for HashMap<K, V, S>

Source§

fn into_any(self: Box<HashMap<K, V, S>>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<HashMap<K, V, S>>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<N, E, Ix> Reflect for Graph<N, E, Directed, Ix>
where N: Clone + TypePath, E: Clone + TypePath, Ix: IndexType + TypePath, Graph<N, E, Directed, Ix>: Any + Send + Sync,

Source§

fn into_any(self: Box<Graph<N, E, Directed, Ix>>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<Graph<N, E, Directed, Ix>>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for Cow<'static, [T]>
where T: FromReflect + Clone + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<Cow<'static, [T]>>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<Cow<'static, [T]>>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for Bound<T>
where T: Clone + Send + Sync + TypePath, Bound<T>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for Option<T>
where Option<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for BinaryHeap<T>
where T: Clone + TypePath, BinaryHeap<T>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for BTreeSet<T>
where T: Ord + Eq + Clone + Send + Sync + TypePath, BTreeSet<T>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for VecDeque<T>
where T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for Saturating<T>
where T: Clone + Send + Sync + TypePath, Saturating<T>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for Wrapping<T>
where T: Clone + Send + Sync + TypePath, Wrapping<T>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for Range<T>
where T: Clone + Send + Sync + TypePath, Range<T>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for RangeFrom<T>
where T: Clone + Send + Sync + TypePath, RangeFrom<T>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for RangeInclusive<T>
where T: Clone + Send + Sync + TypePath, RangeInclusive<T>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for RangeTo<T>
where T: Clone + Send + Sync + TypePath, RangeTo<T>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for RangeToInclusive<T>
where T: Clone + Send + Sync + TypePath, RangeToInclusive<T>: Any + Send + Sync,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Reflect for SmallVec<T>
where T: Array + TypePath + Send + Sync, <T as Array>::Item: FromReflect + MaybeTyped + TypePath,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T, E> Reflect for Result<T, E>
where Result<T, E>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection, E: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

Source§

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

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<Result<T, E>>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<T, const N: usize> Reflect for [T; N]
where T: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

fn into_any(self: Box<[T; N]>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<[T; N]>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Source§

impl<V, S> Reflect for HashSet<V, S>

Source§

fn into_any(self: Box<HashSet<V, S>>) -> Box<dyn Any>

Source§

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

Source§

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

Source§

fn into_reflect(self: Box<HashSet<V, S>>) -> Box<dyn Reflect>

Source§

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

Source§

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

Source§

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

Implementors§

Source§

impl Reflect for AccessibilitySystem

Source§

impl Reflect for RepeatAnimation
where RepeatAnimation: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for bevy::animation::gltf_curves::WeightsCurve
where WeightsCurve: Any + Send + Sync, ConstantCurve<Vec<f32>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WideLinearKeyframeCurve<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WideSteppedKeyframeCurve<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WideCubicKeyframeCurve<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PlaybackMode

Source§

impl Reflect for Volume
where Volume: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BloomCompositeMode

Source§

impl Reflect for Camera3dDepthLoadOp
where Camera3dDepthLoadOp: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ScreenSpaceTransmissionQuality

Source§

impl Reflect for DepthOfFieldMode

Source§

impl Reflect for Sensitivity
where Sensitivity: Any + Send + Sync,

Source§

impl Reflect for SmaaPreset
where SmaaPreset: Any + Send + Sync,

Source§

impl Reflect for DebandDither

Source§

impl Reflect for Tonemapping
where Tonemapping: Any + Send + Sync,

Source§

impl Reflect for ButtonState
where ButtonState: Any + Send + Sync,

Source§

impl Reflect for GamepadConnection
where GamepadConnection: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<u16>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GamepadEvent
where GamepadEvent: Any + Send + Sync, GamepadConnectionEvent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadButtonChangedEvent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadAxisChangedEvent: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GamepadInput
where GamepadInput: Any + Send + Sync, GamepadAxis: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GamepadRumbleRequest
where GamepadRumbleRequest: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadRumbleIntensity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RawGamepadEvent
where RawGamepadEvent: Any + Send + Sync, GamepadConnectionEvent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RawGamepadButtonChangedEvent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RawGamepadAxisChangedEvent: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Key
where Key: Any + Send + Sync, SmolStr: FromReflect + TypePath + MaybeTyped + RegisterForReflection, NativeKey: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<char>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for NativeKey
where NativeKey: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SmolStr: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for NativeKeyCode
where NativeKeyCode: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MouseScrollUnit

Source§

impl Reflect for ForceTouch
where ForceTouch: Any + Send + Sync, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<f64>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TouchPhase
where TouchPhase: Any + Send + Sync,

Source§

impl Reflect for CompassOctant

Source§

impl Reflect for CompassQuadrant

Source§

impl Reflect for ClusterConfig
where ClusterConfig: Any + Send + Sync, UVec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ClusterZConfig: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ClusterFarZMode
where ClusterFarZMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for OpaqueRendererMethod

Source§

impl Reflect for ScreenSpaceAmbientOcclusionQualityLevel
where ScreenSpaceAmbientOcclusionQualityLevel: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ShadowFilteringMethod

Source§

impl Reflect for UvChannel
where UvChannel: Any + Send + Sync,

Source§

impl Reflect for PickingInteraction

Source§

impl Reflect for Backfaces
where Backfaces: Any + Send + Sync,

Source§

impl Reflect for PointerAction
where PointerAction: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MouseScrollUnit: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PointerId
where PointerId: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Uuid: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PressDirection

Source§

impl Reflect for AlignContent

Source§

impl Reflect for AlignItems
where AlignItems: Any + Send + Sync,

Source§

impl Reflect for AlignSelf
where AlignSelf: Any + Send + Sync,

Source§

impl Reflect for AlphaMode
where AlphaMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AnimationNodeType
where AnimationNodeType: Any + Send + Sync, Handle<AnimationClip>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BoxSizing
where BoxSizing: Any + Send + Sync,

Source§

impl Reflect for ClearColorConfig
where ClearColorConfig: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Color
where Color: Any + Send + Sync, Srgba: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LinearRgba: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Hsla: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Hsva: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Hwba: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Laba: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Lcha: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Oklaba: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Oklcha: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Xyza: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Display
where Display: Any + Send + Sync,

Source§

impl Reflect for EaseFunction
where EaseFunction: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, JumpAt: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for EulerRot
where EulerRot: Any + Send + Sync,

Source§

impl Reflect for FileDragAndDrop
where FileDragAndDrop: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PathBuf: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for FlexDirection

Source§

impl Reflect for FlexWrap
where FlexWrap: Any + Send + Sync,

Source§

impl Reflect for FogFalloff
where FogFalloff: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GamepadAxis
where GamepadAxis: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GamepadButton
where GamepadButton: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GizmoLineJoint
where GizmoLineJoint: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GizmoLineStyle
where GizmoLineStyle: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GridAutoFlow

Source§

impl Reflect for GridTrackRepetition
where GridTrackRepetition: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Ime
where Ime: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<(usize, usize)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Interaction
where Interaction: Any + Send + Sync,

Source§

impl Reflect for JumpAt
where JumpAt: Any + Send + Sync,

Source§

impl Reflect for JustifyContent

Source§

impl Reflect for JustifyItems

Source§

impl Reflect for JustifySelf
where JustifySelf: Any + Send + Sync,

Source§

impl Reflect for JustifyText
where JustifyText: Any + Send + Sync,

Source§

impl Reflect for KeyCode
where KeyCode: Any + Send + Sync, NativeKeyCode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for LightGizmoColor
where LightGizmoColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for LineBreak
where LineBreak: Any + Send + Sync,

Source§

impl Reflect for MaxTrackSizingFunction
where MaxTrackSizingFunction: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MinTrackSizingFunction
where MinTrackSizingFunction: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MonitorSelection
where MonitorSelection: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MouseButton
where MouseButton: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Msaa
where Msaa: Any + Send + Sync,

Source§

impl Reflect for NodeImageMode
where NodeImageMode: Any + Send + Sync, TextureSlicer: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for OverflowAxis

Source§

impl Reflect for OverflowClipBox

Source§

impl Reflect for ParallaxMappingMethod
where ParallaxMappingMethod: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PointerButton

Source§

impl Reflect for PositionType

Source§

impl Reflect for Projection
where Projection: Any + Send + Sync, PerspectiveProjection: FromReflect + TypePath + MaybeTyped + RegisterForReflection, OrthographicProjection: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CustomProjection: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RayCastVisibility

Source§

impl Reflect for bevy::prelude::ScalingMode
where ScalingMode: Any + Send + Sync,

Source§

impl Reflect for SliceScaleMode
where SliceScaleMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SpriteImageMode
where SpriteImageMode: Any + Send + Sync, ScalingMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TextureSlicer: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SpritePickingMode
where SpritePickingMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TimerMode
where TimerMode: Any + Send + Sync,

Source§

impl Reflect for UiAntiAlias
where UiAntiAlias: Any + Send + Sync,

Source§

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

Source§

impl Reflect for VideoModeSelection
where VideoModeSelection: Any + Send + Sync, VideoMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Visibility
where Visibility: Any + Send + Sync,

Source§

impl Reflect for WindowPosition
where WindowPosition: Any + Send + Sync, MonitorSelection: FromReflect + TypePath + MaybeTyped + RegisterForReflection, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for NormalizedRenderTarget
where NormalizedRenderTarget: Any + Send + Sync, NormalizedWindowRef: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ImageRenderTarget: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ManualTextureViewHandle: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RenderTarget
where RenderTarget: Any + Send + Sync, WindowRef: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ImageRenderTarget: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ManualTextureViewHandle: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for bevy::render::camera::ScalingMode
where ScalingMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CapsuleUvProfile

Source§

impl Reflect for CircularMeshUvMode
where CircularMeshUvMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ConeAnchor
where ConeAnchor: Any + Send + Sync,

Source§

impl Reflect for CylinderAnchor

Source§

impl Reflect for Indices
where Indices: Any + Send + Sync, Vec<u16>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<u32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SphereKind
where SphereKind: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AlphaMode2d
where AlphaMode2d: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Anchor
where Anchor: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for FontSmoothing

Source§

impl Reflect for LineHeight
where LineHeight: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for FocusPolicy
where FocusPolicy: Any + Send + Sync,

Source§

impl Reflect for AppLifecycle

Source§

impl Reflect for CompositeAlphaMode

Source§

impl Reflect for CursorGrabMode

Source§

impl Reflect for PresentMode
where PresentMode: Any + Send + Sync,

Source§

impl Reflect for SystemCursorIcon

Source§

impl Reflect for WindowEvent
where WindowEvent: Any + Send + Sync, AppLifecycle: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CursorEntered: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CursorLeft: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CursorMoved: FromReflect + TypePath + MaybeTyped + RegisterForReflection, FileDragAndDrop: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Ime: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RequestRedraw: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowBackendScaleFactorChanged: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowCloseRequested: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowCreated: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowDestroyed: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowFocused: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowMoved: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowOccluded: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowResized: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowScaleFactorChanged: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowThemeChanged: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MouseButtonInput: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MouseMotion: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MouseWheel: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PinchGesture: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RotationGesture: FromReflect + TypePath + MaybeTyped + RegisterForReflection, DoubleTapGesture: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PanGesture: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TouchInput: FromReflect + TypePath + MaybeTyped + RegisterForReflection, KeyboardInput: FromReflect + TypePath + MaybeTyped + RegisterForReflection, KeyboardFocusLost: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowLevel
where WindowLevel: Any + Send + Sync,

Source§

impl Reflect for WindowMode
where WindowMode: Any + Send + Sync, MonitorSelection: FromReflect + TypePath + MaybeTyped + RegisterForReflection, VideoModeSelection: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowRef
where WindowRef: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowTheme
where WindowTheme: Any + Send + Sync,

Source§

impl Reflect for CursorIcon
where CursorIcon: Any + Send + Sync, CustomCursor: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SystemCursorIcon: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CustomCursor
where CustomCursor: Any + Send + Sync, CustomCursorImage: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AccessibilityRequested
where AccessibilityRequested: Any + Send + Sync, Arc<AtomicBool>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ManageAccessibilityUpdates
where ManageAccessibilityUpdates: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CubicRotationCurve
where CubicRotationCurve: Any + Send + Sync, ChunkedUnevenCore<Vec4>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ActiveAnimation
where ActiveAnimation: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RepeatAnimation: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AnimationTarget
where AnimationTarget: Any + Send + Sync, AnimationTargetId: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AnimationTargetId
where AnimationTargetId: Any + Send + Sync, Uuid: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AssetIndex
where AssetIndex: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RenderAssetUsages

Source§

impl Reflect for Uuid
where Uuid: Any + Send + Sync,

Source§

impl Reflect for DefaultSpatialScale
where DefaultSpatialScale: Any + Send + Sync, SpatialScale: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SpatialScale
where SpatialScale: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AutoExposure
where AutoExposure: Any + Send + Sync, RangeInclusive<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Handle<AutoExposureCompensationCurve>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AutoExposureCompensationCurve
where AutoExposureCompensationCurve: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, [u8; 256]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Bloom
where Bloom: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, BloomPrefilter: FromReflect + TypePath + MaybeTyped + RegisterForReflection, BloomCompositeMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BloomPrefilter
where BloomPrefilter: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ContrastAdaptiveSharpening
where ContrastAdaptiveSharpening: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DenoiseCas
where DenoiseCas: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Camera3dDepthTextureUsage
where Camera3dDepthTextureUsage: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DepthOfField
where DepthOfField: Any + Send + Sync, DepthOfFieldMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TemporalAntiAliasing
where TemporalAntiAliasing: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Fxaa
where Fxaa: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Sensitivity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MotionBlur
where MotionBlur: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for OrderIndependentTransparencySettings
where OrderIndependentTransparencySettings: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ChromaticAberration
where ChromaticAberration: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DeferredPrepass

Source§

impl Reflect for DepthPrepass

Source§

impl Reflect for MotionVectorPrepass

Source§

impl Reflect for NormalPrepass

Source§

impl Reflect for Smaa
where Smaa: Any + Send + Sync, SmaaPreset: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Skybox
where Skybox: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ComponentId
where ComponentId: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ComponentTicks
where ComponentTicks: Any + Send + Sync, Tick: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Tick
where Tick: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for EntityHash
where EntityHash: Any + Send + Sync,

Source§

impl Reflect for EntityHashSet
where EntityHashSet: Any + Send + Sync, HashSet<Entity, EntityHash>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DefaultQueryFilters
where DefaultQueryFilters: Any + Send + Sync, SmallVec<[ComponentId; 4]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Disabled
where Disabled: Any + Send + Sync,

Source§

impl Reflect for Identifier
where Identifier: Any + Send + Sync,

Source§

impl Reflect for RemovedComponentEntity
where RemovedComponentEntity: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SystemIdMarker

Source§

impl Reflect for OnDespawn
where OnDespawn: Any + Send + Sync,

Source§

impl Reflect for ErasedGizmoConfigGroup

Source§

impl Reflect for GltfMaterialExtras
where GltfMaterialExtras: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GltfMaterialName
where GltfMaterialName: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GltfMeshExtras
where GltfMeshExtras: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GltfSceneExtras
where GltfSceneExtras: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AxisSettings
where AxisSettings: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ButtonAxisSettings
where ButtonAxisSettings: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ButtonSettings
where ButtonSettings: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GamepadAxisChangedEvent
where GamepadAxisChangedEvent: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadAxis: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GamepadButtonChangedEvent
where GamepadButtonChangedEvent: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ButtonState: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GamepadButtonStateChangedEvent
where GamepadButtonStateChangedEvent: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ButtonState: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GamepadConnectionEvent
where GamepadConnectionEvent: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadConnection: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GamepadRumbleIntensity
where GamepadRumbleIntensity: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RawGamepadAxisChangedEvent
where RawGamepadAxisChangedEvent: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadAxis: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RawGamepadButtonChangedEvent
where RawGamepadButtonChangedEvent: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DoubleTapGesture

Source§

impl Reflect for PanGesture
where PanGesture: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PinchGesture
where PinchGesture: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RotationGesture
where RotationGesture: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for KeyboardFocusLost

Source§

impl Reflect for KeyboardInput
where KeyboardInput: Any + Send + Sync, KeyCode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Key: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ButtonState: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<SmolStr>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AccumulatedMouseMotion
where AccumulatedMouseMotion: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AccumulatedMouseScroll
where AccumulatedMouseScroll: Any + Send + Sync, MouseScrollUnit: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MouseButtonInput
where MouseButtonInput: Any + Send + Sync, MouseButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ButtonState: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MouseMotion
where MouseMotion: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MouseWheel
where MouseWheel: Any + Send + Sync, MouseScrollUnit: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DirectionalNavigationMap
where DirectionalNavigationMap: Any + Send + Sync, EntityHashMap<NavNeighbors>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for NavNeighbors
where NavNeighbors: Any + Send + Sync, [Option<Entity>; 8]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AutoFocus
where AutoFocus: Any + Send + Sync,

Source§

impl Reflect for InputFocus
where InputFocus: Any + Send + Sync, Option<Entity>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for InputFocusVisible
where InputFocusVisible: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TabGroup
where TabGroup: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TabIndex
where TabIndex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Aabb2d
where Aabb2d: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Aabb3d
where Aabb3d: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AabbCast2d
where AabbCast2d: Any + Send + Sync, RayCast2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Aabb2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AabbCast3d
where AabbCast3d: Any + Send + Sync, RayCast3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Aabb3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BoundingCircle
where BoundingCircle: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Circle: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BoundingCircleCast
where BoundingCircleCast: Any + Send + Sync, RayCast2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, BoundingCircle: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BoundingSphere
where BoundingSphere: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Sphere: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BoundingSphereCast
where BoundingSphereCast: Any + Send + Sync, RayCast3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, BoundingSphere: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RayCast2d
where RayCast2d: Any + Send + Sync, Ray2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RayCast3d
where RayCast3d: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Dir3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Affine2
where Affine2: Any + Send + Sync, Mat2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Affine3
where Affine3: Any + Send + Sync, Mat3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Affine3A
where Affine3A: Any + Send + Sync, Mat3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AspectRatio
where AspectRatio: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DAffine2
where DAffine2: Any + Send + Sync, DMat2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, DVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DAffine3
where DAffine3: Any + Send + Sync, DMat3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, DVec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DMat2
where DMat2: Any + Send + Sync, DVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DMat3
where DMat3: Any + Send + Sync, DVec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DMat4
where DMat4: Any + Send + Sync, DVec4: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DQuat
where DQuat: Any + Send + Sync, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DVec2
where DVec2: Any + Send + Sync, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DVec3
where DVec3: Any + Send + Sync, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DVec4
where DVec4: Any + Send + Sync, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for FloatOrd
where FloatOrd: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for I8Vec2
where I8Vec2: Any + Send + Sync, i8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for I8Vec3
where I8Vec3: Any + Send + Sync, i8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for I8Vec4
where I8Vec4: Any + Send + Sync, i8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for I16Vec2
where I16Vec2: Any + Send + Sync, i16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for I16Vec3
where I16Vec3: Any + Send + Sync, i16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for I16Vec4
where I16Vec4: Any + Send + Sync, i16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for I64Vec2
where I64Vec2: Any + Send + Sync, i64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for I64Vec3
where I64Vec3: Any + Send + Sync, i64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for I64Vec4
where I64Vec4: Any + Send + Sync, i64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for U8Vec2
where U8Vec2: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for U8Vec3
where U8Vec3: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for U8Vec4
where U8Vec4: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for U16Vec2
where U16Vec2: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for U16Vec3
where U16Vec3: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for U16Vec4
where U16Vec4: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for U64Vec2
where U64Vec2: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for U64Vec3
where U64Vec3: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for U64Vec4
where U64Vec4: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ClusteredDecal
where ClusteredDecal: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ForwardDecal

Source§

impl Reflect for MeshletMesh3d
where MeshletMesh3d: Any + Send + Sync, Handle<MeshletMesh>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for IrradianceVolume
where IrradianceVolume: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Atmosphere
where Atmosphere: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AtmosphereSettings
where AtmosphereSettings: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, UVec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Cascade
where Cascade: Any + Send + Sync, Mat4: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CascadeShadowConfig
where CascadeShadowConfig: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Cascades
where Cascades: Any + Send + Sync, EntityHashMap<Vec<Cascade>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CascadesVisibleEntities

Source§

impl Reflect for ClusterZConfig
where ClusterZConfig: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ClusterFarZMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CubemapVisibleEntities

Source§

impl Reflect for DefaultOpaqueRendererMethod
where DefaultOpaqueRendererMethod: Any + Send + Sync, OpaqueRendererMethod: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DirectionalLightShadowMap
where DirectionalLightShadowMap: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for FogVolume
where FogVolume: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Handle<Image>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Lightmap
where Lightmap: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Rect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MaterialBindGroupIndex
where MaterialBindGroupIndex: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MaterialBindGroupSlot
where MaterialBindGroupSlot: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MaterialBindingId
where MaterialBindingId: Any + Send + Sync, MaterialBindGroupIndex: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MaterialBindGroupSlot: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for NotShadowCaster

Source§

impl Reflect for NotShadowReceiver

Source§

impl Reflect for PointLightShadowMap
where PointLightShadowMap: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RenderCascadesVisibleEntities

Source§

impl Reflect for RenderCubemapVisibleEntities

Source§

impl Reflect for RenderVisibleMeshEntities

Source§

impl Reflect for ScreenSpaceAmbientOcclusion
where ScreenSpaceAmbientOcclusion: Any + Send + Sync, ScreenSpaceAmbientOcclusionQualityLevel: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ScreenSpaceReflections
where ScreenSpaceReflections: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TransmittedShadowReceiver

Source§

impl Reflect for VisibleMeshEntities

Source§

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

Source§

impl Reflect for VolumetricLight

Source§

impl Reflect for Mesh3dWireframe
where Mesh3dWireframe: Any + Send + Sync, Handle<WireframeMaterial>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for NoWireframe
where NoWireframe: Any + Send + Sync,

Source§

impl Reflect for Wireframe
where Wireframe: Any + Send + Sync,

Source§

impl Reflect for WireframeColor
where WireframeColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WireframeConfig
where WireframeConfig: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WireframeMaterial
where WireframeMaterial: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RayId
where RayId: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PointerId: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for HitData
where HitData: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec3>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PointerHits
where PointerHits: Any + Send + Sync, PointerId: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<(Entity, HitData)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RayMeshHit
where RayMeshHit: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<[Vec3; 3]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<usize>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SimplifiedMesh
where SimplifiedMesh: Any + Send + Sync, Handle<Mesh>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for bevy::picking::pointer::Location
where Location: Any + Send + Sync, NormalizedRenderTarget: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PointerInput
where PointerInput: Any + Send + Sync, PointerId: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Location: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PointerAction: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PointerInteraction
where PointerInteraction: Any + Send + Sync, Vec<(Entity, HitData)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PointerLocation

Source§

impl Reflect for PointerPress
where PointerPress: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AtomicBool
where AtomicBool: Any + Send + Sync,

Source§

impl Reflect for AtomicI8
where AtomicI8: Any + Send + Sync,

Source§

impl Reflect for AtomicI16
where AtomicI16: Any + Send + Sync,

Source§

impl Reflect for AtomicI32
where AtomicI32: Any + Send + Sync,

Source§

impl Reflect for AtomicI64
where AtomicI64: Any + Send + Sync,

Source§

impl Reflect for AtomicIsize
where AtomicIsize: Any + Send + Sync,

Source§

impl Reflect for AtomicU8
where AtomicU8: Any + Send + Sync,

Source§

impl Reflect for AtomicU16
where AtomicU16: Any + Send + Sync,

Source§

impl Reflect for AtomicU32
where AtomicU32: Any + Send + Sync,

Source§

impl Reflect for AtomicU64
where AtomicU64: Any + Send + Sync,

Source§

impl Reflect for AtomicUsize
where AtomicUsize: Any + Send + Sync,

Source§

impl Reflect for Instant
where Instant: Any + Send + Sync,

Source§

impl Reflect for AabbGizmoConfigGroup
where AabbGizmoConfigGroup: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Color>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

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

Source§

impl Reflect for AnimationClip
where AnimationClip: Any + Send + Sync, HashMap<AnimationEventTarget, Vec<TimedAnimationEvent>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AnimationGraph
where AnimationGraph: Any + Send + Sync, Graph<AnimationGraphNode, ()>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, NodeIndex: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HashMap<AnimationTargetId, u64>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AnimationGraphHandle
where AnimationGraphHandle: Any + Send + Sync, Handle<AnimationGraph>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AnimationGraphNode
where AnimationGraphNode: Any + Send + Sync, AnimationNodeType: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AnimationPlayer
where AnimationPlayer: Any + Send + Sync, HashMap<NodeIndex, ActiveAnimation>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HashMap<NodeIndex, f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AnimationTransition
where AnimationTransition: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, NodeIndex: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AnimationTransitions
where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Annulus
where Annulus: Any + Send + Sync, Circle: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Arc2d
where Arc2d: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BVec2
where BVec2: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BVec3
where BVec3: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BVec3A
where BVec3A: Any + Send + Sync,

Source§

impl Reflect for BVec4
where BVec4: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BVec4A
where BVec4A: Any + Send + Sync,

Source§

impl Reflect for BackgroundColor
where BackgroundColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BorderColor
where BorderColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BorderRadius
where BorderRadius: Any + Send + Sync, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BorderRect
where BorderRect: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BoxShadow
where BoxShadow: Any + Send + Sync, Vec<ShadowStyle>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for BoxShadowSamples
where BoxShadowSamples: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Button
where Button: Any + Send + Sync,

Source§

impl Reflect for CalculatedClip
where CalculatedClip: Any + Send + Sync, Rect: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Camera2d
where Camera2d: Any + Send + Sync,

Source§

impl Reflect for Camera3d
where Camera3d: Any + Send + Sync, Camera3dDepthLoadOp: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Camera3dDepthTextureUsage: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ScreenSpaceTransmissionQuality: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Camera
where Camera: Any + Send + Sync, Option<Viewport>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, isize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RenderTarget: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ClearColorConfig: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<SubCameraView>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Cancel
where Cancel: Any + Send + Sync, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Capsule2d
where Capsule2d: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Capsule3d
where Capsule3d: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ChildOf
where ChildOf: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Children
where Children: Any + Send + Sync, Vec<Entity>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Circle
where Circle: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CircularSector
where CircularSector: Any + Send + Sync, Arc2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CircularSegment
where CircularSegment: Any + Send + Sync, Arc2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ClearColor
where ClearColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Click
where Click: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ColorMaterial
where ColorMaterial: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AlphaMode2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Affine2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Handle<Image>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ComputedNode
where ComputedNode: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, BorderRect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ResolvedBorderRadius: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ComputedNodeTarget
where ComputedNodeTarget: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Cone
where Cone: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ConicalFrustum
where ConicalFrustum: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Cuboid
where Cuboid: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CursorEntered
where CursorEntered: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CursorLeft
where CursorLeft: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CursorMoved
where CursorMoved: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec2>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Cylinder
where Cylinder: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DefaultGizmoConfigGroup

Source§

impl Reflect for Dir2
where Dir2: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Dir3
where Dir3: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Dir3A
where Dir3A: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DirectionalLight
where DirectionalLight: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

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

Source§

impl Reflect for Drag
where Drag: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DragDrop
where DragDrop: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DragEnd
where DragEnd: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DragEnter
where DragEnter: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DragEntry
where DragEntry: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DragLeave
where DragLeave: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DragOver
where DragOver: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DragStart
where DragStart: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Ellipse
where Ellipse: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Entity
where Entity: Any + Send + Sync,

Source§

impl Reflect for EnvironmentMapLight
where EnvironmentMapLight: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Fixed
where Fixed: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Gamepad
where Gamepad: Any + Send + Sync, Option<u16>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ButtonInput<GamepadButton>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Axis<GamepadInput>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GamepadSettings
where GamepadSettings: Any + Send + Sync, ButtonSettings: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AxisSettings: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ButtonAxisSettings: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HashMap<GamepadButton, ButtonSettings>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HashMap<GamepadAxis, AxisSettings>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HashMap<GamepadButton, ButtonAxisSettings>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Gizmo
where Gizmo: Any + Send + Sync, Handle<GizmoAsset>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GizmoLineConfig: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GizmoConfig
where GizmoConfig: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GizmoLineConfig: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RenderLayers: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GizmoConfigStore

Source§

impl Reflect for GizmoLineConfig
where GizmoLineConfig: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GizmoLineStyle: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GizmoLineJoint: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GlobalVolume
where GlobalVolume: Any + Send + Sync, Volume: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GlobalZIndex
where GlobalZIndex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GltfExtras
where GltfExtras: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GridPlacement
where GridPlacement: Any + Send + Sync, Option<NonZero<i16>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<NonZero<u16>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GridTrack
where GridTrack: Any + Send + Sync, MinTrackSizingFunction: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MaxTrackSizingFunction: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Hsla
where Hsla: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Hsva
where Hsva: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Hwba
where Hwba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for IRect
where IRect: Any + Send + Sync, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for IVec2
where IVec2: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for IVec3
where IVec3: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for IVec4
where IVec4: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Image
where Image: Any + Send + Sync,

Source§

impl Reflect for ImageNode
where ImageNode: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<TextureAtlas>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Rect>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, NodeImageMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for InfinitePlane3d
where InfinitePlane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for InheritedVisibility
where InheritedVisibility: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Interval
where Interval: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Isometry2d
where Isometry2d: Any + Send + Sync, Rot2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Isometry3d
where Isometry3d: Any + Send + Sync, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Laba
where Laba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Label
where Label: Any + Send + Sync,

Source§

impl Reflect for LayoutConfig
where LayoutConfig: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Lcha
where Lcha: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for LightGizmoConfigGroup
where LightGizmoConfigGroup: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LightGizmoColor: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for LightProbe
where LightProbe: Any + Send + Sync,

Source§

impl Reflect for Line2d
where Line2d: Any + Send + Sync, Dir2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Line3d
where Line3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for LinearRgba
where LinearRgba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Mat2
where Mat2: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Mat3
where Mat3: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Mat3A
where Mat3A: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Mat4
where Mat4: Any + Send + Sync, Vec4: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Mesh2d
where Mesh2d: Any + Send + Sync, Handle<Mesh>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Mesh3d
where Mesh3d: Any + Send + Sync, Handle<Mesh>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Mesh
where Mesh: Any + Send + Sync, Option<Indices>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Handle<Image>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec<String>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RenderAssetUsages: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MeshPickingCamera

Source§

impl Reflect for MeshPickingSettings
where MeshPickingSettings: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RayCastVisibility: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MorphWeights
where MorphWeights: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Handle<Mesh>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Move
where Move: Any + Send + Sync, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Name
where Name: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Cow<'static, str>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Node
where Node: Any + Send + Sync, Display: FromReflect + TypePath + MaybeTyped + RegisterForReflection, BoxSizing: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PositionType: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Overflow: FromReflect + TypePath + MaybeTyped + RegisterForReflection, OverflowClipMargin: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AlignItems: FromReflect + TypePath + MaybeTyped + RegisterForReflection, JustifyItems: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AlignSelf: FromReflect + TypePath + MaybeTyped + RegisterForReflection, JustifySelf: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AlignContent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, JustifyContent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, UiRect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, FlexDirection: FromReflect + TypePath + MaybeTyped + RegisterForReflection, FlexWrap: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GridAutoFlow: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<RepeatedGridTrack>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<GridTrack>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GridPlacement: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Oklaba
where Oklaba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Oklcha
where Oklcha: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for OnAdd
where OnAdd: Any + Send + Sync,

Source§

impl Reflect for OnInsert
where OnInsert: Any + Send + Sync,

Source§

impl Reflect for OnRemove
where OnRemove: Any + Send + Sync,

Source§

impl Reflect for OnReplace
where OnReplace: Any + Send + Sync,

Source§

impl Reflect for OrthographicProjection
where OrthographicProjection: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ScalingMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Rect: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Out
where Out: Any + Send + Sync, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

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

Source§

impl Reflect for Over
where Over: Any + Send + Sync, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Overflow
where Overflow: Any + Send + Sync, OverflowAxis: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for OverflowClipMargin
where OverflowClipMargin: Any + Send + Sync, OverflowClipBox: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PerspectiveProjection
where PerspectiveProjection: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Pickable
where Pickable: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PickingPlugin
where PickingPlugin: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Plane2d
where Plane2d: Any + Send + Sync, Dir2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Plane3d
where Plane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PlaybackSettings
where PlaybackSettings: Any + Send + Sync, PlaybackMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Volume: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<SpatialScale>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

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

Source§

impl Reflect for PointerInputPlugin
where PointerInputPlugin: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Pressed
where Pressed: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Quat
where Quat: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Ray2d
where Ray2d: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Dir2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Ray3d
where Ray3d: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RayCastBackfaces

Source§

impl Reflect for Real
where Real: Any + Send + Sync, Instant: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Instant>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Rect
where Rect: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Rectangle
where Rectangle: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RegularPolygon
where RegularPolygon: Any + Send + Sync, Circle: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Released
where Released: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RepeatedGridTrack
where RepeatedGridTrack: Any + Send + Sync, GridTrackRepetition: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SmallVec<[GridTrack; 1]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ResolvedBorderRadius
where ResolvedBorderRadius: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Rhombus
where Rhombus: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Rot2
where Rot2: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SceneRoot
where SceneRoot: Any + Send + Sync, Handle<Scene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Scroll
where Scroll: Any + Send + Sync, MouseScrollUnit: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ScrollPosition
where ScrollPosition: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Segment2d
where Segment2d: Any + Send + Sync, [Vec2; 2]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Segment3d
where Segment3d: Any + Send + Sync, [Vec3; 2]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

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

Source§

impl Reflect for ShowAabbGizmo
where ShowAabbGizmo: Any + Send + Sync, Option<Color>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ShowLightGizmo
where ShowLightGizmo: Any + Send + Sync, Option<LightGizmoColor>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SpatialListener
where SpatialListener: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Sphere
where Sphere: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

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

Source§

impl Reflect for Sprite
where Sprite: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<TextureAtlas>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec2>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Rect>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Anchor: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SpriteImageMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SpritePickingCamera

Source§

impl Reflect for SpritePickingSettings
where SpritePickingSettings: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SpritePickingMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Srgba
where Srgba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for StandardMaterial
where StandardMaterial: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, UvChannel: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Handle<Image>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LinearRgba: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AlphaMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ParallaxMappingMethod: FromReflect + TypePath + MaybeTyped + RegisterForReflection, OpaqueRendererMethod: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Affine2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for String
where String: Any + Send + Sync,

Source§

impl Reflect for Tetrahedron
where Tetrahedron: Any + Send + Sync, [Vec3; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Text2d
where Text2d: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Text
where Text: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TextColor
where TextColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TextFont
where TextFont: Any + Send + Sync, Handle<Font>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineHeight: FromReflect + TypePath + MaybeTyped + RegisterForReflection, FontSmoothing: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TextLayout
where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TextShadow
where TextShadow: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TextSpan
where TextSpan: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TextureAtlas
where TextureAtlas: Any + Send + Sync, Handle<TextureAtlasLayout>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TextureAtlasLayout
where TextureAtlasLayout: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<URect>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TextureSlicer
where TextureSlicer: Any + Send + Sync, BorderRect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SliceScaleMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ThreadedAnimationGraph
where ThreadedAnimationGraph: Any + Send + Sync, Vec<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<Range<u32>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<u64>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ThreadedAnimationGraphs

Source§

impl Reflect for Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Torus
where Torus: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TouchInput
where TouchInput: Any + Send + Sync, TouchPhase: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<ForceTouch>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Transform
where Transform: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TransformTreeChanged

Source§

impl Reflect for Triangle2d
where Triangle2d: Any + Send + Sync, [Vec2; 3]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Triangle3d
where Triangle3d: Any + Send + Sync, [Vec3; 3]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for URect
where URect: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for UVec2
where UVec2: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for UVec3
where UVec3: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for UVec4
where UVec4: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for UiPickingCamera

Source§

impl Reflect for UiPickingSettings
where UiPickingSettings: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for UiRect
where UiRect: Any + Send + Sync, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for UiScale
where UiScale: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for UiTargetCamera
where UiTargetCamera: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Vec2
where Vec2: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Vec3
where Vec3: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Vec3A
where Vec3A: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Vec4
where Vec4: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ViewVisibility
where ViewVisibility: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Virtual
where Virtual: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Window
where Window: Any + Send + Sync, CursorOptions: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PresentMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowPosition: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowResolution: FromReflect + TypePath + MaybeTyped + RegisterForReflection, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<String>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CompositeAlphaMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowResizeConstraints: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, EnabledButtons: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowLevel: FromReflect + TypePath + MaybeTyped + RegisterForReflection, InternalWindowState: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<WindowTheme>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<NonZero<u32>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<(u8, u8)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowMoved
where WindowMoved: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowResizeConstraints
where WindowResizeConstraints: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Xyza
where Xyza: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ZIndex
where ZIndex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CameraMainTextureUsages

Source§

impl Reflect for CameraRenderGraph

Source§

impl Reflect for CustomProjection

Source§

impl Reflect for Exposure
where Exposure: Any + Send + Sync,

Source§

impl Reflect for ImageRenderTarget
where ImageRenderTarget: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, FloatOrd: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ManualTextureViewHandle
where ManualTextureViewHandle: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MipBias
where MipBias: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SubCameraView
where SubCameraView: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TemporalJitter
where TemporalJitter: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Viewport
where Viewport: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Range<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for OcclusionCulling

Source§

impl Reflect for GlobalsUniform
where GlobalsUniform: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ReadbackComplete
where ReadbackComplete: Any + Send + Sync, Vec<u8>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MeshMorphWeights
where MeshMorphWeights: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SkinnedMesh
where SkinnedMesh: Any + Send + Sync, Handle<SkinnedMeshInverseBindposes>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<Entity>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for AnnulusMeshBuilder
where AnnulusMeshBuilder: Any + Send + Sync, Annulus: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Capsule2dMeshBuilder
where Capsule2dMeshBuilder: Any + Send + Sync, Capsule2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Capsule3dMeshBuilder
where Capsule3dMeshBuilder: Any + Send + Sync, Capsule3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CapsuleUvProfile: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CircleMeshBuilder
where CircleMeshBuilder: Any + Send + Sync, Circle: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CircularSectorMeshBuilder
where CircularSectorMeshBuilder: Any + Send + Sync, CircularSector: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CircularMeshUvMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CircularSegmentMeshBuilder
where CircularSegmentMeshBuilder: Any + Send + Sync, CircularSegment: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CircularMeshUvMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ConeMeshBuilder
where ConeMeshBuilder: Any + Send + Sync, Cone: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ConeAnchor: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ConicalFrustumMeshBuilder
where ConicalFrustumMeshBuilder: Any + Send + Sync, ConicalFrustum: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CuboidMeshBuilder
where CuboidMeshBuilder: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CylinderMeshBuilder
where CylinderMeshBuilder: Any + Send + Sync, Cylinder: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CylinderAnchor: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for EllipseMeshBuilder
where EllipseMeshBuilder: Any + Send + Sync, Ellipse: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for MeshTag
where MeshTag: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PlaneMeshBuilder
where PlaneMeshBuilder: Any + Send + Sync, Plane3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RectangleMeshBuilder
where RectangleMeshBuilder: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RegularPolygonMeshBuilder
where RegularPolygonMeshBuilder: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RhombusMeshBuilder
where RhombusMeshBuilder: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SphereMeshBuilder
where SphereMeshBuilder: Any + Send + Sync, Sphere: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SphereKind: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TetrahedronMeshBuilder
where TetrahedronMeshBuilder: Any + Send + Sync, Tetrahedron: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TorusMeshBuilder
where TorusMeshBuilder: Any + Send + Sync, Torus: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RangeInclusive<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Triangle2dMeshBuilder
where Triangle2dMeshBuilder: Any + Send + Sync, Triangle2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Triangle3dMeshBuilder
where Triangle3dMeshBuilder: Any + Send + Sync, Triangle3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Aabb
where Aabb: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CascadesFrusta

Source§

impl Reflect for CubemapFrusta

Source§

impl Reflect for Frustum
where Frustum: Any + Send + Sync,

Source§

impl Reflect for ShaderStorageBuffer

Source§

impl Reflect for SyncToRenderWorld

Source§

impl Reflect for TemporaryRenderEntity

Source§

impl Reflect for ColorGrading
where ColorGrading: Any + Send + Sync, ColorGradingGlobal: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ColorGradingSection: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ColorGradingGlobal
where ColorGradingGlobal: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Range<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ColorGradingSection
where ColorGradingSection: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for NoFrustumCulling

Source§

impl Reflect for RenderLayers
where RenderLayers: Any + Send + Sync, SmallVec<[u64; 1]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for RenderVisibleEntities

Source§

impl Reflect for VisibilityClass
where VisibilityClass: Any + Send + Sync, SmallVec<[TypeId; 1]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for VisibilityRange
where VisibilityRange: Any + Send + Sync, Range<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for VisibleEntities

Source§

impl Reflect for Screenshot
where Screenshot: Any + Send + Sync, RenderTarget: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ScreenshotCaptured
where ScreenshotCaptured: Any + Send + Sync, Image: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for InstanceId
where InstanceId: Any + Send + Sync, Uuid: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for SceneInstanceReady
where SceneInstanceReady: Any + Send + Sync, InstanceId: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Mesh2dWireframe
where Mesh2dWireframe: Any + Send + Sync, Handle<Wireframe2dMaterial>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for NoWireframe2d

Source§

impl Reflect for Wireframe2d
where Wireframe2d: Any + Send + Sync,

Source§

impl Reflect for Wireframe2dColor
where Wireframe2dColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Wireframe2dConfig
where Wireframe2dConfig: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Wireframe2dMaterial
where Wireframe2dMaterial: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ComputedTextBlock
where ComputedTextBlock: Any + Send + Sync, SmallVec<[TextEntity; 1]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GlyphAtlasInfo
where GlyphAtlasInfo: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Handle<TextureAtlasLayout>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GlyphAtlasLocation: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GlyphAtlasLocation
where GlyphAtlasLocation: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PositionedGlyph
where PositionedGlyph: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GlyphAtlasInfo: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TextBounds
where TextBounds: Any + Send + Sync, Option<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TextEntity
where TextEntity: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TextLayoutInfo
where TextLayoutInfo: Any + Send + Sync, Vec<PositionedGlyph>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Stopwatch
where Stopwatch: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for GhostNode
where GhostNode: Any + Send + Sync,

Source§

impl Reflect for ContentSize
where ContentSize: Any + Send + Sync,

Source§

impl Reflect for RelativeCursorPosition
where RelativeCursorPosition: Any + Send + Sync, Rect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec2>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for ImageNodeSize
where ImageNodeSize: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for TextNodeFlags
where TextNodeFlags: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CursorOptions
where CursorOptions: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CursorGrabMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for EnabledButtons
where EnabledButtons: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for InternalWindowState
where InternalWindowState: Any + Send + Sync, Option<bool>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<CompassOctant>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<DVec2>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for Monitor
where Monitor: Any + Send + Sync, Option<String>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<u32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<VideoMode>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for NormalizedWindowRef
where NormalizedWindowRef: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for PrimaryMonitor

Source§

impl Reflect for PrimaryWindow

Source§

impl Reflect for RequestRedraw

Source§

impl Reflect for VideoMode
where VideoMode: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowBackendScaleFactorChanged
where WindowBackendScaleFactorChanged: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowCloseRequested
where WindowCloseRequested: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowClosed
where WindowClosed: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowClosing
where WindowClosing: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowCreated
where WindowCreated: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowDestroyed
where WindowDestroyed: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowFocused
where WindowFocused: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowOccluded
where WindowOccluded: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowResized
where WindowResized: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowResolution
where WindowResolution: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowScaleFactorChanged
where WindowScaleFactorChanged: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WindowThemeChanged
where WindowThemeChanged: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowTheme: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for CustomCursorImage
where CustomCursorImage: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<TextureAtlas>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<URect>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, (u16, u16): FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl Reflect for WakeUp
where WakeUp: Any + Send + Sync,

Source§

impl<'a> Reflect for AssetPath<'a>
where AssetPath<'a>: Any + Send + Sync,

Source§

impl<A> Reflect for AssetEvent<A>
where A: Asset + TypePath, AssetEvent<A>: Any + Send + Sync, AssetId<A>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<A> Reflect for AssetId<A>
where A: Asset + TypePath, AssetId<A>: Any + Send + Sync, AssetIndex: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Uuid: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<A> Reflect for Handle<A>
where A: Asset + TypePath, Handle<A>: Any + Send + Sync, Arc<StrongHandle>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AssetId<A>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<A> Reflect for AnimatableCurveEvaluator<A>
where A: Animatable + TypePath, AnimatableCurveEvaluator<A>: Any + Send + Sync, BasicAnimationCurveEvaluator<A>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Box<dyn AnimatableProperty<Property = A>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<B, E> Reflect for ExtendedMaterial<B, E>
where B: Material + FromReflect + TypePath + MaybeTyped + RegisterForReflection, E: MaterialExtension + FromReflect + TypePath + MaybeTyped + RegisterForReflection, ExtendedMaterial<B, E>: Any + Send + Sync,

Source§

impl<C> Reflect for SampleDerivativeWrapper<C>
where SampleDerivativeWrapper<C>: Any + Send + Sync, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

Source§

impl<C> Reflect for SampleTwoDerivativesWrapper<C>
where SampleTwoDerivativesWrapper<C>: Any + Send + Sync, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

Source§

impl<C> Reflect for bevy::prelude::WeightsCurve<C>
where WeightsCurve<C>: Any + Send + Sync, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

Source§

impl<Config, Clear> Reflect for GizmoBuffer<Config, Clear>
where GizmoBuffer<Config, Clear>: Any + Send + Sync, Config: GizmoConfigGroup + TypePath, Clear: 'static + Send + Sync + TypePath, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<Vec3>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<LinearRgba>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<E> Reflect for EventId<E>
where E: Event + TypePath, EventId<E>: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MaybeLocation: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<E> Reflect for FocusedInput<E>
where E: Event + Clone + TypePath + FromReflect + MaybeTyped + RegisterForReflection, FocusedInput<E>: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<E> Reflect for Events<E>
where E: Event + TypePath, Events<E>: Any + Send + Sync, EventSequence<E>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<E> Reflect for Pointer<E>
where E: Debug + Clone + Reflect + TypePath + FromReflect + MaybeTyped + RegisterForReflection, Pointer<E>: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PointerId: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Location: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<K, V, S> Reflect for bevy::platform::collections::HashMap<K, V, S>

Source§

impl<M> Reflect for MaterialNode<M>
where M: UiMaterial + TypePath, MaterialNode<M>: Any + Send + Sync, Handle<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<M> Reflect for MeshMaterial2d<M>
where M: Material2d + TypePath, MeshMaterial2d<M>: Any + Send + Sync, Handle<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<M> Reflect for MeshMaterial3d<M>
where M: Material + TypePath, MeshMaterial3d<M>: Any + Send + Sync, Handle<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<P> Reflect for LinearSpline<P>
where P: VectorSpace + TypePath, LinearSpline<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<P> Reflect for CubicBSpline<P>
where P: VectorSpace + TypePath, CubicBSpline<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<P> Reflect for CubicBezier<P>
where P: VectorSpace + TypePath, CubicBezier<P>: Any + Send + Sync, Vec<[P; 4]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<P> Reflect for CubicCardinalSpline<P>
where P: VectorSpace + TypePath, CubicCardinalSpline<P>: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<P> Reflect for CubicCurve<P>
where P: VectorSpace + TypePath, CubicCurve<P>: Any + Send + Sync, Vec<CubicSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<P> Reflect for CubicHermite<P>
where P: VectorSpace + TypePath, CubicHermite<P>: Any + Send + Sync, Vec<(P, P)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<P> Reflect for CubicNurbs<P>
where P: VectorSpace + TypePath, CubicNurbs<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<P> Reflect for CubicSegment<P>
where P: VectorSpace + TypePath, CubicSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<P> Reflect for RationalCurve<P>
where P: VectorSpace + TypePath, RationalCurve<P>: Any + Send + Sync, Vec<RationalSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<P> Reflect for RationalSegment<P>
where P: VectorSpace + TypePath, RationalSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection, [f32; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<P, C> Reflect for AnimatableCurve<P, C>
where AnimatableCurve<P, C>: Any + Send + Sync, P: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

Source§

impl<S> Reflect for NextState<S>
where S: FreelyMutableState + TypePath + FromReflect + MaybeTyped + RegisterForReflection, NextState<S>: Any + Send + Sync,

Source§

impl<S> Reflect for State<S>
where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, State<S>: Any + Send + Sync,

Source§

impl<S> Reflect for StateScoped<S>
where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, StateScoped<S>: Any + Send + Sync,

Source§

impl<S, T, C, D> Reflect for ZipCurve<S, T, C, D>
where ZipCurve<S, T, C, D>: Any + Send + Sync, S: TypePath, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, D: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<S, T, C, F> Reflect for MapCurve<S, T, C, F>
where MapCurve<S, T, C, F>: Any + Send + Sync, C: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, S: TypePath, T: TypePath,

Source§

impl<Source> Reflect for AudioPlayer<Source>
where AudioPlayer<Source>: Any + Send + Sync, Source: Asset + Decodable + TypePath, Handle<Source>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for InterpolationDatum<T>
where InterpolationDatum<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for CubicKeyframeCurve<T>
where CubicKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for SteppedKeyframeCurve<T>
where SteppedKeyframeCurve<T>: Any + Send + Sync, T: TypePath, UnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for WideCubicKeyframeCurve<T>
where WideCubicKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for WideLinearKeyframeCurve<T>
where WideLinearKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for WideSteppedKeyframeCurve<T>
where WideSteppedKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for ColorCurve<T>
where ColorCurve<T>: Any + Send + Sync, T: TypePath, EvenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for MaybeLocation<T>
where MaybeLocation<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection + ?Sized,

Source§

impl<T> Reflect for WithDerivative<T>
where WithDerivative<T>: Any + Send + Sync, T: HasTangent + TypePath + FromReflect + MaybeTyped + RegisterForReflection, <T as HasTangent>::Tangent: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for WithTwoDerivatives<T>
where WithTwoDerivatives<T>: Any + Send + Sync, T: HasTangent + TypePath + FromReflect + MaybeTyped + RegisterForReflection, <T as HasTangent>::Tangent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, <<T as HasTangent>::Tangent as HasTangent>::Tangent: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for Arc<T>
where T: Send + Sync + TypePath + ?Sized, Arc<T>: Any + Send + Sync,

Source§

impl<T> Reflect for ChunkedUnevenCore<T>
where ChunkedUnevenCore<T>: Any + Send + Sync, T: TypePath, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for AnimatableKeyframeCurve<T>
where AnimatableKeyframeCurve<T>: Any + Send + Sync, T: TypePath, UnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for Axis<T>
where Axis<T>: Any + Send + Sync, T: TypePath, HashMap<T, f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

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

Source§

impl<T> Reflect for ConstantCurve<T>
where ConstantCurve<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection, Interval: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for EasingCurve<T>
where EasingCurve<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection, EaseFunction: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for EvenCore<T>
where EvenCore<T>: Any + Send + Sync, T: TypePath, Interval: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for SampleAutoCurve<T>
where SampleAutoCurve<T>: Any + Send + Sync, T: TypePath, EvenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for Time<T>
where T: Default + TypePath + FromReflect + MaybeTyped + RegisterForReflection, Time<T>: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for UnevenCore<T>
where UnevenCore<T>: Any + Send + Sync, T: TypePath, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for UnevenSampleAutoCurve<T>
where UnevenSampleAutoCurve<T>: Any + Send + Sync, T: TypePath, UnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T> Reflect for Vec<T>
where T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,

Source§

impl<T, C> Reflect for ForeverCurve<T, C>
where ForeverCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

Source§

impl<T, C> Reflect for GraphCurve<T, C>
where GraphCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

Source§

impl<T, C> Reflect for LinearReparamCurve<T, C>
where LinearReparamCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T, C> Reflect for PingPongCurve<T, C>
where PingPongCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

Source§

impl<T, C> Reflect for RepeatCurve<T, C>
where RepeatCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<T, C> Reflect for ReverseCurve<T, C>
where ReverseCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

Source§

impl<T, C, D> Reflect for ChainCurve<T, C, D>
where ChainCurve<T, C, D>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, D: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

Source§

impl<T, C, D> Reflect for ContinuationCurve<T, C, D>
where ContinuationCurve<T, C, D>: Any + Send + Sync, T: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, D: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

Source§

impl<T, C, D> Reflect for CurveReparamCurve<T, C, D>
where CurveReparamCurve<T, C, D>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, D: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

Source§

impl<T, C, F> Reflect for ReparamCurve<T, C, F>
where ReparamCurve<T, C, F>: Any + Send + Sync, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, C: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

Source§

impl<T, F> Reflect for FunctionCurve<T, F>
where FunctionCurve<T, F>: Any + Send + Sync, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

Source§

impl<T, I> Reflect for SampleCurve<T, I>
where SampleCurve<T, I>: Any + Send + Sync, EvenCore<T>: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

Source§

impl<T, I> Reflect for UnevenSampleCurve<T, I>
where UnevenSampleCurve<T, I>: Any + Send + Sync, UnevenCore<T>: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

Source§

impl<V> Reflect for EntityHashMap<V>
where EntityHashMap<V>: Any + Send + Sync, V: TypePath, HashMap<Entity, V, EntityHash>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<V> Reflect for EntityIndexMap<V>
where EntityIndexMap<V>: Any + Send + Sync, V: TypePath, IndexMap<Entity, V, EntityHash>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<V, S> Reflect for bevy::platform::collections::HashSet<V, S>

Source§

impl<V, W> Reflect for Sum<V, W>
where Sum<V, W>: Any + Send + Sync, V: TypePath + FromReflect + MaybeTyped + RegisterForReflection, W: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

Source§

impl<const N: usize> Reflect for ConvexPolygon<N>
where ConvexPolygon<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<const N: usize> Reflect for Polygon<N>
where Polygon<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<const N: usize> Reflect for Polyline2d<N>
where Polyline2d<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<const N: usize> Reflect for Polyline3d<N>
where Polyline3d<N>: Any + Send + Sync, [Vec3; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

impl<const N: usize> Reflect for ConvexPolygonMeshBuilder<N>
where ConvexPolygonMeshBuilder<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,