Trait PartialReflect

pub trait PartialReflect:
    DynamicTypePath
    + Send
    + Sync
    + 'static {
    // Required methods
    fn get_represented_type_info(&self) -> Option<&'static TypeInfo>;
    fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>;
    fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static);
    fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static);
    fn try_into_reflect(
        self: Box<Self>,
    ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>;
    fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>;
    fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>;
    fn try_apply(
        &mut self,
        value: &(dyn PartialReflect + 'static),
    ) -> Result<(), ApplyError>;
    fn reflect_ref(&self) -> ReflectRef<'_>;
    fn reflect_mut(&mut self) -> ReflectMut<'_>;
    fn reflect_owned(self: Box<Self>) -> ReflectOwned;

    // Provided methods
    fn apply(&mut self, value: &(dyn PartialReflect + 'static)) { ... }
    fn reflect_kind(&self) -> ReflectKind { ... }
    fn clone_value(&self) -> Box<dyn PartialReflect> { ... }
    fn to_dynamic(&self) -> Box<dyn PartialReflect> { ... }
    fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError> { ... }
    fn reflect_hash(&self) -> Option<u64> { ... }
    fn reflect_partial_eq(
        &self,
        _value: &(dyn PartialReflect + 'static),
    ) -> Option<bool> { ... }
    fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error> { ... }
    fn is_dynamic(&self) -> bool { ... }
}

The foundational trait of bevy_reflect, used for accessing and modifying data dynamically.

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

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

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

Required Methods

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

Returns the TypeInfo of the type represented by this value.

For most types, this will simply return their own TypeInfo. However, for dynamic types, such as DynamicStruct or DynamicList, this will return the type they represent (or None if they don’t represent any particular type).

This method is great if you have an instance of a type or a dyn Reflect, and want to access its TypeInfo. However, if this method is to be called frequently, consider using TypeRegistry::get_type_info as it can be more performant for such use cases.

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

Casts this type to a boxed, reflected value.

This is useful for coercing trait objects.

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

Casts this type to a reflected value.

This is useful for coercing trait objects.

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

Casts this type to a mutable, reflected value.

This is useful for coercing trait objects.

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

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

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

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

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

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

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

Tries to apply a reflected value to this value.

Functions the same as the apply function but returns an error instead of panicking.

Handling Errors

This function may leave self in a partially mutated state if a error was encountered on the way. consider maintaining a cloned instance of this data you can switch to if a error is encountered.

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

Returns an immutable enumeration of “kinds” of type.

See ReflectRef.

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

Returns a mutable enumeration of “kinds” of type.

See ReflectMut.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

See ReflectOwned.

Provided Methods

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

Applies a reflected value to this value.

If a type implements an introspection subtrait, then the semantics of this method are as follows:

• If T is a Struct, then the value of each named field of value is applied to the corresponding named field of self. Fields which are not present in both structs are ignored.
• If T is a TupleStruct or Tuple, then the value of each numbered field is applied to the corresponding numbered field of self. Fields which are not present in both values are ignored.
• If T is an Enum, then the variant of self is updated to match the variant of value. The corresponding fields of that variant are applied from value onto self. Fields which are not present in both values are ignored.
• If T is a List or Array, then each element of value is applied to the corresponding element of self. Up to self.len() items are applied, and excess elements in value are appended to self.
• If T is a Map, then for each key in value, the associated value is applied to the value associated with the same key in self. Keys which are not present in self are inserted.
• If T is none of these, then value is downcast to T, cloned, and assigned to self.

Note that Reflect must be implemented manually for Lists and Maps in order to achieve the correct semantics, as derived implementations will have the semantics for Struct, TupleStruct, Enum or none of the above depending on the kind of type. For lists and maps, use the list_apply and map_apply helper functions when implementing this method.

Panics

Derived implementations of this method will panic:

• If the type of value is not of the same kind as T (e.g. if T is a List, while value is a Struct).
• If T is any complex type and the corresponding fields or elements of self and value are not of the same type.
• If T is an opaque type and self cannot be downcast to T

Examples found in repository

examples/reflection/reflection.rs (line 88)

fn setup(type_registry: Res<AppTypeRegistry>) {
    let mut value = Foo {
        a: 1,
        _ignored: NonReflectedValue { _a: 10 },
        nested: Bar { b: 8 },
    };

    // You can set field values like this. The type must match exactly or this will fail.
    *value.get_field_mut("a").unwrap() = 2usize;
    assert_eq!(value.a, 2);
    assert_eq!(*value.get_field::<usize>("a").unwrap(), 2);

    // You can also get the `&dyn PartialReflect` value of a field like this
    let field = value.field("a").unwrap();

    // But values introspected via `PartialReflect` will not return `dyn Reflect` trait objects
    // (even if the containing type does implement `Reflect`), so we need to convert them:
    let fully_reflected_field = field.try_as_reflect().unwrap();

    // Now, you can downcast your `Reflect` value like this:
    assert_eq!(*fully_reflected_field.downcast_ref::<usize>().unwrap(), 2);

    // For this specific case, we also support the shortcut `try_downcast_ref`:
    assert_eq!(*field.try_downcast_ref::<usize>().unwrap(), 2);

    // `DynamicStruct` also implements the `Struct` and `Reflect` traits.
    let mut patch = DynamicStruct::default();
    patch.insert("a", 4usize);

    // You can "apply" Reflect implementations on top of other Reflect implementations.
    // This will only set fields with the same name, and it will fail if the types don't match.
    // You can use this to "patch" your types with new values.
    value.apply(&patch);
    assert_eq!(value.a, 4);

    let type_registry = type_registry.read();
    // By default, all derived `Reflect` types can be Serialized using serde. No need to derive
    // Serialize!
    let serializer = ReflectSerializer::new(&value, &type_registry);
    let ron_string =
        ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
    info!("{}\n", ron_string);

    // Dynamic properties can be deserialized
    let reflect_deserializer = ReflectDeserializer::new(&type_registry);
    let mut deserializer = ron::de::Deserializer::from_str(&ron_string).unwrap();
    let reflect_value = reflect_deserializer.deserialize(&mut deserializer).unwrap();

    // Deserializing returns a `Box<dyn PartialReflect>` value.
    // Generally, deserializing a value will return the "dynamic" variant of a type.
    // For example, deserializing a struct will return the DynamicStruct type.
    // "Opaque types" will be deserialized as themselves.
    assert_eq!(
        reflect_value.reflect_type_path(),
        DynamicStruct::type_path(),
    );

    // Reflect has its own `partial_eq` implementation, named `reflect_partial_eq`. This behaves
    // like normal `partial_eq`, but it treats "dynamic" and "non-dynamic" types the same. The
    // `Foo` struct and deserialized `DynamicStruct` are considered equal for this reason:
    assert!(reflect_value.reflect_partial_eq(&value).unwrap());

    // By "patching" `Foo` with the deserialized DynamicStruct, we can "Deserialize" Foo.
    // This means we can serialize and deserialize with a single `Reflect` derive!
    value.apply(&*reflect_value);
}

examples/reflection/reflection_types.rs (line 141)

fn setup() {
    let mut z = <HashMap<_, _>>::default();
    z.insert("Hello".to_string(), 1.0);
    let value: Box<dyn Reflect> = Box::new(A {
        x: 1,
        y: vec![1, 2],
        z,
    });

    // There are a number of different "reflect traits", which each expose different operations on
    // the underlying type
    match value.reflect_ref() {
        // `Struct` is a trait automatically implemented for structs that derive Reflect. This trait
        // allows you to interact with fields via their string names or indices
        ReflectRef::Struct(value) => {
            info!(
                "This is a 'struct' type with an 'x' value of {}",
                value.get_field::<usize>("x").unwrap()
            );
        }
        // `TupleStruct` is a trait automatically implemented for tuple structs that derive Reflect.
        // This trait allows you to interact with fields via their indices
        ReflectRef::TupleStruct(_) => {}
        // `Tuple` is a special trait that can be manually implemented (instead of deriving
        // Reflect). This exposes "tuple" operations on your type, allowing you to interact
        // with fields via their indices. Tuple is automatically implemented for tuples of
        // arity 12 or less.
        ReflectRef::Tuple(_) => {}
        // `Enum` is a trait automatically implemented for enums that derive Reflect. This trait allows you
        // to interact with the current variant and its fields (if it has any)
        ReflectRef::Enum(_) => {}
        // `List` is a special trait that can be manually implemented (instead of deriving Reflect).
        // This exposes "list" operations on your type, such as insertion. `List` is automatically
        // implemented for relevant core types like Vec<T>.
        ReflectRef::List(_) => {}
        // `Array` is a special trait that can be manually implemented (instead of deriving Reflect).
        // This exposes "array" operations on your type, such as indexing. `Array`
        // is automatically implemented for relevant core types like [T; N].
        ReflectRef::Array(_) => {}
        // `Map` is a special trait that can be manually implemented (instead of deriving Reflect).
        // This exposes "map" operations on your type, such as getting / inserting by key.
        // Map is automatically implemented for relevant core types like HashMap<K, V>
        ReflectRef::Map(_) => {}
        // `Set` is a special trait that can be manually implemented (instead of deriving Reflect).
        // This exposes "set" operations on your type, such as getting / inserting by value.
        // Set is automatically implemented for relevant core types like HashSet<T>
        ReflectRef::Set(_) => {}
        // `Function` is a special trait that can be manually implemented (instead of deriving Reflect).
        // This exposes "function" operations on your type, such as calling it with arguments.
        // This trait is automatically implemented for types like DynamicFunction.
        // This variant only exists if the `reflect_functions` feature is enabled.
        #[cfg(feature = "reflect_functions")]
        ReflectRef::Function(_) => {}
        // `Opaque` types do not implement any of the other traits above. They are simply a Reflect
        // implementation. Opaque is implemented for opaque types like String and Instant,
        // but also include primitive types like i32, usize, and f32 (despite not technically being opaque).
        ReflectRef::Opaque(_) => {}
        #[expect(
            clippy::allow_attributes,
            reason = "`unreachable_patterns` is not always linted"
        )]
        #[allow(
            unreachable_patterns,
            reason = "This example cannot always detect when `bevy_reflect/functions` is enabled."
        )]
        _ => {}
    }

    let mut dynamic_list = DynamicList::default();
    dynamic_list.push(3u32);
    dynamic_list.push(4u32);
    dynamic_list.push(5u32);

    let mut value: A = value.take::<A>().unwrap();
    value.y.apply(&dynamic_list);
    assert_eq!(value.y, vec![3u32, 4u32, 5u32]);
}

examples/reflection/dynamic_types.rs (line 108)

fn main() {
    #[derive(Reflect, Default, PartialEq, Debug)]
    #[reflect(Identifiable, Default)]
    struct Player {
        id: u32,
    }

    #[reflect_trait]
    trait Identifiable {
        fn id(&self) -> u32;
    }

    impl Identifiable for Player {
        fn id(&self) -> u32 {
            self.id
        }
    }

    // Normally, when instantiating a type, you get back exactly that type.
    // This is because the type is known at compile time.
    // We call this the "concrete" or "canonical" type.
    let player: Player = Player { id: 123 };

    // When working with reflected types, however, we often "erase" this type information
    // using the `Reflect` trait object.
    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
    // The underlying type is still the same (in this case, `Player`),
    // but now we've hidden that information from the compiler.
    let reflected: Box<dyn Reflect> = Box::new(player);

    // Because it's the same type under the hood, we can still downcast it back to the original type.
    assert!(reflected.downcast_ref::<Player>().is_some());

    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));

    // Another way we can "clone" our data is by converting it to a dynamic type.
    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
    // This is because it returns a dynamic type that simply represents the original type.
    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
    assert!(dynamic.is_dynamic());

    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
    assert!(dynamic.try_as_reflect().is_none());

    // Generally dynamic types are used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
    let id = dynamic_ref.field("id").unwrap().try_downcast_ref::<u32>();
    assert_eq!(id, Some(&123));

    // It also enables us to create a representation of a type without having compile-time
    // access to the actual type. This is how the reflection deserializers work.
    // They generally can't know how to construct a type ahead of time,
    // so they instead build and return these dynamic representations.
    let input = "(id: 123)";
    let mut registry = TypeRegistry::default();
    registry.register::<Player>();
    let registration = registry.get(std::any::TypeId::of::<Player>()).unwrap();
    let deserialized = TypedReflectDeserializer::new(registration, &registry)
        .deserialize(&mut ron::Deserializer::from_str(input).unwrap())
        .unwrap();

    // Our deserialized output is a `DynamicStruct` that proxies/represents a `Player`.
    assert!(deserialized.represents::<Player>());

    // And while this does allow us to access the fields and structure of the type,
    // there may be instances where we need the actual type.
    // For example, if we want to convert our `dyn Reflect` into a `dyn Identifiable`,
    // we can't use the `DynamicStruct` proxy.
    let reflect_identifiable = registration
        .data::<ReflectIdentifiable>()
        .expect("`ReflectIdentifiable` should be registered");

    // Trying to access the registry with our `deserialized` will give a compile error
    // since it doesn't implement `Reflect`, only `PartialReflect`.
    // Similarly, trying to force the operation will fail.
    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(deserialized
        .try_as_reflect()
        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
        .is_none());

    // So how can we go from a dynamic type to a concrete type?
    // There are two ways:

    // 1. Using `PartialReflect::apply`.
    {
        // If you know the type at compile time, you can construct a new value and apply the dynamic
        // value to it.
        let mut value = Player::default();
        value.apply(deserialized.as_ref());
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you need a dynamic way of constructing
        // an instance of the type. One such way is to use the `ReflectDefault` type data.
        let reflect_default = registration
            .data::<ReflectDefault>()
            .expect("`ReflectDefault` should be registered");

        let mut value: Box<dyn Reflect> = reflect_default.default();
        value.apply(deserialized.as_ref());

        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // 2. Using `FromReflect`
    {
        // If you know the type at compile time, you can use the `FromReflect` trait to convert the
        // dynamic value into the concrete type directly.
        let value: Player = Player::from_reflect(deserialized.as_ref()).unwrap();
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you can use the `ReflectFromReflect` type data
        // to perform the conversion dynamically.
        let reflect_from_reflect = registration
            .data::<ReflectFromReflect>()
            .expect("`ReflectFromReflect` should be registered");

        let value: Box<dyn Reflect> = reflect_from_reflect
            .from_reflect(deserialized.as_ref())
            .unwrap();
        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // Lastly, while dynamic types are commonly generated via reflection methods like
    // `PartialReflect::to_dynamic` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

    // This is useful when you just need to apply some subset of changes to a type.
    let mut my_list: Vec<u32> = Vec::new();
    my_list.apply(&my_dynamic_list);
    assert_eq!(my_list, vec![1, 2, 3]);

    // And if you want it to actually proxy a type, you can configure it to do that as well:
    assert!(!my_dynamic_list
        .as_partial_reflect()
        .represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list
        .as_partial_reflect()
        .represents::<Vec<u32>>());

    // ============================= REFERENCE ============================= //
    // For reference, here are all the available dynamic types:

    // 1. `DynamicTuple`
    {
        let mut dynamic_tuple = DynamicTuple::default();
        dynamic_tuple.insert(1u32);
        dynamic_tuple.insert(2u32);
        dynamic_tuple.insert(3u32);

        let mut my_tuple: (u32, u32, u32) = (0, 0, 0);
        my_tuple.apply(&dynamic_tuple);
        assert_eq!(my_tuple, (1, 2, 3));
    }

    // 2. `DynamicArray`
    {
        let dynamic_array = DynamicArray::from_iter([1u32, 2u32, 3u32]);

        let mut my_array = [0u32; 3];
        my_array.apply(&dynamic_array);
        assert_eq!(my_array, [1, 2, 3]);
    }

    // 3. `DynamicList`
    {
        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

        let mut my_list: Vec<u32> = Vec::new();
        my_list.apply(&dynamic_list);
        assert_eq!(my_list, vec![1, 2, 3]);
    }

    // 4. `DynamicSet`
    {
        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
        assert!(dynamic_set.contains(&"x"));

        dynamic_set.remove(&"y");

        let mut my_set: HashSet<&str> = HashSet::default();
        my_set.apply(&dynamic_set);
        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
    }

    // 5. `DynamicMap`
    {
        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);

        let mut my_map: HashMap<&str, u32> = HashMap::default();
        my_map.apply(&dynamic_map);
        assert_eq!(my_map.get("x"), Some(&1));
        assert_eq!(my_map.get("y"), Some(&2));
        assert_eq!(my_map.get("z"), Some(&3));
    }

    // 6. `DynamicStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyStruct {
            x: u32,
            y: u32,
            z: u32,
        }

        let mut dynamic_struct = DynamicStruct::default();
        dynamic_struct.insert("x", 1u32);
        dynamic_struct.insert("y", 2u32);
        dynamic_struct.insert("z", 3u32);

        let mut my_struct = MyStruct::default();
        my_struct.apply(&dynamic_struct);
        assert_eq!(my_struct, MyStruct { x: 1, y: 2, z: 3 });
    }

    // 7. `DynamicTupleStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyTupleStruct(u32, u32, u32);

        let mut dynamic_tuple_struct = DynamicTupleStruct::default();
        dynamic_tuple_struct.insert(1u32);
        dynamic_tuple_struct.insert(2u32);
        dynamic_tuple_struct.insert(3u32);

        let mut my_tuple_struct = MyTupleStruct::default();
        my_tuple_struct.apply(&dynamic_tuple_struct);
        assert_eq!(my_tuple_struct, MyTupleStruct(1, 2, 3));
    }

    // 8. `DynamicEnum`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        enum MyEnum {
            #[default]
            Empty,
            Xyz(u32, u32, u32),
        }

        let mut values = DynamicTuple::default();
        values.insert(1u32);
        values.insert(2u32);
        values.insert(3u32);

        let dynamic_variant = DynamicVariant::Tuple(values);
        let dynamic_enum = DynamicEnum::new("Xyz", dynamic_variant);

        let mut my_enum = MyEnum::default();
        my_enum.apply(&dynamic_enum);
        assert_eq!(my_enum, MyEnum::Xyz(1, 2, 3));
    }
}

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

See ReflectKind.

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

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

Clones Self into its dynamic representation.

For value types or types marked with #[reflect_value], this will simply return a clone of Self.

Otherwise the associated dynamic type will be returned.

For example, a List type will invoke List::clone_dynamic, returning DynamicList. A Struct type will invoke Struct::clone_dynamic, returning DynamicStruct. And so on.

If the dynamic behavior is not desired, a concrete clone can be obtained using PartialReflect::reflect_clone.

Example

let value = (1, true, 3.14);
let cloned = value.clone_value();
assert!(cloned.is_dynamic())

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

Converts this reflected value into its dynamic representation based on its kind.

For example, a List type will internally invoke List::to_dynamic_list, returning DynamicList. A Struct type will invoke Struct::to_dynamic_struct, returning DynamicStruct. And so on.

If the kind is opaque, then the value will attempt to be cloned directly via reflect_clone, since opaque types do not have any standard dynamic representation.

To attempt to clone the value directly such that it returns a concrete instance of this type, use reflect_clone.

Panics

This method will panic if the kind is opaque and the call to reflect_clone fails.

Example

let value = (1, true, 3.14);
let dynamic_value = value.to_dynamic();
assert!(dynamic_value.is_dynamic())

Examples found in repository

examples/reflection/dynamic_types.rs (line 55)

fn main() {
    #[derive(Reflect, Default, PartialEq, Debug)]
    #[reflect(Identifiable, Default)]
    struct Player {
        id: u32,
    }

    #[reflect_trait]
    trait Identifiable {
        fn id(&self) -> u32;
    }

    impl Identifiable for Player {
        fn id(&self) -> u32 {
            self.id
        }
    }

    // Normally, when instantiating a type, you get back exactly that type.
    // This is because the type is known at compile time.
    // We call this the "concrete" or "canonical" type.
    let player: Player = Player { id: 123 };

    // When working with reflected types, however, we often "erase" this type information
    // using the `Reflect` trait object.
    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
    // The underlying type is still the same (in this case, `Player`),
    // but now we've hidden that information from the compiler.
    let reflected: Box<dyn Reflect> = Box::new(player);

    // Because it's the same type under the hood, we can still downcast it back to the original type.
    assert!(reflected.downcast_ref::<Player>().is_some());

    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));

    // Another way we can "clone" our data is by converting it to a dynamic type.
    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
    // This is because it returns a dynamic type that simply represents the original type.
    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
    assert!(dynamic.is_dynamic());

    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
    assert!(dynamic.try_as_reflect().is_none());

    // Generally dynamic types are used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
    let id = dynamic_ref.field("id").unwrap().try_downcast_ref::<u32>();
    assert_eq!(id, Some(&123));

    // It also enables us to create a representation of a type without having compile-time
    // access to the actual type. This is how the reflection deserializers work.
    // They generally can't know how to construct a type ahead of time,
    // so they instead build and return these dynamic representations.
    let input = "(id: 123)";
    let mut registry = TypeRegistry::default();
    registry.register::<Player>();
    let registration = registry.get(std::any::TypeId::of::<Player>()).unwrap();
    let deserialized = TypedReflectDeserializer::new(registration, &registry)
        .deserialize(&mut ron::Deserializer::from_str(input).unwrap())
        .unwrap();

    // Our deserialized output is a `DynamicStruct` that proxies/represents a `Player`.
    assert!(deserialized.represents::<Player>());

    // And while this does allow us to access the fields and structure of the type,
    // there may be instances where we need the actual type.
    // For example, if we want to convert our `dyn Reflect` into a `dyn Identifiable`,
    // we can't use the `DynamicStruct` proxy.
    let reflect_identifiable = registration
        .data::<ReflectIdentifiable>()
        .expect("`ReflectIdentifiable` should be registered");

    // Trying to access the registry with our `deserialized` will give a compile error
    // since it doesn't implement `Reflect`, only `PartialReflect`.
    // Similarly, trying to force the operation will fail.
    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(deserialized
        .try_as_reflect()
        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
        .is_none());

    // So how can we go from a dynamic type to a concrete type?
    // There are two ways:

    // 1. Using `PartialReflect::apply`.
    {
        // If you know the type at compile time, you can construct a new value and apply the dynamic
        // value to it.
        let mut value = Player::default();
        value.apply(deserialized.as_ref());
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you need a dynamic way of constructing
        // an instance of the type. One such way is to use the `ReflectDefault` type data.
        let reflect_default = registration
            .data::<ReflectDefault>()
            .expect("`ReflectDefault` should be registered");

        let mut value: Box<dyn Reflect> = reflect_default.default();
        value.apply(deserialized.as_ref());

        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // 2. Using `FromReflect`
    {
        // If you know the type at compile time, you can use the `FromReflect` trait to convert the
        // dynamic value into the concrete type directly.
        let value: Player = Player::from_reflect(deserialized.as_ref()).unwrap();
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you can use the `ReflectFromReflect` type data
        // to perform the conversion dynamically.
        let reflect_from_reflect = registration
            .data::<ReflectFromReflect>()
            .expect("`ReflectFromReflect` should be registered");

        let value: Box<dyn Reflect> = reflect_from_reflect
            .from_reflect(deserialized.as_ref())
            .unwrap();
        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // Lastly, while dynamic types are commonly generated via reflection methods like
    // `PartialReflect::to_dynamic` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

    // This is useful when you just need to apply some subset of changes to a type.
    let mut my_list: Vec<u32> = Vec::new();
    my_list.apply(&my_dynamic_list);
    assert_eq!(my_list, vec![1, 2, 3]);

    // And if you want it to actually proxy a type, you can configure it to do that as well:
    assert!(!my_dynamic_list
        .as_partial_reflect()
        .represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list
        .as_partial_reflect()
        .represents::<Vec<u32>>());

    // ============================= REFERENCE ============================= //
    // For reference, here are all the available dynamic types:

    // 1. `DynamicTuple`
    {
        let mut dynamic_tuple = DynamicTuple::default();
        dynamic_tuple.insert(1u32);
        dynamic_tuple.insert(2u32);
        dynamic_tuple.insert(3u32);

        let mut my_tuple: (u32, u32, u32) = (0, 0, 0);
        my_tuple.apply(&dynamic_tuple);
        assert_eq!(my_tuple, (1, 2, 3));
    }

    // 2. `DynamicArray`
    {
        let dynamic_array = DynamicArray::from_iter([1u32, 2u32, 3u32]);

        let mut my_array = [0u32; 3];
        my_array.apply(&dynamic_array);
        assert_eq!(my_array, [1, 2, 3]);
    }

    // 3. `DynamicList`
    {
        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

        let mut my_list: Vec<u32> = Vec::new();
        my_list.apply(&dynamic_list);
        assert_eq!(my_list, vec![1, 2, 3]);
    }

    // 4. `DynamicSet`
    {
        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
        assert!(dynamic_set.contains(&"x"));

        dynamic_set.remove(&"y");

        let mut my_set: HashSet<&str> = HashSet::default();
        my_set.apply(&dynamic_set);
        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
    }

    // 5. `DynamicMap`
    {
        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);

        let mut my_map: HashMap<&str, u32> = HashMap::default();
        my_map.apply(&dynamic_map);
        assert_eq!(my_map.get("x"), Some(&1));
        assert_eq!(my_map.get("y"), Some(&2));
        assert_eq!(my_map.get("z"), Some(&3));
    }

    // 6. `DynamicStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyStruct {
            x: u32,
            y: u32,
            z: u32,
        }

        let mut dynamic_struct = DynamicStruct::default();
        dynamic_struct.insert("x", 1u32);
        dynamic_struct.insert("y", 2u32);
        dynamic_struct.insert("z", 3u32);

        let mut my_struct = MyStruct::default();
        my_struct.apply(&dynamic_struct);
        assert_eq!(my_struct, MyStruct { x: 1, y: 2, z: 3 });
    }

    // 7. `DynamicTupleStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyTupleStruct(u32, u32, u32);

        let mut dynamic_tuple_struct = DynamicTupleStruct::default();
        dynamic_tuple_struct.insert(1u32);
        dynamic_tuple_struct.insert(2u32);
        dynamic_tuple_struct.insert(3u32);

        let mut my_tuple_struct = MyTupleStruct::default();
        my_tuple_struct.apply(&dynamic_tuple_struct);
        assert_eq!(my_tuple_struct, MyTupleStruct(1, 2, 3));
    }

    // 8. `DynamicEnum`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        enum MyEnum {
            #[default]
            Empty,
            Xyz(u32, u32, u32),
        }

        let mut values = DynamicTuple::default();
        values.insert(1u32);
        values.insert(2u32);
        values.insert(3u32);

        let dynamic_variant = DynamicVariant::Tuple(values);
        let dynamic_enum = DynamicEnum::new("Xyz", dynamic_variant);

        let mut my_enum = MyEnum::default();
        my_enum.apply(&dynamic_enum);
        assert_eq!(my_enum, MyEnum::Xyz(1, 2, 3));
    }
}

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

Attempts to clone Self using reflection.

Unlike to_dynamic, which generally returns a dynamic representation of Self, this method attempts create a clone of Self directly, if possible.

If the clone cannot be performed, an appropriate ReflectCloneError is returned.

Example

let value = (1, true, 3.14);
let cloned = value.reflect_clone().unwrap();
assert!(cloned.is::<(i32, bool, f64)>())

Examples found in repository

examples/reflection/dynamic_types.rs (line 48)

fn main() {
    #[derive(Reflect, Default, PartialEq, Debug)]
    #[reflect(Identifiable, Default)]
    struct Player {
        id: u32,
    }

    #[reflect_trait]
    trait Identifiable {
        fn id(&self) -> u32;
    }

    impl Identifiable for Player {
        fn id(&self) -> u32 {
            self.id
        }
    }

    // Normally, when instantiating a type, you get back exactly that type.
    // This is because the type is known at compile time.
    // We call this the "concrete" or "canonical" type.
    let player: Player = Player { id: 123 };

    // When working with reflected types, however, we often "erase" this type information
    // using the `Reflect` trait object.
    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
    // The underlying type is still the same (in this case, `Player`),
    // but now we've hidden that information from the compiler.
    let reflected: Box<dyn Reflect> = Box::new(player);

    // Because it's the same type under the hood, we can still downcast it back to the original type.
    assert!(reflected.downcast_ref::<Player>().is_some());

    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));

    // Another way we can "clone" our data is by converting it to a dynamic type.
    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
    // This is because it returns a dynamic type that simply represents the original type.
    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
    assert!(dynamic.is_dynamic());

    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
    assert!(dynamic.try_as_reflect().is_none());

    // Generally dynamic types are used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
    let id = dynamic_ref.field("id").unwrap().try_downcast_ref::<u32>();
    assert_eq!(id, Some(&123));

    // It also enables us to create a representation of a type without having compile-time
    // access to the actual type. This is how the reflection deserializers work.
    // They generally can't know how to construct a type ahead of time,
    // so they instead build and return these dynamic representations.
    let input = "(id: 123)";
    let mut registry = TypeRegistry::default();
    registry.register::<Player>();
    let registration = registry.get(std::any::TypeId::of::<Player>()).unwrap();
    let deserialized = TypedReflectDeserializer::new(registration, &registry)
        .deserialize(&mut ron::Deserializer::from_str(input).unwrap())
        .unwrap();

    // Our deserialized output is a `DynamicStruct` that proxies/represents a `Player`.
    assert!(deserialized.represents::<Player>());

    // And while this does allow us to access the fields and structure of the type,
    // there may be instances where we need the actual type.
    // For example, if we want to convert our `dyn Reflect` into a `dyn Identifiable`,
    // we can't use the `DynamicStruct` proxy.
    let reflect_identifiable = registration
        .data::<ReflectIdentifiable>()
        .expect("`ReflectIdentifiable` should be registered");

    // Trying to access the registry with our `deserialized` will give a compile error
    // since it doesn't implement `Reflect`, only `PartialReflect`.
    // Similarly, trying to force the operation will fail.
    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(deserialized
        .try_as_reflect()
        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
        .is_none());

    // So how can we go from a dynamic type to a concrete type?
    // There are two ways:

    // 1. Using `PartialReflect::apply`.
    {
        // If you know the type at compile time, you can construct a new value and apply the dynamic
        // value to it.
        let mut value = Player::default();
        value.apply(deserialized.as_ref());
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you need a dynamic way of constructing
        // an instance of the type. One such way is to use the `ReflectDefault` type data.
        let reflect_default = registration
            .data::<ReflectDefault>()
            .expect("`ReflectDefault` should be registered");

        let mut value: Box<dyn Reflect> = reflect_default.default();
        value.apply(deserialized.as_ref());

        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // 2. Using `FromReflect`
    {
        // If you know the type at compile time, you can use the `FromReflect` trait to convert the
        // dynamic value into the concrete type directly.
        let value: Player = Player::from_reflect(deserialized.as_ref()).unwrap();
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you can use the `ReflectFromReflect` type data
        // to perform the conversion dynamically.
        let reflect_from_reflect = registration
            .data::<ReflectFromReflect>()
            .expect("`ReflectFromReflect` should be registered");

        let value: Box<dyn Reflect> = reflect_from_reflect
            .from_reflect(deserialized.as_ref())
            .unwrap();
        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // Lastly, while dynamic types are commonly generated via reflection methods like
    // `PartialReflect::to_dynamic` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

    // This is useful when you just need to apply some subset of changes to a type.
    let mut my_list: Vec<u32> = Vec::new();
    my_list.apply(&my_dynamic_list);
    assert_eq!(my_list, vec![1, 2, 3]);

    // And if you want it to actually proxy a type, you can configure it to do that as well:
    assert!(!my_dynamic_list
        .as_partial_reflect()
        .represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list
        .as_partial_reflect()
        .represents::<Vec<u32>>());

    // ============================= REFERENCE ============================= //
    // For reference, here are all the available dynamic types:

    // 1. `DynamicTuple`
    {
        let mut dynamic_tuple = DynamicTuple::default();
        dynamic_tuple.insert(1u32);
        dynamic_tuple.insert(2u32);
        dynamic_tuple.insert(3u32);

        let mut my_tuple: (u32, u32, u32) = (0, 0, 0);
        my_tuple.apply(&dynamic_tuple);
        assert_eq!(my_tuple, (1, 2, 3));
    }

    // 2. `DynamicArray`
    {
        let dynamic_array = DynamicArray::from_iter([1u32, 2u32, 3u32]);

        let mut my_array = [0u32; 3];
        my_array.apply(&dynamic_array);
        assert_eq!(my_array, [1, 2, 3]);
    }

    // 3. `DynamicList`
    {
        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

        let mut my_list: Vec<u32> = Vec::new();
        my_list.apply(&dynamic_list);
        assert_eq!(my_list, vec![1, 2, 3]);
    }

    // 4. `DynamicSet`
    {
        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
        assert!(dynamic_set.contains(&"x"));

        dynamic_set.remove(&"y");

        let mut my_set: HashSet<&str> = HashSet::default();
        my_set.apply(&dynamic_set);
        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
    }

    // 5. `DynamicMap`
    {
        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);

        let mut my_map: HashMap<&str, u32> = HashMap::default();
        my_map.apply(&dynamic_map);
        assert_eq!(my_map.get("x"), Some(&1));
        assert_eq!(my_map.get("y"), Some(&2));
        assert_eq!(my_map.get("z"), Some(&3));
    }

    // 6. `DynamicStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyStruct {
            x: u32,
            y: u32,
            z: u32,
        }

        let mut dynamic_struct = DynamicStruct::default();
        dynamic_struct.insert("x", 1u32);
        dynamic_struct.insert("y", 2u32);
        dynamic_struct.insert("z", 3u32);

        let mut my_struct = MyStruct::default();
        my_struct.apply(&dynamic_struct);
        assert_eq!(my_struct, MyStruct { x: 1, y: 2, z: 3 });
    }

    // 7. `DynamicTupleStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyTupleStruct(u32, u32, u32);

        let mut dynamic_tuple_struct = DynamicTupleStruct::default();
        dynamic_tuple_struct.insert(1u32);
        dynamic_tuple_struct.insert(2u32);
        dynamic_tuple_struct.insert(3u32);

        let mut my_tuple_struct = MyTupleStruct::default();
        my_tuple_struct.apply(&dynamic_tuple_struct);
        assert_eq!(my_tuple_struct, MyTupleStruct(1, 2, 3));
    }

    // 8. `DynamicEnum`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        enum MyEnum {
            #[default]
            Empty,
            Xyz(u32, u32, u32),
        }

        let mut values = DynamicTuple::default();
        values.insert(1u32);
        values.insert(2u32);
        values.insert(3u32);

        let dynamic_variant = DynamicVariant::Tuple(values);
        let dynamic_enum = DynamicEnum::new("Xyz", dynamic_variant);

        let mut my_enum = MyEnum::default();
        my_enum.apply(&dynamic_enum);
        assert_eq!(my_enum, MyEnum::Xyz(1, 2, 3));
    }
}

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

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

If the underlying type does not support hashing, returns None.

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

Returns a “partial equality” comparison result.

If the underlying type does not support equality testing, returns None.

Examples found in repository

examples/reflection/reflection.rs (line 116)

fn setup(type_registry: Res<AppTypeRegistry>) {
    let mut value = Foo {
        a: 1,
        _ignored: NonReflectedValue { _a: 10 },
        nested: Bar { b: 8 },
    };

    // You can set field values like this. The type must match exactly or this will fail.
    *value.get_field_mut("a").unwrap() = 2usize;
    assert_eq!(value.a, 2);
    assert_eq!(*value.get_field::<usize>("a").unwrap(), 2);

    // You can also get the `&dyn PartialReflect` value of a field like this
    let field = value.field("a").unwrap();

    // But values introspected via `PartialReflect` will not return `dyn Reflect` trait objects
    // (even if the containing type does implement `Reflect`), so we need to convert them:
    let fully_reflected_field = field.try_as_reflect().unwrap();

    // Now, you can downcast your `Reflect` value like this:
    assert_eq!(*fully_reflected_field.downcast_ref::<usize>().unwrap(), 2);

    // For this specific case, we also support the shortcut `try_downcast_ref`:
    assert_eq!(*field.try_downcast_ref::<usize>().unwrap(), 2);

    // `DynamicStruct` also implements the `Struct` and `Reflect` traits.
    let mut patch = DynamicStruct::default();
    patch.insert("a", 4usize);

    // You can "apply" Reflect implementations on top of other Reflect implementations.
    // This will only set fields with the same name, and it will fail if the types don't match.
    // You can use this to "patch" your types with new values.
    value.apply(&patch);
    assert_eq!(value.a, 4);

    let type_registry = type_registry.read();
    // By default, all derived `Reflect` types can be Serialized using serde. No need to derive
    // Serialize!
    let serializer = ReflectSerializer::new(&value, &type_registry);
    let ron_string =
        ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
    info!("{}\n", ron_string);

    // Dynamic properties can be deserialized
    let reflect_deserializer = ReflectDeserializer::new(&type_registry);
    let mut deserializer = ron::de::Deserializer::from_str(&ron_string).unwrap();
    let reflect_value = reflect_deserializer.deserialize(&mut deserializer).unwrap();

    // Deserializing returns a `Box<dyn PartialReflect>` value.
    // Generally, deserializing a value will return the "dynamic" variant of a type.
    // For example, deserializing a struct will return the DynamicStruct type.
    // "Opaque types" will be deserialized as themselves.
    assert_eq!(
        reflect_value.reflect_type_path(),
        DynamicStruct::type_path(),
    );

    // Reflect has its own `partial_eq` implementation, named `reflect_partial_eq`. This behaves
    // like normal `partial_eq`, but it treats "dynamic" and "non-dynamic" types the same. The
    // `Foo` struct and deserialized `DynamicStruct` are considered equal for this reason:
    assert!(reflect_value.reflect_partial_eq(&value).unwrap());

    // By "patching" `Foo` with the deserialized DynamicStruct, we can "Deserialize" Foo.
    // This means we can serialize and deserialize with a single `Reflect` derive!
    value.apply(&*reflect_value);
}

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

Debug formatter for the value.

Any value that is not an implementor of other Reflect subtraits (e.g. List, Map), will default to the format: "Reflect(type_path)", where type_path is the type path of the underlying type.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

Dynamic types include the ones built-in to this crate, such as DynamicStruct, DynamicList, and DynamicTuple. However, they may be custom types used as proxies for other types or to facilitate scripting capabilities.

By default, this method will return false.

Examples found in repository

examples/reflection/dynamic_types.rs (line 56)

fn main() {
    #[derive(Reflect, Default, PartialEq, Debug)]
    #[reflect(Identifiable, Default)]
    struct Player {
        id: u32,
    }

    #[reflect_trait]
    trait Identifiable {
        fn id(&self) -> u32;
    }

    impl Identifiable for Player {
        fn id(&self) -> u32 {
            self.id
        }
    }

    // Normally, when instantiating a type, you get back exactly that type.
    // This is because the type is known at compile time.
    // We call this the "concrete" or "canonical" type.
    let player: Player = Player { id: 123 };

    // When working with reflected types, however, we often "erase" this type information
    // using the `Reflect` trait object.
    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
    // The underlying type is still the same (in this case, `Player`),
    // but now we've hidden that information from the compiler.
    let reflected: Box<dyn Reflect> = Box::new(player);

    // Because it's the same type under the hood, we can still downcast it back to the original type.
    assert!(reflected.downcast_ref::<Player>().is_some());

    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));

    // Another way we can "clone" our data is by converting it to a dynamic type.
    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
    // This is because it returns a dynamic type that simply represents the original type.
    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
    assert!(dynamic.is_dynamic());

    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
    assert!(dynamic.try_as_reflect().is_none());

    // Generally dynamic types are used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
    let id = dynamic_ref.field("id").unwrap().try_downcast_ref::<u32>();
    assert_eq!(id, Some(&123));

    // It also enables us to create a representation of a type without having compile-time
    // access to the actual type. This is how the reflection deserializers work.
    // They generally can't know how to construct a type ahead of time,
    // so they instead build and return these dynamic representations.
    let input = "(id: 123)";
    let mut registry = TypeRegistry::default();
    registry.register::<Player>();
    let registration = registry.get(std::any::TypeId::of::<Player>()).unwrap();
    let deserialized = TypedReflectDeserializer::new(registration, &registry)
        .deserialize(&mut ron::Deserializer::from_str(input).unwrap())
        .unwrap();

    // Our deserialized output is a `DynamicStruct` that proxies/represents a `Player`.
    assert!(deserialized.represents::<Player>());

    // And while this does allow us to access the fields and structure of the type,
    // there may be instances where we need the actual type.
    // For example, if we want to convert our `dyn Reflect` into a `dyn Identifiable`,
    // we can't use the `DynamicStruct` proxy.
    let reflect_identifiable = registration
        .data::<ReflectIdentifiable>()
        .expect("`ReflectIdentifiable` should be registered");

    // Trying to access the registry with our `deserialized` will give a compile error
    // since it doesn't implement `Reflect`, only `PartialReflect`.
    // Similarly, trying to force the operation will fail.
    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(deserialized
        .try_as_reflect()
        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
        .is_none());

    // So how can we go from a dynamic type to a concrete type?
    // There are two ways:

    // 1. Using `PartialReflect::apply`.
    {
        // If you know the type at compile time, you can construct a new value and apply the dynamic
        // value to it.
        let mut value = Player::default();
        value.apply(deserialized.as_ref());
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you need a dynamic way of constructing
        // an instance of the type. One such way is to use the `ReflectDefault` type data.
        let reflect_default = registration
            .data::<ReflectDefault>()
            .expect("`ReflectDefault` should be registered");

        let mut value: Box<dyn Reflect> = reflect_default.default();
        value.apply(deserialized.as_ref());

        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // 2. Using `FromReflect`
    {
        // If you know the type at compile time, you can use the `FromReflect` trait to convert the
        // dynamic value into the concrete type directly.
        let value: Player = Player::from_reflect(deserialized.as_ref()).unwrap();
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you can use the `ReflectFromReflect` type data
        // to perform the conversion dynamically.
        let reflect_from_reflect = registration
            .data::<ReflectFromReflect>()
            .expect("`ReflectFromReflect` should be registered");

        let value: Box<dyn Reflect> = reflect_from_reflect
            .from_reflect(deserialized.as_ref())
            .unwrap();
        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // Lastly, while dynamic types are commonly generated via reflection methods like
    // `PartialReflect::to_dynamic` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

    // This is useful when you just need to apply some subset of changes to a type.
    let mut my_list: Vec<u32> = Vec::new();
    my_list.apply(&my_dynamic_list);
    assert_eq!(my_list, vec![1, 2, 3]);

    // And if you want it to actually proxy a type, you can configure it to do that as well:
    assert!(!my_dynamic_list
        .as_partial_reflect()
        .represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list
        .as_partial_reflect()
        .represents::<Vec<u32>>());

    // ============================= REFERENCE ============================= //
    // For reference, here are all the available dynamic types:

    // 1. `DynamicTuple`
    {
        let mut dynamic_tuple = DynamicTuple::default();
        dynamic_tuple.insert(1u32);
        dynamic_tuple.insert(2u32);
        dynamic_tuple.insert(3u32);

        let mut my_tuple: (u32, u32, u32) = (0, 0, 0);
        my_tuple.apply(&dynamic_tuple);
        assert_eq!(my_tuple, (1, 2, 3));
    }

    // 2. `DynamicArray`
    {
        let dynamic_array = DynamicArray::from_iter([1u32, 2u32, 3u32]);

        let mut my_array = [0u32; 3];
        my_array.apply(&dynamic_array);
        assert_eq!(my_array, [1, 2, 3]);
    }

    // 3. `DynamicList`
    {
        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

        let mut my_list: Vec<u32> = Vec::new();
        my_list.apply(&dynamic_list);
        assert_eq!(my_list, vec![1, 2, 3]);
    }

    // 4. `DynamicSet`
    {
        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
        assert!(dynamic_set.contains(&"x"));

        dynamic_set.remove(&"y");

        let mut my_set: HashSet<&str> = HashSet::default();
        my_set.apply(&dynamic_set);
        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
    }

    // 5. `DynamicMap`
    {
        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);

        let mut my_map: HashMap<&str, u32> = HashMap::default();
        my_map.apply(&dynamic_map);
        assert_eq!(my_map.get("x"), Some(&1));
        assert_eq!(my_map.get("y"), Some(&2));
        assert_eq!(my_map.get("z"), Some(&3));
    }

    // 6. `DynamicStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyStruct {
            x: u32,
            y: u32,
            z: u32,
        }

        let mut dynamic_struct = DynamicStruct::default();
        dynamic_struct.insert("x", 1u32);
        dynamic_struct.insert("y", 2u32);
        dynamic_struct.insert("z", 3u32);

        let mut my_struct = MyStruct::default();
        my_struct.apply(&dynamic_struct);
        assert_eq!(my_struct, MyStruct { x: 1, y: 2, z: 3 });
    }

    // 7. `DynamicTupleStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyTupleStruct(u32, u32, u32);

        let mut dynamic_tuple_struct = DynamicTupleStruct::default();
        dynamic_tuple_struct.insert(1u32);
        dynamic_tuple_struct.insert(2u32);
        dynamic_tuple_struct.insert(3u32);

        let mut my_tuple_struct = MyTupleStruct::default();
        my_tuple_struct.apply(&dynamic_tuple_struct);
        assert_eq!(my_tuple_struct, MyTupleStruct(1, 2, 3));
    }

    // 8. `DynamicEnum`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        enum MyEnum {
            #[default]
            Empty,
            Xyz(u32, u32, u32),
        }

        let mut values = DynamicTuple::default();
        values.insert(1u32);
        values.insert(2u32);
        values.insert(3u32);

        let dynamic_variant = DynamicVariant::Tuple(values);
        let dynamic_enum = DynamicEnum::new("Xyz", dynamic_variant);

        let mut my_enum = MyEnum::default();
        my_enum.apply(&dynamic_enum);
        assert_eq!(my_enum, MyEnum::Xyz(1, 2, 3));
    }
}

Implementations

impl dyn PartialReflect

pub fn represents<T>(&self) -> bool

where T: Reflect + TypePath,

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

Read is for more information on underlying values and represented types.

Examples found in repository

examples/reflection/dynamic_types.rs (line 81)

fn main() {
    #[derive(Reflect, Default, PartialEq, Debug)]
    #[reflect(Identifiable, Default)]
    struct Player {
        id: u32,
    }

    #[reflect_trait]
    trait Identifiable {
        fn id(&self) -> u32;
    }

    impl Identifiable for Player {
        fn id(&self) -> u32 {
            self.id
        }
    }

    // Normally, when instantiating a type, you get back exactly that type.
    // This is because the type is known at compile time.
    // We call this the "concrete" or "canonical" type.
    let player: Player = Player { id: 123 };

    // When working with reflected types, however, we often "erase" this type information
    // using the `Reflect` trait object.
    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
    // The underlying type is still the same (in this case, `Player`),
    // but now we've hidden that information from the compiler.
    let reflected: Box<dyn Reflect> = Box::new(player);

    // Because it's the same type under the hood, we can still downcast it back to the original type.
    assert!(reflected.downcast_ref::<Player>().is_some());

    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));

    // Another way we can "clone" our data is by converting it to a dynamic type.
    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
    // This is because it returns a dynamic type that simply represents the original type.
    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
    assert!(dynamic.is_dynamic());

    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
    assert!(dynamic.try_as_reflect().is_none());

    // Generally dynamic types are used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
    let id = dynamic_ref.field("id").unwrap().try_downcast_ref::<u32>();
    assert_eq!(id, Some(&123));

    // It also enables us to create a representation of a type without having compile-time
    // access to the actual type. This is how the reflection deserializers work.
    // They generally can't know how to construct a type ahead of time,
    // so they instead build and return these dynamic representations.
    let input = "(id: 123)";
    let mut registry = TypeRegistry::default();
    registry.register::<Player>();
    let registration = registry.get(std::any::TypeId::of::<Player>()).unwrap();
    let deserialized = TypedReflectDeserializer::new(registration, &registry)
        .deserialize(&mut ron::Deserializer::from_str(input).unwrap())
        .unwrap();

    // Our deserialized output is a `DynamicStruct` that proxies/represents a `Player`.
    assert!(deserialized.represents::<Player>());

    // And while this does allow us to access the fields and structure of the type,
    // there may be instances where we need the actual type.
    // For example, if we want to convert our `dyn Reflect` into a `dyn Identifiable`,
    // we can't use the `DynamicStruct` proxy.
    let reflect_identifiable = registration
        .data::<ReflectIdentifiable>()
        .expect("`ReflectIdentifiable` should be registered");

    // Trying to access the registry with our `deserialized` will give a compile error
    // since it doesn't implement `Reflect`, only `PartialReflect`.
    // Similarly, trying to force the operation will fail.
    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(deserialized
        .try_as_reflect()
        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
        .is_none());

    // So how can we go from a dynamic type to a concrete type?
    // There are two ways:

    // 1. Using `PartialReflect::apply`.
    {
        // If you know the type at compile time, you can construct a new value and apply the dynamic
        // value to it.
        let mut value = Player::default();
        value.apply(deserialized.as_ref());
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you need a dynamic way of constructing
        // an instance of the type. One such way is to use the `ReflectDefault` type data.
        let reflect_default = registration
            .data::<ReflectDefault>()
            .expect("`ReflectDefault` should be registered");

        let mut value: Box<dyn Reflect> = reflect_default.default();
        value.apply(deserialized.as_ref());

        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // 2. Using `FromReflect`
    {
        // If you know the type at compile time, you can use the `FromReflect` trait to convert the
        // dynamic value into the concrete type directly.
        let value: Player = Player::from_reflect(deserialized.as_ref()).unwrap();
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you can use the `ReflectFromReflect` type data
        // to perform the conversion dynamically.
        let reflect_from_reflect = registration
            .data::<ReflectFromReflect>()
            .expect("`ReflectFromReflect` should be registered");

        let value: Box<dyn Reflect> = reflect_from_reflect
            .from_reflect(deserialized.as_ref())
            .unwrap();
        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // Lastly, while dynamic types are commonly generated via reflection methods like
    // `PartialReflect::to_dynamic` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

    // This is useful when you just need to apply some subset of changes to a type.
    let mut my_list: Vec<u32> = Vec::new();
    my_list.apply(&my_dynamic_list);
    assert_eq!(my_list, vec![1, 2, 3]);

    // And if you want it to actually proxy a type, you can configure it to do that as well:
    assert!(!my_dynamic_list
        .as_partial_reflect()
        .represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list
        .as_partial_reflect()
        .represents::<Vec<u32>>());

    // ============================= REFERENCE ============================= //
    // For reference, here are all the available dynamic types:

    // 1. `DynamicTuple`
    {
        let mut dynamic_tuple = DynamicTuple::default();
        dynamic_tuple.insert(1u32);
        dynamic_tuple.insert(2u32);
        dynamic_tuple.insert(3u32);

        let mut my_tuple: (u32, u32, u32) = (0, 0, 0);
        my_tuple.apply(&dynamic_tuple);
        assert_eq!(my_tuple, (1, 2, 3));
    }

    // 2. `DynamicArray`
    {
        let dynamic_array = DynamicArray::from_iter([1u32, 2u32, 3u32]);

        let mut my_array = [0u32; 3];
        my_array.apply(&dynamic_array);
        assert_eq!(my_array, [1, 2, 3]);
    }

    // 3. `DynamicList`
    {
        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

        let mut my_list: Vec<u32> = Vec::new();
        my_list.apply(&dynamic_list);
        assert_eq!(my_list, vec![1, 2, 3]);
    }

    // 4. `DynamicSet`
    {
        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
        assert!(dynamic_set.contains(&"x"));

        dynamic_set.remove(&"y");

        let mut my_set: HashSet<&str> = HashSet::default();
        my_set.apply(&dynamic_set);
        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
    }

    // 5. `DynamicMap`
    {
        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);

        let mut my_map: HashMap<&str, u32> = HashMap::default();
        my_map.apply(&dynamic_map);
        assert_eq!(my_map.get("x"), Some(&1));
        assert_eq!(my_map.get("y"), Some(&2));
        assert_eq!(my_map.get("z"), Some(&3));
    }

    // 6. `DynamicStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyStruct {
            x: u32,
            y: u32,
            z: u32,
        }

        let mut dynamic_struct = DynamicStruct::default();
        dynamic_struct.insert("x", 1u32);
        dynamic_struct.insert("y", 2u32);
        dynamic_struct.insert("z", 3u32);

        let mut my_struct = MyStruct::default();
        my_struct.apply(&dynamic_struct);
        assert_eq!(my_struct, MyStruct { x: 1, y: 2, z: 3 });
    }

    // 7. `DynamicTupleStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyTupleStruct(u32, u32, u32);

        let mut dynamic_tuple_struct = DynamicTupleStruct::default();
        dynamic_tuple_struct.insert(1u32);
        dynamic_tuple_struct.insert(2u32);
        dynamic_tuple_struct.insert(3u32);

        let mut my_tuple_struct = MyTupleStruct::default();
        my_tuple_struct.apply(&dynamic_tuple_struct);
        assert_eq!(my_tuple_struct, MyTupleStruct(1, 2, 3));
    }

    // 8. `DynamicEnum`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        enum MyEnum {
            #[default]
            Empty,
            Xyz(u32, u32, u32),
        }

        let mut values = DynamicTuple::default();
        values.insert(1u32);
        values.insert(2u32);
        values.insert(3u32);

        let dynamic_variant = DynamicVariant::Tuple(values);
        let dynamic_enum = DynamicEnum::new("Xyz", dynamic_variant);

        let mut my_enum = MyEnum::default();
        my_enum.apply(&dynamic_enum);
        assert_eq!(my_enum, MyEnum::Xyz(1, 2, 3));
    }
}

pub fn try_downcast<T>( self: Box<dyn PartialReflect>, ) -> Result<Box<T>, Box<dyn PartialReflect>>

where T: Any,

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

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

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

pub fn try_take<T>( self: Box<dyn PartialReflect>, ) -> Result<T, Box<dyn PartialReflect>>

where T: Any,

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

If the underlying value does not implement Reflect or 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/function_reflection.rs (line 58)

fn main() {
    // There are times when it may be helpful to store a function away for later.
    // In Rust, we can do this by storing either a function pointer or a function trait object.
    // For example, say we wanted to store the following function:
    fn add(left: i32, right: i32) -> i32 {
        left + right
    }

    // We could store it as either of the following:
    let fn_pointer: fn(i32, i32) -> i32 = add;
    let fn_trait_object: Box<dyn Fn(i32, i32) -> i32> = Box::new(add);

    // And we can call them like so:
    let result = fn_pointer(2, 2);
    assert_eq!(result, 4);
    let result = fn_trait_object(2, 2);
    assert_eq!(result, 4);

    // However, you'll notice that we have to know the types of the arguments and return value at compile time.
    // This means there's not really a way to store or call these functions dynamically at runtime.
    // Luckily, Bevy's reflection crate comes with a set of tools for doing just that!
    // We do this by first converting our function into the reflection-based `DynamicFunction` type
    // using the `IntoFunction` trait.
    let function: DynamicFunction<'static> = dbg!(add.into_function());

    // This time, you'll notice that `DynamicFunction` doesn't take any information about the function's arguments or return value.
    // This is because `DynamicFunction` checks the types of the arguments and return value at runtime.
    // Now we can generate a list of arguments:
    let args: ArgList = dbg!(ArgList::new().with_owned(2_i32).with_owned(2_i32));

    // And finally, we can call the function.
    // This returns a `Result` indicating whether the function was called successfully.
    // For now, we'll just unwrap it to get our `Return` value,
    // which is an enum containing the function's return value.
    let return_value: Return = dbg!(function.call(args).unwrap());

    // The `Return` value can be pattern matched or unwrapped to get the underlying reflection data.
    // For the sake of brevity, we'll just unwrap it here and downcast it to the expected type of `i32`.
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<i32>().unwrap(), 4);

    // The same can also be done for closures that capture references to their environment.
    // Closures that capture their environment immutably can be converted into a `DynamicFunction`
    // using the `IntoFunction` trait.
    let minimum = 5;
    let clamp = |value: i32| value.max(minimum);

    let function: DynamicFunction = dbg!(clamp.into_function());
    let args = dbg!(ArgList::new().with_owned(2_i32));
    let return_value = dbg!(function.call(args).unwrap());
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<i32>().unwrap(), 5);

    // We can also handle closures that capture their environment mutably
    // using the `IntoFunctionMut` trait.
    let mut count = 0;
    let increment = |amount: i32| count += amount;

    let closure: DynamicFunctionMut = dbg!(increment.into_function_mut());
    let args = dbg!(ArgList::new().with_owned(5_i32));

    // Because `DynamicFunctionMut` mutably borrows `total`,
    // it will need to be dropped before `total` can be accessed again.
    // This can be done manually with `drop(closure)` or by using the `DynamicFunctionMut::call_once` method.
    dbg!(closure.call_once(args).unwrap());
    assert_eq!(count, 5);

    // Generic functions can also be converted into a `DynamicFunction`,
    // however, they will need to be manually monomorphized first.
    fn stringify<T: ToString>(value: T) -> String {
        value.to_string()
    }

    // We have to manually specify the concrete generic type we want to use.
    let function = stringify::<i32>.into_function();

    let args = ArgList::new().with_owned(123_i32);
    let return_value = function.call(args).unwrap();
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<String>().unwrap(), "123");

    // To make things a little easier, we can also "overload" functions.
    // This makes it so that a single `DynamicFunction` can represent multiple functions,
    // and the correct one is chosen based on the types of the arguments.
    // Each function overload must have a unique argument signature.
    let function = stringify::<i32>
        .into_function()
        .with_overload(stringify::<f32>);

    // Now our `function` accepts both `i32` and `f32` arguments.
    let args = ArgList::new().with_owned(1.23_f32);
    let return_value = function.call(args).unwrap();
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<String>().unwrap(), "1.23");

    // Function overloading even allows us to have a variable number of arguments.
    let function = (|| 0)
        .into_function()
        .with_overload(|a: i32| a)
        .with_overload(|a: i32, b: i32| a + b)
        .with_overload(|a: i32, b: i32, c: i32| a + b + c);

    let args = ArgList::new()
        .with_owned(1_i32)
        .with_owned(2_i32)
        .with_owned(3_i32);
    let return_value = function.call(args).unwrap();
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<i32>().unwrap(), 6);

    // As stated earlier, `IntoFunction` works for many kinds of simple functions.
    // Functions with non-reflectable arguments or return values may not be able to be converted.
    // Generic functions are also not supported (unless manually monomorphized like `foo::<i32>.into_function()`).
    // Additionally, the lifetime of the return value is tied to the lifetime of the first argument.
    // However, this means that many methods (i.e. functions with a `self` parameter) are also supported:
    #[derive(Reflect, Default)]
    struct Data {
        value: String,
    }

    impl Data {
        fn set_value(&mut self, value: String) {
            self.value = value;
        }

        // Note that only `&'static str` implements `Reflect`.
        // To get around this limitation we can use `&String` instead.
        fn get_value(&self) -> &String {
            &self.value
        }
    }

    let mut data = Data::default();

    let set_value = dbg!(Data::set_value.into_function());
    let args = dbg!(ArgList::new().with_mut(&mut data)).with_owned(String::from("Hello, world!"));
    dbg!(set_value.call(args).unwrap());
    assert_eq!(data.value, "Hello, world!");

    let get_value = dbg!(Data::get_value.into_function());
    let args = dbg!(ArgList::new().with_ref(&data));
    let return_value = dbg!(get_value.call(args).unwrap());
    let value: &dyn PartialReflect = return_value.unwrap_ref();
    assert_eq!(value.try_downcast_ref::<String>().unwrap(), "Hello, world!");

    // For more complex use cases, you can always create a custom `DynamicFunction` manually.
    // This is useful for functions that can't be converted via the `IntoFunction` trait.
    // For example, this function doesn't implement `IntoFunction` due to the fact that
    // the lifetime of the return value is not tied to the lifetime of the first argument.
    fn get_or_insert(value: i32, container: &mut Option<i32>) -> &i32 {
        if container.is_none() {
            *container = Some(value);
        }

        container.as_ref().unwrap()
    }

    let get_or_insert_function = dbg!(DynamicFunction::new(
        |mut args: ArgList| -> FunctionResult {
            // The `ArgList` contains the arguments in the order they were pushed.
            // The `DynamicFunction` will validate that the list contains
            // exactly the number of arguments we expect.
            // We can retrieve them out in order (note that this modifies the `ArgList`):
            let value = args.take::<i32>()?;
            let container = args.take::<&mut Option<i32>>()?;

            // We could have also done the following to make use of type inference:
            // let value = args.take_owned()?;
            // let container = args.take_mut()?;

            Ok(Return::Ref(get_or_insert(value, container)))
        },
        // Functions can be either anonymous or named.
        // It's good practice, though, to try and name your functions whenever possible.
        // This makes it easier to debug and is also required for function registration.
        // We can either give it a custom name or use the function's type name as
        // derived from `std::any::type_name_of_val`.
        SignatureInfo::named(std::any::type_name_of_val(&get_or_insert))
            // We can always change the name if needed.
            // It's a good idea to also ensure that the name is unique,
            // such as by using its type name or by prefixing it with your crate name.
            .with_name("my_crate::get_or_insert")
            // Since our function takes arguments, we should provide that argument information.
            // This is used to validate arguments when calling the function.
            // And it aids consumers of the function with their own validation and debugging.
            // Arguments should be provided in the order they are defined in the function.
            .with_arg::<i32>("value")
            .with_arg::<&mut Option<i32>>("container")
            // We can provide return information as well.
            .with_return::<&i32>(),
    ));

    let mut container: Option<i32> = None;

    let args = dbg!(ArgList::new().with_owned(5_i32).with_mut(&mut container));
    let value = dbg!(get_or_insert_function.call(args).unwrap()).unwrap_ref();
    assert_eq!(value.try_downcast_ref::<i32>(), Some(&5));

    let args = dbg!(ArgList::new().with_owned(500_i32).with_mut(&mut container));
    let value = dbg!(get_or_insert_function.call(args).unwrap()).unwrap_ref();
    assert_eq!(value.try_downcast_ref::<i32>(), Some(&5));
}

pub fn try_downcast_ref<T>(&self) -> Option<&T>

where T: Any,

Downcasts the value to type T by reference.

If the underlying value does not implement Reflect or 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/reflection_types.rs (line 49)

#[reflect(Hash, PartialEq, Clone)]
pub struct E {
    x: usize,
}

/// By default, deriving with Reflect assumes the type is either a "struct" or an "enum".
///
/// You can tell reflect to treat your type instead as an "opaque type" by using the `#[reflect(opaque)]`.
/// It is generally a good idea to implement (and reflect) the `PartialEq` and `Clone` (optionally also `Serialize` and `Deserialize`)
/// traits on opaque types to ensure that these values behave as expected when nested in other reflected types.
#[derive(Reflect, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[reflect(opaque)]
#[reflect(PartialEq

examples/reflection/reflection.rs (line 79)

fn setup(type_registry: Res<AppTypeRegistry>) {
    let mut value = Foo {
        a: 1,
        _ignored: NonReflectedValue { _a: 10 },
        nested: Bar { b: 8 },
    };

    // You can set field values like this. The type must match exactly or this will fail.
    *value.get_field_mut("a").unwrap() = 2usize;
    assert_eq!(value.a, 2);
    assert_eq!(*value.get_field::<usize>("a").unwrap(), 2);

    // You can also get the `&dyn PartialReflect` value of a field like this
    let field = value.field("a").unwrap();

    // But values introspected via `PartialReflect` will not return `dyn Reflect` trait objects
    // (even if the containing type does implement `Reflect`), so we need to convert them:
    let fully_reflected_field = field.try_as_reflect().unwrap();

    // Now, you can downcast your `Reflect` value like this:
    assert_eq!(*fully_reflected_field.downcast_ref::<usize>().unwrap(), 2);

    // For this specific case, we also support the shortcut `try_downcast_ref`:
    assert_eq!(*field.try_downcast_ref::<usize>().unwrap(), 2);

    // `DynamicStruct` also implements the `Struct` and `Reflect` traits.
    let mut patch = DynamicStruct::default();
    patch.insert("a", 4usize);

    // You can "apply" Reflect implementations on top of other Reflect implementations.
    // This will only set fields with the same name, and it will fail if the types don't match.
    // You can use this to "patch" your types with new values.
    value.apply(&patch);
    assert_eq!(value.a, 4);

    let type_registry = type_registry.read();
    // By default, all derived `Reflect` types can be Serialized using serde. No need to derive
    // Serialize!
    let serializer = ReflectSerializer::new(&value, &type_registry);
    let ron_string =
        ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
    info!("{}\n", ron_string);

    // Dynamic properties can be deserialized
    let reflect_deserializer = ReflectDeserializer::new(&type_registry);
    let mut deserializer = ron::de::Deserializer::from_str(&ron_string).unwrap();
    let reflect_value = reflect_deserializer.deserialize(&mut deserializer).unwrap();

    // Deserializing returns a `Box<dyn PartialReflect>` value.
    // Generally, deserializing a value will return the "dynamic" variant of a type.
    // For example, deserializing a struct will return the DynamicStruct type.
    // "Opaque types" will be deserialized as themselves.
    assert_eq!(
        reflect_value.reflect_type_path(),
        DynamicStruct::type_path(),
    );

    // Reflect has its own `partial_eq` implementation, named `reflect_partial_eq`. This behaves
    // like normal `partial_eq`, but it treats "dynamic" and "non-dynamic" types the same. The
    // `Foo` struct and deserialized `DynamicStruct` are considered equal for this reason:
    assert!(reflect_value.reflect_partial_eq(&value).unwrap());

    // By "patching" `Foo` with the deserialized DynamicStruct, we can "Deserialize" Foo.
    // This means we can serialize and deserialize with a single `Reflect` derive!
    value.apply(&*reflect_value);
}

examples/reflection/function_reflection.rs (line 162)

fn main() {
    // There are times when it may be helpful to store a function away for later.
    // In Rust, we can do this by storing either a function pointer or a function trait object.
    // For example, say we wanted to store the following function:
    fn add(left: i32, right: i32) -> i32 {
        left + right
    }

    // We could store it as either of the following:
    let fn_pointer: fn(i32, i32) -> i32 = add;
    let fn_trait_object: Box<dyn Fn(i32, i32) -> i32> = Box::new(add);

    // And we can call them like so:
    let result = fn_pointer(2, 2);
    assert_eq!(result, 4);
    let result = fn_trait_object(2, 2);
    assert_eq!(result, 4);

    // However, you'll notice that we have to know the types of the arguments and return value at compile time.
    // This means there's not really a way to store or call these functions dynamically at runtime.
    // Luckily, Bevy's reflection crate comes with a set of tools for doing just that!
    // We do this by first converting our function into the reflection-based `DynamicFunction` type
    // using the `IntoFunction` trait.
    let function: DynamicFunction<'static> = dbg!(add.into_function());

    // This time, you'll notice that `DynamicFunction` doesn't take any information about the function's arguments or return value.
    // This is because `DynamicFunction` checks the types of the arguments and return value at runtime.
    // Now we can generate a list of arguments:
    let args: ArgList = dbg!(ArgList::new().with_owned(2_i32).with_owned(2_i32));

    // And finally, we can call the function.
    // This returns a `Result` indicating whether the function was called successfully.
    // For now, we'll just unwrap it to get our `Return` value,
    // which is an enum containing the function's return value.
    let return_value: Return = dbg!(function.call(args).unwrap());

    // The `Return` value can be pattern matched or unwrapped to get the underlying reflection data.
    // For the sake of brevity, we'll just unwrap it here and downcast it to the expected type of `i32`.
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<i32>().unwrap(), 4);

    // The same can also be done for closures that capture references to their environment.
    // Closures that capture their environment immutably can be converted into a `DynamicFunction`
    // using the `IntoFunction` trait.
    let minimum = 5;
    let clamp = |value: i32| value.max(minimum);

    let function: DynamicFunction = dbg!(clamp.into_function());
    let args = dbg!(ArgList::new().with_owned(2_i32));
    let return_value = dbg!(function.call(args).unwrap());
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<i32>().unwrap(), 5);

    // We can also handle closures that capture their environment mutably
    // using the `IntoFunctionMut` trait.
    let mut count = 0;
    let increment = |amount: i32| count += amount;

    let closure: DynamicFunctionMut = dbg!(increment.into_function_mut());
    let args = dbg!(ArgList::new().with_owned(5_i32));

    // Because `DynamicFunctionMut` mutably borrows `total`,
    // it will need to be dropped before `total` can be accessed again.
    // This can be done manually with `drop(closure)` or by using the `DynamicFunctionMut::call_once` method.
    dbg!(closure.call_once(args).unwrap());
    assert_eq!(count, 5);

    // Generic functions can also be converted into a `DynamicFunction`,
    // however, they will need to be manually monomorphized first.
    fn stringify<T: ToString>(value: T) -> String {
        value.to_string()
    }

    // We have to manually specify the concrete generic type we want to use.
    let function = stringify::<i32>.into_function();

    let args = ArgList::new().with_owned(123_i32);
    let return_value = function.call(args).unwrap();
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<String>().unwrap(), "123");

    // To make things a little easier, we can also "overload" functions.
    // This makes it so that a single `DynamicFunction` can represent multiple functions,
    // and the correct one is chosen based on the types of the arguments.
    // Each function overload must have a unique argument signature.
    let function = stringify::<i32>
        .into_function()
        .with_overload(stringify::<f32>);

    // Now our `function` accepts both `i32` and `f32` arguments.
    let args = ArgList::new().with_owned(1.23_f32);
    let return_value = function.call(args).unwrap();
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<String>().unwrap(), "1.23");

    // Function overloading even allows us to have a variable number of arguments.
    let function = (|| 0)
        .into_function()
        .with_overload(|a: i32| a)
        .with_overload(|a: i32, b: i32| a + b)
        .with_overload(|a: i32, b: i32, c: i32| a + b + c);

    let args = ArgList::new()
        .with_owned(1_i32)
        .with_owned(2_i32)
        .with_owned(3_i32);
    let return_value = function.call(args).unwrap();
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<i32>().unwrap(), 6);

    // As stated earlier, `IntoFunction` works for many kinds of simple functions.
    // Functions with non-reflectable arguments or return values may not be able to be converted.
    // Generic functions are also not supported (unless manually monomorphized like `foo::<i32>.into_function()`).
    // Additionally, the lifetime of the return value is tied to the lifetime of the first argument.
    // However, this means that many methods (i.e. functions with a `self` parameter) are also supported:
    #[derive(Reflect, Default)]
    struct Data {
        value: String,
    }

    impl Data {
        fn set_value(&mut self, value: String) {
            self.value = value;
        }

        // Note that only `&'static str` implements `Reflect`.
        // To get around this limitation we can use `&String` instead.
        fn get_value(&self) -> &String {
            &self.value
        }
    }

    let mut data = Data::default();

    let set_value = dbg!(Data::set_value.into_function());
    let args = dbg!(ArgList::new().with_mut(&mut data)).with_owned(String::from("Hello, world!"));
    dbg!(set_value.call(args).unwrap());
    assert_eq!(data.value, "Hello, world!");

    let get_value = dbg!(Data::get_value.into_function());
    let args = dbg!(ArgList::new().with_ref(&data));
    let return_value = dbg!(get_value.call(args).unwrap());
    let value: &dyn PartialReflect = return_value.unwrap_ref();
    assert_eq!(value.try_downcast_ref::<String>().unwrap(), "Hello, world!");

    // For more complex use cases, you can always create a custom `DynamicFunction` manually.
    // This is useful for functions that can't be converted via the `IntoFunction` trait.
    // For example, this function doesn't implement `IntoFunction` due to the fact that
    // the lifetime of the return value is not tied to the lifetime of the first argument.
    fn get_or_insert(value: i32, container: &mut Option<i32>) -> &i32 {
        if container.is_none() {
            *container = Some(value);
        }

        container.as_ref().unwrap()
    }

    let get_or_insert_function = dbg!(DynamicFunction::new(
        |mut args: ArgList| -> FunctionResult {
            // The `ArgList` contains the arguments in the order they were pushed.
            // The `DynamicFunction` will validate that the list contains
            // exactly the number of arguments we expect.
            // We can retrieve them out in order (note that this modifies the `ArgList`):
            let value = args.take::<i32>()?;
            let container = args.take::<&mut Option<i32>>()?;

            // We could have also done the following to make use of type inference:
            // let value = args.take_owned()?;
            // let container = args.take_mut()?;

            Ok(Return::Ref(get_or_insert(value, container)))
        },
        // Functions can be either anonymous or named.
        // It's good practice, though, to try and name your functions whenever possible.
        // This makes it easier to debug and is also required for function registration.
        // We can either give it a custom name or use the function's type name as
        // derived from `std::any::type_name_of_val`.
        SignatureInfo::named(std::any::type_name_of_val(&get_or_insert))
            // We can always change the name if needed.
            // It's a good idea to also ensure that the name is unique,
            // such as by using its type name or by prefixing it with your crate name.
            .with_name("my_crate::get_or_insert")
            // Since our function takes arguments, we should provide that argument information.
            // This is used to validate arguments when calling the function.
            // And it aids consumers of the function with their own validation and debugging.
            // Arguments should be provided in the order they are defined in the function.
            .with_arg::<i32>("value")
            .with_arg::<&mut Option<i32>>("container")
            // We can provide return information as well.
            .with_return::<&i32>(),
    ));

    let mut container: Option<i32> = None;

    let args = dbg!(ArgList::new().with_owned(5_i32).with_mut(&mut container));
    let value = dbg!(get_or_insert_function.call(args).unwrap()).unwrap_ref();
    assert_eq!(value.try_downcast_ref::<i32>(), Some(&5));

    let args = dbg!(ArgList::new().with_owned(500_i32).with_mut(&mut container));
    let value = dbg!(get_or_insert_function.call(args).unwrap()).unwrap_ref();
    assert_eq!(value.try_downcast_ref::<i32>(), Some(&5));
}

examples/reflection/dynamic_types.rs (line 65)

fn main() {
    #[derive(Reflect, Default, PartialEq, Debug)]
    #[reflect(Identifiable, Default)]
    struct Player {
        id: u32,
    }

    #[reflect_trait]
    trait Identifiable {
        fn id(&self) -> u32;
    }

    impl Identifiable for Player {
        fn id(&self) -> u32 {
            self.id
        }
    }

    // Normally, when instantiating a type, you get back exactly that type.
    // This is because the type is known at compile time.
    // We call this the "concrete" or "canonical" type.
    let player: Player = Player { id: 123 };

    // When working with reflected types, however, we often "erase" this type information
    // using the `Reflect` trait object.
    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
    // The underlying type is still the same (in this case, `Player`),
    // but now we've hidden that information from the compiler.
    let reflected: Box<dyn Reflect> = Box::new(player);

    // Because it's the same type under the hood, we can still downcast it back to the original type.
    assert!(reflected.downcast_ref::<Player>().is_some());

    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));

    // Another way we can "clone" our data is by converting it to a dynamic type.
    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
    // This is because it returns a dynamic type that simply represents the original type.
    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
    assert!(dynamic.is_dynamic());

    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
    assert!(dynamic.try_as_reflect().is_none());

    // Generally dynamic types are used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
    let id = dynamic_ref.field("id").unwrap().try_downcast_ref::<u32>();
    assert_eq!(id, Some(&123));

    // It also enables us to create a representation of a type without having compile-time
    // access to the actual type. This is how the reflection deserializers work.
    // They generally can't know how to construct a type ahead of time,
    // so they instead build and return these dynamic representations.
    let input = "(id: 123)";
    let mut registry = TypeRegistry::default();
    registry.register::<Player>();
    let registration = registry.get(std::any::TypeId::of::<Player>()).unwrap();
    let deserialized = TypedReflectDeserializer::new(registration, &registry)
        .deserialize(&mut ron::Deserializer::from_str(input).unwrap())
        .unwrap();

    // Our deserialized output is a `DynamicStruct` that proxies/represents a `Player`.
    assert!(deserialized.represents::<Player>());

    // And while this does allow us to access the fields and structure of the type,
    // there may be instances where we need the actual type.
    // For example, if we want to convert our `dyn Reflect` into a `dyn Identifiable`,
    // we can't use the `DynamicStruct` proxy.
    let reflect_identifiable = registration
        .data::<ReflectIdentifiable>()
        .expect("`ReflectIdentifiable` should be registered");

    // Trying to access the registry with our `deserialized` will give a compile error
    // since it doesn't implement `Reflect`, only `PartialReflect`.
    // Similarly, trying to force the operation will fail.
    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(deserialized
        .try_as_reflect()
        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
        .is_none());

    // So how can we go from a dynamic type to a concrete type?
    // There are two ways:

    // 1. Using `PartialReflect::apply`.
    {
        // If you know the type at compile time, you can construct a new value and apply the dynamic
        // value to it.
        let mut value = Player::default();
        value.apply(deserialized.as_ref());
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you need a dynamic way of constructing
        // an instance of the type. One such way is to use the `ReflectDefault` type data.
        let reflect_default = registration
            .data::<ReflectDefault>()
            .expect("`ReflectDefault` should be registered");

        let mut value: Box<dyn Reflect> = reflect_default.default();
        value.apply(deserialized.as_ref());

        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // 2. Using `FromReflect`
    {
        // If you know the type at compile time, you can use the `FromReflect` trait to convert the
        // dynamic value into the concrete type directly.
        let value: Player = Player::from_reflect(deserialized.as_ref()).unwrap();
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you can use the `ReflectFromReflect` type data
        // to perform the conversion dynamically.
        let reflect_from_reflect = registration
            .data::<ReflectFromReflect>()
            .expect("`ReflectFromReflect` should be registered");

        let value: Box<dyn Reflect> = reflect_from_reflect
            .from_reflect(deserialized.as_ref())
            .unwrap();
        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // Lastly, while dynamic types are commonly generated via reflection methods like
    // `PartialReflect::to_dynamic` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

    // This is useful when you just need to apply some subset of changes to a type.
    let mut my_list: Vec<u32> = Vec::new();
    my_list.apply(&my_dynamic_list);
    assert_eq!(my_list, vec![1, 2, 3]);

    // And if you want it to actually proxy a type, you can configure it to do that as well:
    assert!(!my_dynamic_list
        .as_partial_reflect()
        .represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list
        .as_partial_reflect()
        .represents::<Vec<u32>>());

    // ============================= REFERENCE ============================= //
    // For reference, here are all the available dynamic types:

    // 1. `DynamicTuple`
    {
        let mut dynamic_tuple = DynamicTuple::default();
        dynamic_tuple.insert(1u32);
        dynamic_tuple.insert(2u32);
        dynamic_tuple.insert(3u32);

        let mut my_tuple: (u32, u32, u32) = (0, 0, 0);
        my_tuple.apply(&dynamic_tuple);
        assert_eq!(my_tuple, (1, 2, 3));
    }

    // 2. `DynamicArray`
    {
        let dynamic_array = DynamicArray::from_iter([1u32, 2u32, 3u32]);

        let mut my_array = [0u32; 3];
        my_array.apply(&dynamic_array);
        assert_eq!(my_array, [1, 2, 3]);
    }

    // 3. `DynamicList`
    {
        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

        let mut my_list: Vec<u32> = Vec::new();
        my_list.apply(&dynamic_list);
        assert_eq!(my_list, vec![1, 2, 3]);
    }

    // 4. `DynamicSet`
    {
        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
        assert!(dynamic_set.contains(&"x"));

        dynamic_set.remove(&"y");

        let mut my_set: HashSet<&str> = HashSet::default();
        my_set.apply(&dynamic_set);
        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
    }

    // 5. `DynamicMap`
    {
        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);

        let mut my_map: HashMap<&str, u32> = HashMap::default();
        my_map.apply(&dynamic_map);
        assert_eq!(my_map.get("x"), Some(&1));
        assert_eq!(my_map.get("y"), Some(&2));
        assert_eq!(my_map.get("z"), Some(&3));
    }

    // 6. `DynamicStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyStruct {
            x: u32,
            y: u32,
            z: u32,
        }

        let mut dynamic_struct = DynamicStruct::default();
        dynamic_struct.insert("x", 1u32);
        dynamic_struct.insert("y", 2u32);
        dynamic_struct.insert("z", 3u32);

        let mut my_struct = MyStruct::default();
        my_struct.apply(&dynamic_struct);
        assert_eq!(my_struct, MyStruct { x: 1, y: 2, z: 3 });
    }

    // 7. `DynamicTupleStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyTupleStruct(u32, u32, u32);

        let mut dynamic_tuple_struct = DynamicTupleStruct::default();
        dynamic_tuple_struct.insert(1u32);
        dynamic_tuple_struct.insert(2u32);
        dynamic_tuple_struct.insert(3u32);

        let mut my_tuple_struct = MyTupleStruct::default();
        my_tuple_struct.apply(&dynamic_tuple_struct);
        assert_eq!(my_tuple_struct, MyTupleStruct(1, 2, 3));
    }

    // 8. `DynamicEnum`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        enum MyEnum {
            #[default]
            Empty,
            Xyz(u32, u32, u32),
        }

        let mut values = DynamicTuple::default();
        values.insert(1u32);
        values.insert(2u32);
        values.insert(3u32);

        let dynamic_variant = DynamicVariant::Tuple(values);
        let dynamic_enum = DynamicEnum::new("Xyz", dynamic_variant);

        let mut my_enum = MyEnum::default();
        my_enum.apply(&dynamic_enum);
        assert_eq!(my_enum, MyEnum::Xyz(1, 2, 3));
    }
}

pub fn try_downcast_mut<T>(&mut self) -> Option<&mut T>

where T: Any,

Downcasts the value to type T by mutable reference.

If the underlying value does not implement Reflect or is not of type T, returns None.

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

Trait Implementations

impl Debug for dyn PartialReflect

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

Formats the value using the given formatter.

impl TypePath for dyn PartialReflect

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

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

Returns the name of the type, or None if it is anonymous.

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

Returns the name of the crate the type is in, or None if it is anonymous.

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

Returns the path to the module the type is in, or None if it is anonymous.

Implementations on Foreign Types

impl PartialReflect for &'static str

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

fn into_partial_reflect(self: Box<&'static str>) -> Box<dyn PartialReflect>

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

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

fn try_into_reflect( self: Box<&'static str>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

fn reflect_owned(self: Box<&'static str>) -> ReflectOwned

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

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

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

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

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

impl PartialReflect for &'static Location<'static>

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

fn into_partial_reflect( self: Box<&'static Location<'static>>, ) -> Box<dyn PartialReflect>

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

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

fn try_into_reflect( self: Box<&'static Location<'static>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<&'static Location<'static>>) -> ReflectOwned

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

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

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

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

impl PartialReflect for &'static Path

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

fn into_partial_reflect(self: Box<&'static Path>) -> Box<dyn PartialReflect>

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

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

fn try_into_reflect( self: Box<&'static Path>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<&'static Path>) -> ReflectOwned

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

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

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

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

impl PartialReflect for Cow<'static, str>

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

fn into_partial_reflect(self: Box<Cow<'static, str>>) -> Box<dyn PartialReflect>

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<Cow<'static, str>>) -> ReflectOwned

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

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

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

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

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

impl PartialReflect for Cow<'static, Path>

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

fn into_partial_reflect( self: Box<Cow<'static, Path>>, ) -> Box<dyn PartialReflect>

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<Cow<'static, Path>>) -> ReflectOwned

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

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

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

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

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

impl PartialReflect for SocketAddr

where SocketAddr: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<SocketAddr>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for bool

where bool: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<bool>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for char

where char: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<char>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for f32

where f32: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<f32>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

impl PartialReflect for f64

where f64: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<f64>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

impl PartialReflect for i8

where i8: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<i8>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for i16

where i16: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<i16>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for i32

where i32: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<i32>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for i64

where i64: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<i64>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for i128

where i128: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<i128>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for isize

where isize: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<isize>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for u8

where u8: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<u8>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for u16

where u16: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<u16>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for u32

where u32: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<u32>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for u64

where u64: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<u64>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for u128

where u128: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<u128>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for ()

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

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

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

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

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

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

impl PartialReflect for usize

where usize: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<usize>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for TypeId

where TypeId: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<TypeId>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for NonZero<i8>

where NonZero<i8>: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NonZero<i8>>) -> ReflectOwned

fn try_into_reflect( self: Box<NonZero<i8>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

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

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

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

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

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

impl PartialReflect for NonZero<i16>

where NonZero<i16>: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NonZero<i16>>) -> ReflectOwned

fn try_into_reflect( self: Box<NonZero<i16>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

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

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

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

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

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

impl PartialReflect for NonZero<i32>

where NonZero<i32>: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NonZero<i32>>) -> ReflectOwned

fn try_into_reflect( self: Box<NonZero<i32>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

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

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

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

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

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

impl PartialReflect for NonZero<i64>

where NonZero<i64>: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NonZero<i64>>) -> ReflectOwned

fn try_into_reflect( self: Box<NonZero<i64>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

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

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

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

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

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

impl PartialReflect for NonZero<i128>

where NonZero<i128>: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NonZero<i128>>) -> ReflectOwned

fn try_into_reflect( self: Box<NonZero<i128>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

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

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

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

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

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

impl PartialReflect for NonZero<isize>

where NonZero<isize>: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NonZero<isize>>) -> ReflectOwned

fn try_into_reflect( self: Box<NonZero<isize>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

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

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

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

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

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

impl PartialReflect for NonZero<u8>

where NonZero<u8>: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NonZero<u8>>) -> ReflectOwned

fn try_into_reflect( self: Box<NonZero<u8>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

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

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

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

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

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

impl PartialReflect for NonZero<u16>

where NonZero<u16>: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NonZero<u16>>) -> ReflectOwned

fn try_into_reflect( self: Box<NonZero<u16>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

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

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

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

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

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

impl PartialReflect for NonZero<u32>

where NonZero<u32>: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NonZero<u32>>) -> ReflectOwned

fn try_into_reflect( self: Box<NonZero<u32>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

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

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

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

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

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

impl PartialReflect for NonZero<u64>

where NonZero<u64>: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NonZero<u64>>) -> ReflectOwned

fn try_into_reflect( self: Box<NonZero<u64>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

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

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

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

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

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

impl PartialReflect for NonZero<u128>

where NonZero<u128>: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NonZero<u128>>) -> ReflectOwned

fn try_into_reflect( self: Box<NonZero<u128>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

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

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

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

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

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

impl PartialReflect for NonZero<usize>

where NonZero<usize>: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NonZero<usize>>) -> ReflectOwned

fn try_into_reflect( self: Box<NonZero<usize>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

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

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

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

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

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

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

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

impl PartialReflect for RangeFull

where RangeFull: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<RangeFull>) -> ReflectOwned

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

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

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

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

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

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

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

impl PartialReflect for Duration

where Duration: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<Duration>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for OsString

where OsString: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<OsString>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for PathBuf

where PathBuf: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<PathBuf>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl PartialReflect for NodeIndex

where NodeIndex: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<NodeIndex>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

impl PartialReflect for SmolStr

where SmolStr: Any + Send + Sync,

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<SmolStr>) -> ReflectOwned

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

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

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

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

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

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

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

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

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

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

impl<A> PartialReflect for (A,)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<(A,)>) -> ReflectOwned

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

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

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

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

impl<A, B> PartialReflect for (A, B)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

fn into_partial_reflect(self: Box<(A, B)>) -> Box<dyn PartialReflect>

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

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

fn try_into_reflect( self: Box<(A, B)>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<(A, B)>) -> ReflectOwned

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

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

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

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

impl<A, B, C> PartialReflect for (A, B, C)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

fn into_partial_reflect(self: Box<(A, B, C)>) -> Box<dyn PartialReflect>

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

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

fn try_into_reflect( self: Box<(A, B, C)>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<(A, B, C)>) -> ReflectOwned

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

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

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

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

impl<A, B, C, D> PartialReflect 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,

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

fn into_partial_reflect(self: Box<(A, B, C, D)>) -> Box<dyn PartialReflect>

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<(A, B, C, D)>) -> ReflectOwned

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

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

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

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

impl<A, B, C, D, E> PartialReflect 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,

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

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

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<(A, B, C, D, E)>) -> ReflectOwned

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

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

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

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

impl<A, B, C, D, E, F> PartialReflect 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,

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

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

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<(A, B, C, D, E, F)>) -> ReflectOwned

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

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

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

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

impl<A, B, C, D, E, F, G> PartialReflect 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,

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

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

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<(A, B, C, D, E, F, G)>) -> ReflectOwned

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

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

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

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

impl<A, B, C, D, E, F, G, H> PartialReflect 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,

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

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

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<(A, B, C, D, E, F, G, H)>) -> ReflectOwned

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

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

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

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

impl<A, B, C, D, E, F, G, H, I> PartialReflect 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,

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

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

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<(A, B, C, D, E, F, G, H, I)>) -> ReflectOwned

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

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

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

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

impl<A, B, C, D, E, F, G, H, I, J> PartialReflect 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,

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

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

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K> PartialReflect 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,

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

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

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L> PartialReflect 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,

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

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

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

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

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

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

impl<K, V> PartialReflect for BTreeMap<K, V>

where K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Ord, V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,

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

fn into_partial_reflect(self: Box<BTreeMap<K, V>>) -> Box<dyn PartialReflect>

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

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

fn try_into_reflect( self: Box<BTreeMap<K, V>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<BTreeMap<K, V>>) -> ReflectOwned

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

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

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

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

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

where K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Hash, V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration, S: TypePath + BuildHasher + Default + Send + Sync,

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

fn into_partial_reflect(self: Box<HashMap<K, V, S>>) -> Box<dyn PartialReflect>

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

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

fn try_into_reflect( self: Box<HashMap<K, V, S>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<HashMap<K, V, S>>) -> ReflectOwned

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

impl<N, E, Ix> PartialReflect for Graph<N, E, Directed, Ix>

where N: Clone + TypePath, E: Clone + TypePath, Ix: IndexType + TypePath, Graph<N, E, Directed, Ix>: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<Graph<N, E, Directed, Ix>>) -> ReflectOwned

fn try_into_reflect( self: Box<Graph<N, E, Directed, Ix>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect( self: Box<Graph<N, E, Directed, Ix>>, ) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for Cow<'static, [T]>

where T: FromReflect + MaybeTyped + Clone + TypePath + GetTypeRegistration,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn into_partial_reflect(self: Box<Cow<'static, [T]>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Cow<'static, [T]>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<Cow<'static, [T]>>) -> ReflectOwned

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

fn reflect_hash(&self) -> Option<u64>

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

impl<T> PartialReflect for Bound<T>

where T: Clone + Send + Sync + TypePath, Bound<T>: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<Bound<T>>) -> ReflectOwned

fn try_into_reflect( self: Box<Bound<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Bound<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for Option<T>

where Option<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn try_apply( &mut self, __value_param: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<Option<T>>) -> ReflectOwned

fn try_into_reflect( self: Box<Option<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Option<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_hash(&self) -> Option<u64>

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for BinaryHeap<T>

where T: Clone + TypePath, BinaryHeap<T>: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<BinaryHeap<T>>) -> ReflectOwned

fn try_into_reflect( self: Box<BinaryHeap<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<BinaryHeap<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for BTreeSet<T>

where T: Ord + Eq + Clone + Send + Sync + TypePath, BTreeSet<T>: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<BTreeSet<T>>) -> ReflectOwned

fn try_into_reflect( self: Box<BTreeSet<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<BTreeSet<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for VecDeque<T>

where T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn into_partial_reflect(self: Box<VecDeque<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<VecDeque<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<VecDeque<T>>) -> ReflectOwned

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

fn reflect_hash(&self) -> Option<u64>

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

impl<T> PartialReflect for Saturating<T>

where T: Clone + Send + Sync + TypePath, Saturating<T>: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<Saturating<T>>) -> ReflectOwned

fn try_into_reflect( self: Box<Saturating<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Saturating<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for Wrapping<T>

where T: Clone + Send + Sync + TypePath, Wrapping<T>: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<Wrapping<T>>) -> ReflectOwned

fn try_into_reflect( self: Box<Wrapping<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Wrapping<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for Range<T>

where T: Clone + Send + Sync + TypePath, Range<T>: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<Range<T>>) -> ReflectOwned

fn try_into_reflect( self: Box<Range<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Range<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for RangeFrom<T>

where T: Clone + Send + Sync + TypePath, RangeFrom<T>: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<RangeFrom<T>>) -> ReflectOwned

fn try_into_reflect( self: Box<RangeFrom<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<RangeFrom<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for RangeInclusive<T>

where T: Clone + Send + Sync + TypePath, RangeInclusive<T>: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<RangeInclusive<T>>) -> ReflectOwned

fn try_into_reflect( self: Box<RangeInclusive<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<RangeInclusive<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for RangeTo<T>

where T: Clone + Send + Sync + TypePath, RangeTo<T>: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<RangeTo<T>>) -> ReflectOwned

fn try_into_reflect( self: Box<RangeTo<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<RangeTo<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for RangeToInclusive<T>

where T: Clone + Send + Sync + TypePath, RangeToInclusive<T>: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<RangeToInclusive<T>>) -> ReflectOwned

fn try_into_reflect( self: Box<RangeToInclusive<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect( self: Box<RangeToInclusive<T>>, ) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for SmallVec<T>

where T: Array + TypePath + Send + Sync, <T as Array>::Item: FromReflect + MaybeTyped + TypePath,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn into_partial_reflect(self: Box<SmallVec<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<SmallVec<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<SmallVec<T>>) -> ReflectOwned

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

impl<T, E> PartialReflect for Result<T, E>

where Result<T, E>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection, E: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn try_apply( &mut self, __value_param: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<Result<T, E>>) -> ReflectOwned

fn try_into_reflect( self: Box<Result<T, E>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Result<T, E>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_hash(&self) -> Option<u64>

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T, const N: usize> PartialReflect for [T; N]

where T: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn into_partial_reflect(self: Box<[T; N]>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<[T; N]>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<[T; N]>) -> ReflectOwned

fn reflect_hash(&self) -> Option<u64>

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

impl<V, S> PartialReflect for HashSet<V, S>

where V: FromReflect + TypePath + GetTypeRegistration + Eq + Hash, S: TypePath + BuildHasher + Default + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn into_partial_reflect(self: Box<HashSet<V, S>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<HashSet<V, S>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<HashSet<V, S>>) -> ReflectOwned

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Implementors

impl PartialReflect for AccessibilitySystem

where AccessibilitySystem: Any + Send + Sync,

impl PartialReflect for RepeatAnimation

where RepeatAnimation: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for PlaybackMode

where PlaybackMode: Any + Send + Sync,

impl PartialReflect for Volume

where Volume: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BloomCompositeMode

where BloomCompositeMode: Any + Send + Sync,

impl PartialReflect for Camera3dDepthLoadOp

where Camera3dDepthLoadOp: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ScreenSpaceTransmissionQuality

where ScreenSpaceTransmissionQuality: Any + Send + Sync,

impl PartialReflect for DepthOfFieldMode

where DepthOfFieldMode: Any + Send + Sync,

impl PartialReflect for Sensitivity

where Sensitivity: Any + Send + Sync,

impl PartialReflect for SmaaPreset

where SmaaPreset: Any + Send + Sync,

impl PartialReflect for DebandDither

where DebandDither: Any + Send + Sync,

impl PartialReflect for Tonemapping

where Tonemapping: Any + Send + Sync,

impl PartialReflect for ButtonState

where ButtonState: Any + Send + Sync,

impl PartialReflect for GamepadConnection

where GamepadConnection: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<u16>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GamepadEvent

where GamepadEvent: Any + Send + Sync, GamepadConnectionEvent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadButtonChangedEvent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadAxisChangedEvent: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GamepadInput

where GamepadInput: Any + Send + Sync, GamepadAxis: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GamepadRumbleRequest

where GamepadRumbleRequest: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadRumbleIntensity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RawGamepadEvent

where RawGamepadEvent: Any + Send + Sync, GamepadConnectionEvent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RawGamepadButtonChangedEvent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RawGamepadAxisChangedEvent: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Key

where Key: Any + Send + Sync, SmolStr: FromReflect + TypePath + MaybeTyped + RegisterForReflection, NativeKey: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<char>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for NativeKey

where NativeKey: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SmolStr: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for NativeKeyCode

where NativeKeyCode: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MouseScrollUnit

where MouseScrollUnit: Any + Send + Sync,

impl PartialReflect for ForceTouch

where ForceTouch: Any + Send + Sync, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<f64>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TouchPhase

where TouchPhase: Any + Send + Sync,

impl PartialReflect for CompassOctant

where CompassOctant: Any + Send + Sync,

impl PartialReflect for CompassQuadrant

where CompassQuadrant: Any + Send + Sync,

impl PartialReflect 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,

impl PartialReflect for ClusterFarZMode

where ClusterFarZMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for OpaqueRendererMethod

where OpaqueRendererMethod: Any + Send + Sync,

impl PartialReflect for ScreenSpaceAmbientOcclusionQualityLevel

where ScreenSpaceAmbientOcclusionQualityLevel: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ShadowFilteringMethod

where ShadowFilteringMethod: Any + Send + Sync,

impl PartialReflect for UvChannel

where UvChannel: Any + Send + Sync,

impl PartialReflect for PickingInteraction

where PickingInteraction: Any + Send + Sync,

impl PartialReflect for Backfaces

where Backfaces: Any + Send + Sync,

impl PartialReflect 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,

impl PartialReflect for PointerId

where PointerId: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Uuid: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PressDirection

where PressDirection: Any + Send + Sync,

impl PartialReflect for NormalizedRenderTarget

where NormalizedRenderTarget: Any + Send + Sync, NormalizedWindowRef: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ImageRenderTarget: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ManualTextureViewHandle: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RenderTarget

where RenderTarget: Any + Send + Sync, WindowRef: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ImageRenderTarget: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ManualTextureViewHandle: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for bevy::render::camera::ScalingMode

where ScalingMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CapsuleUvProfile

where CapsuleUvProfile: Any + Send + Sync,

impl PartialReflect for CircularMeshUvMode

where CircularMeshUvMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ConeAnchor

where ConeAnchor: Any + Send + Sync,

impl PartialReflect for CylinderAnchor

where CylinderAnchor: Any + Send + Sync,

impl PartialReflect for Indices

where Indices: Any + Send + Sync, Vec<u16>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<u32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for SphereKind

where SphereKind: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AlphaMode2d

where AlphaMode2d: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Anchor

where Anchor: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for FontSmoothing

where FontSmoothing: Any + Send + Sync,

impl PartialReflect for LineHeight

where LineHeight: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for FocusPolicy

where FocusPolicy: Any + Send + Sync,

impl PartialReflect for AppLifecycle

where AppLifecycle: Any + Send + Sync,

impl PartialReflect for CompositeAlphaMode

where CompositeAlphaMode: Any + Send + Sync,

impl PartialReflect for CursorGrabMode

where CursorGrabMode: Any + Send + Sync,

impl PartialReflect for PresentMode

where PresentMode: Any + Send + Sync,

impl PartialReflect for SystemCursorIcon

where SystemCursorIcon: Any + Send + Sync,

impl PartialReflect 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,

impl PartialReflect for WindowLevel

where WindowLevel: Any + Send + Sync,

impl PartialReflect for WindowMode

where WindowMode: Any + Send + Sync, MonitorSelection: FromReflect + TypePath + MaybeTyped + RegisterForReflection, VideoModeSelection: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowRef

where WindowRef: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowTheme

where WindowTheme: Any + Send + Sync,

impl PartialReflect for CursorIcon

where CursorIcon: Any + Send + Sync, CustomCursor: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SystemCursorIcon: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CustomCursor

where CustomCursor: Any + Send + Sync, CustomCursorImage: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AlignContent

where AlignContent: Any + Send + Sync,

impl PartialReflect for AlignItems

where AlignItems: Any + Send + Sync,

impl PartialReflect for AlignSelf

where AlignSelf: Any + Send + Sync,

impl PartialReflect for AlphaMode

where AlphaMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AnimationNodeType

where AnimationNodeType: Any + Send + Sync, Handle<AnimationClip>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BoxSizing

where BoxSizing: Any + Send + Sync,

impl PartialReflect for ClearColorConfig

where ClearColorConfig: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for Display

where Display: Any + Send + Sync,

impl PartialReflect for EaseFunction

where EaseFunction: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, JumpAt: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for EulerRot

where EulerRot: Any + Send + Sync,

impl PartialReflect for FileDragAndDrop

where FileDragAndDrop: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PathBuf: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for FlexDirection

where FlexDirection: Any + Send + Sync,

impl PartialReflect for FlexWrap

where FlexWrap: Any + Send + Sync,

impl PartialReflect for FogFalloff

where FogFalloff: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GamepadAxis

where GamepadAxis: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GamepadButton

where GamepadButton: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GizmoLineJoint

where GizmoLineJoint: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GizmoLineStyle

where GizmoLineStyle: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GridAutoFlow

where GridAutoFlow: Any + Send + Sync,

impl PartialReflect for GridTrackRepetition

where GridTrackRepetition: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Ime

where Ime: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<(usize, usize)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Interaction

where Interaction: Any + Send + Sync,

impl PartialReflect for JumpAt

where JumpAt: Any + Send + Sync,

impl PartialReflect for JustifyContent

where JustifyContent: Any + Send + Sync,

impl PartialReflect for JustifyItems

where JustifyItems: Any + Send + Sync,

impl PartialReflect for JustifySelf

where JustifySelf: Any + Send + Sync,

impl PartialReflect for JustifyText

where JustifyText: Any + Send + Sync,

impl PartialReflect for KeyCode

where KeyCode: Any + Send + Sync, NativeKeyCode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for LightGizmoColor

where LightGizmoColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for LineBreak

where LineBreak: Any + Send + Sync,

impl PartialReflect for MaxTrackSizingFunction

where MaxTrackSizingFunction: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MinTrackSizingFunction

where MinTrackSizingFunction: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MonitorSelection

where MonitorSelection: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MouseButton

where MouseButton: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Msaa

where Msaa: Any + Send + Sync,

impl PartialReflect for NodeImageMode

where NodeImageMode: Any + Send + Sync, TextureSlicer: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for OverflowAxis

where OverflowAxis: Any + Send + Sync,

impl PartialReflect for OverflowClipBox

where OverflowClipBox: Any + Send + Sync,

impl PartialReflect for ParallaxMappingMethod

where ParallaxMappingMethod: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PointerButton

where PointerButton: Any + Send + Sync,

impl PartialReflect for PositionType

where PositionType: Any + Send + Sync,

impl PartialReflect for Projection

where Projection: Any + Send + Sync, PerspectiveProjection: FromReflect + TypePath + MaybeTyped + RegisterForReflection, OrthographicProjection: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CustomProjection: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RayCastVisibility

where RayCastVisibility: Any + Send + Sync,

impl PartialReflect for bevy::prelude::ScalingMode

where ScalingMode: Any + Send + Sync,

impl PartialReflect for SliceScaleMode

where SliceScaleMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for SpritePickingMode

where SpritePickingMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TimerMode

where TimerMode: Any + Send + Sync,

impl PartialReflect for UiAntiAlias

where UiAntiAlias: Any + Send + Sync,

impl PartialReflect for Val

where Val: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for VideoModeSelection

where VideoModeSelection: Any + Send + Sync, VideoMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Visibility

where Visibility: Any + Send + Sync,

impl PartialReflect for WindowPosition

where WindowPosition: Any + Send + Sync, MonitorSelection: FromReflect + TypePath + MaybeTyped + RegisterForReflection, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AccessibilityRequested

where AccessibilityRequested: Any + Send + Sync, Arc<AtomicBool>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ManageAccessibilityUpdates

where ManageAccessibilityUpdates: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CubicRotationCurve

where CubicRotationCurve: Any + Send + Sync, ChunkedUnevenCore<Vec4>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for AnimationTarget

where AnimationTarget: Any + Send + Sync, AnimationTargetId: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AnimationTargetId

where AnimationTargetId: Any + Send + Sync, Uuid: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AssetIndex

where AssetIndex: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RenderAssetUsages

where RenderAssetUsages: Any + Send + Sync,

impl PartialReflect for Uuid

where Uuid: Any + Send + Sync,

impl PartialReflect for DefaultSpatialScale

where DefaultSpatialScale: Any + Send + Sync, SpatialScale: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for SpatialScale

where SpatialScale: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for AutoExposureCompensationCurve

where AutoExposureCompensationCurve: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, [u8; 256]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for BloomPrefilter

where BloomPrefilter: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ContrastAdaptiveSharpening

where ContrastAdaptiveSharpening: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DenoiseCas

where DenoiseCas: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Camera3dDepthTextureUsage

where Camera3dDepthTextureUsage: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DepthOfField

where DepthOfField: Any + Send + Sync, DepthOfFieldMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TemporalAntiAliasing

where TemporalAntiAliasing: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Fxaa

where Fxaa: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Sensitivity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MotionBlur

where MotionBlur: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for OrderIndependentTransparencySettings

where OrderIndependentTransparencySettings: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ChromaticAberration

where ChromaticAberration: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DeferredPrepass

where DeferredPrepass: Any + Send + Sync,

impl PartialReflect for DepthPrepass

where DepthPrepass: Any + Send + Sync,

impl PartialReflect for MotionVectorPrepass

where MotionVectorPrepass: Any + Send + Sync,

impl PartialReflect for NormalPrepass

where NormalPrepass: Any + Send + Sync,

impl PartialReflect for Smaa

where Smaa: Any + Send + Sync, SmaaPreset: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Skybox

where Skybox: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ComponentId

where ComponentId: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ComponentTicks

where ComponentTicks: Any + Send + Sync, Tick: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Tick

where Tick: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for EntityHash

where EntityHash: Any + Send + Sync,

impl PartialReflect for EntityHashSet

where EntityHashSet: Any + Send + Sync, HashSet<Entity, EntityHash>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DefaultQueryFilters

where DefaultQueryFilters: Any + Send + Sync, SmallVec<[ComponentId; 4]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Disabled

where Disabled: Any + Send + Sync,

impl PartialReflect for Identifier

where Identifier: Any + Send + Sync,

impl PartialReflect for RemovedComponentEntity

where RemovedComponentEntity: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for SystemIdMarker

where SystemIdMarker: Any + Send + Sync,

impl PartialReflect for OnDespawn

where OnDespawn: Any + Send + Sync,

impl PartialReflect for ErasedGizmoConfigGroup

where ErasedGizmoConfigGroup: Any + Send + Sync,

impl PartialReflect for GltfMaterialExtras

where GltfMaterialExtras: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GltfMaterialName

where GltfMaterialName: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GltfMeshExtras

where GltfMeshExtras: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GltfSceneExtras

where GltfSceneExtras: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AxisSettings

where AxisSettings: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ButtonAxisSettings

where ButtonAxisSettings: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ButtonSettings

where ButtonSettings: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GamepadAxisChangedEvent

where GamepadAxisChangedEvent: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadAxis: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for GamepadButtonStateChangedEvent

where GamepadButtonStateChangedEvent: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ButtonState: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GamepadConnectionEvent

where GamepadConnectionEvent: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadConnection: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GamepadRumbleIntensity

where GamepadRumbleIntensity: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RawGamepadAxisChangedEvent

where RawGamepadAxisChangedEvent: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadAxis: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RawGamepadButtonChangedEvent

where RawGamepadButtonChangedEvent: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GamepadButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DoubleTapGesture

where DoubleTapGesture: Any + Send + Sync,

impl PartialReflect for PanGesture

where PanGesture: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PinchGesture

where PinchGesture: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RotationGesture

where RotationGesture: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for KeyboardFocusLost

where KeyboardFocusLost: Any + Send + Sync,

impl PartialReflect 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,

impl PartialReflect for AccumulatedMouseMotion

where AccumulatedMouseMotion: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AccumulatedMouseScroll

where AccumulatedMouseScroll: Any + Send + Sync, MouseScrollUnit: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MouseButtonInput

where MouseButtonInput: Any + Send + Sync, MouseButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ButtonState: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MouseMotion

where MouseMotion: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MouseWheel

where MouseWheel: Any + Send + Sync, MouseScrollUnit: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DirectionalNavigationMap

where DirectionalNavigationMap: Any + Send + Sync, EntityHashMap<NavNeighbors>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for NavNeighbors

where NavNeighbors: Any + Send + Sync, [Option<Entity>; 8]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AutoFocus

where AutoFocus: Any + Send + Sync,

impl PartialReflect for InputFocus

where InputFocus: Any + Send + Sync, Option<Entity>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for InputFocusVisible

where InputFocusVisible: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TabGroup

where TabGroup: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TabIndex

where TabIndex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Aabb2d

where Aabb2d: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Aabb3d

where Aabb3d: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AabbCast2d

where AabbCast2d: Any + Send + Sync, RayCast2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Aabb2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AabbCast3d

where AabbCast3d: Any + Send + Sync, RayCast3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Aabb3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BoundingCircle

where BoundingCircle: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Circle: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BoundingCircleCast

where BoundingCircleCast: Any + Send + Sync, RayCast2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, BoundingCircle: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BoundingSphere

where BoundingSphere: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Sphere: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BoundingSphereCast

where BoundingSphereCast: Any + Send + Sync, RayCast3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, BoundingSphere: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RayCast2d

where RayCast2d: Any + Send + Sync, Ray2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RayCast3d

where RayCast3d: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Dir3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Affine2

where Affine2: Any + Send + Sync, Mat2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Affine3

where Affine3: Any + Send + Sync, Mat3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Affine3A

where Affine3A: Any + Send + Sync, Mat3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AspectRatio

where AspectRatio: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DAffine2

where DAffine2: Any + Send + Sync, DMat2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, DVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DAffine3

where DAffine3: Any + Send + Sync, DMat3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, DVec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DMat2

where DMat2: Any + Send + Sync, DVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DMat3

where DMat3: Any + Send + Sync, DVec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DMat4

where DMat4: Any + Send + Sync, DVec4: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DQuat

where DQuat: Any + Send + Sync, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DVec2

where DVec2: Any + Send + Sync, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DVec3

where DVec3: Any + Send + Sync, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DVec4

where DVec4: Any + Send + Sync, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for FloatOrd

where FloatOrd: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for I8Vec2

where I8Vec2: Any + Send + Sync, i8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for I8Vec3

where I8Vec3: Any + Send + Sync, i8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for I8Vec4

where I8Vec4: Any + Send + Sync, i8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for I16Vec2

where I16Vec2: Any + Send + Sync, i16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for I16Vec3

where I16Vec3: Any + Send + Sync, i16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for I16Vec4

where I16Vec4: Any + Send + Sync, i16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for I64Vec2

where I64Vec2: Any + Send + Sync, i64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for I64Vec3

where I64Vec3: Any + Send + Sync, i64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for I64Vec4

where I64Vec4: Any + Send + Sync, i64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for U8Vec2

where U8Vec2: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for U8Vec3

where U8Vec3: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for U8Vec4

where U8Vec4: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for U16Vec2

where U16Vec2: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for U16Vec3

where U16Vec3: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for U16Vec4

where U16Vec4: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for U64Vec2

where U64Vec2: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for U64Vec3

where U64Vec3: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for U64Vec4

where U64Vec4: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ClusteredDecal

where ClusteredDecal: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ForwardDecal

where ForwardDecal: Any + Send + Sync,

impl PartialReflect for MeshletMesh3d

where MeshletMesh3d: Any + Send + Sync, Handle<MeshletMesh>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for IrradianceVolume

where IrradianceVolume: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Atmosphere

where Atmosphere: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for Cascade

where Cascade: Any + Send + Sync, Mat4: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CascadeShadowConfig

where CascadeShadowConfig: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Cascades

where Cascades: Any + Send + Sync, EntityHashMap<Vec<Cascade>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CascadesVisibleEntities

where CascadesVisibleEntities: Any + Send + Sync,

impl PartialReflect for ClusterZConfig

where ClusterZConfig: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ClusterFarZMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CubemapVisibleEntities

where CubemapVisibleEntities: Any + Send + Sync,

impl PartialReflect for DefaultOpaqueRendererMethod

where DefaultOpaqueRendererMethod: Any + Send + Sync, OpaqueRendererMethod: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DirectionalLightShadowMap

where DirectionalLightShadowMap: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for Lightmap

where Lightmap: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Rect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MaterialBindGroupIndex

where MaterialBindGroupIndex: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MaterialBindGroupSlot

where MaterialBindGroupSlot: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MaterialBindingId

where MaterialBindingId: Any + Send + Sync, MaterialBindGroupIndex: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MaterialBindGroupSlot: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for NotShadowCaster

where NotShadowCaster: Any + Send + Sync,

impl PartialReflect for NotShadowReceiver

where NotShadowReceiver: Any + Send + Sync,

impl PartialReflect for PointLightShadowMap

where PointLightShadowMap: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RenderCascadesVisibleEntities

where RenderCascadesVisibleEntities: Any + Send + Sync,

impl PartialReflect for RenderCubemapVisibleEntities

where RenderCubemapVisibleEntities: Any + Send + Sync,

impl PartialReflect for RenderVisibleMeshEntities

where RenderVisibleMeshEntities: Any + Send + Sync,

impl PartialReflect for ScreenSpaceAmbientOcclusion

where ScreenSpaceAmbientOcclusion: Any + Send + Sync, ScreenSpaceAmbientOcclusionQualityLevel: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ScreenSpaceReflections

where ScreenSpaceReflections: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TransmittedShadowReceiver

where TransmittedShadowReceiver: Any + Send + Sync,

impl PartialReflect for VisibleMeshEntities

where VisibleMeshEntities: Any + Send + Sync,

impl PartialReflect for VolumetricFog

where VolumetricFog: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for VolumetricLight

where VolumetricLight: Any + Send + Sync,

impl PartialReflect for Mesh3dWireframe

where Mesh3dWireframe: Any + Send + Sync, Handle<WireframeMaterial>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for NoWireframe

where NoWireframe: Any + Send + Sync,

impl PartialReflect for Wireframe

where Wireframe: Any + Send + Sync,

impl PartialReflect for WireframeColor

where WireframeColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WireframeConfig

where WireframeConfig: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WireframeMaterial

where WireframeMaterial: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RayId

where RayId: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PointerId: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for HitData

where HitData: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec3>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PointerHits

where PointerHits: Any + Send + Sync, PointerId: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<(Entity, HitData)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for SimplifiedMesh

where SimplifiedMesh: Any + Send + Sync, Handle<Mesh>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for bevy::picking::pointer::Location

where Location: Any + Send + Sync, NormalizedRenderTarget: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PointerInput

where PointerInput: Any + Send + Sync, PointerId: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Location: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PointerAction: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PointerInteraction

where PointerInteraction: Any + Send + Sync, Vec<(Entity, HitData)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PointerLocation

where PointerLocation: Any + Send + Sync,

impl PartialReflect for PointerPress

where PointerPress: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AtomicBool

where AtomicBool: Any + Send + Sync,

impl PartialReflect for AtomicI8

where AtomicI8: Any + Send + Sync,

impl PartialReflect for AtomicI16

where AtomicI16: Any + Send + Sync,

impl PartialReflect for AtomicI32

where AtomicI32: Any + Send + Sync,

impl PartialReflect for AtomicI64

where AtomicI64: Any + Send + Sync,

impl PartialReflect for AtomicIsize

where AtomicIsize: Any + Send + Sync,

impl PartialReflect for AtomicU8

where AtomicU8: Any + Send + Sync,

impl PartialReflect for AtomicU16

where AtomicU16: Any + Send + Sync,

impl PartialReflect for AtomicU32

where AtomicU32: Any + Send + Sync,

impl PartialReflect for AtomicU64

where AtomicU64: Any + Send + Sync,

impl PartialReflect for AtomicUsize

where AtomicUsize: Any + Send + Sync,

impl PartialReflect for Instant

where Instant: Any + Send + Sync,

impl PartialReflect for DynamicFunction<'static>

impl PartialReflect for DynamicArray

impl PartialReflect for DynamicEnum

impl PartialReflect for DynamicList

impl PartialReflect for DynamicMap

impl PartialReflect for DynamicSet

impl PartialReflect for DynamicStruct

impl PartialReflect for DynamicTuple

impl PartialReflect for DynamicTupleStruct

impl PartialReflect for CameraMainTextureUsages

where CameraMainTextureUsages: Any + Send + Sync,

impl PartialReflect for CameraRenderGraph

where CameraRenderGraph: Any + Send + Sync,

impl PartialReflect for CustomProjection

where CustomProjection: Any + Send + Sync,

impl PartialReflect for Exposure

where Exposure: Any + Send + Sync,

impl PartialReflect for ImageRenderTarget

where ImageRenderTarget: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, FloatOrd: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ManualTextureViewHandle

where ManualTextureViewHandle: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MipBias

where MipBias: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for SubCameraView

where SubCameraView: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TemporalJitter

where TemporalJitter: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Viewport

where Viewport: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Range<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for OcclusionCulling

where OcclusionCulling: Any + Send + Sync,

impl PartialReflect for GlobalsUniform

where GlobalsUniform: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ReadbackComplete

where ReadbackComplete: Any + Send + Sync, Vec<u8>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MeshMorphWeights

where MeshMorphWeights: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for SkinnedMesh

where SkinnedMesh: Any + Send + Sync, Handle<SkinnedMeshInverseBindposes>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<Entity>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AnnulusMeshBuilder

where AnnulusMeshBuilder: Any + Send + Sync, Annulus: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Capsule2dMeshBuilder

where Capsule2dMeshBuilder: Any + Send + Sync, Capsule2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Capsule3dMeshBuilder

where Capsule3dMeshBuilder: Any + Send + Sync, Capsule3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CapsuleUvProfile: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CircleMeshBuilder

where CircleMeshBuilder: Any + Send + Sync, Circle: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CircularSectorMeshBuilder

where CircularSectorMeshBuilder: Any + Send + Sync, CircularSector: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CircularMeshUvMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CircularSegmentMeshBuilder

where CircularSegmentMeshBuilder: Any + Send + Sync, CircularSegment: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CircularMeshUvMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ConeMeshBuilder

where ConeMeshBuilder: Any + Send + Sync, Cone: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ConeAnchor: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ConicalFrustumMeshBuilder

where ConicalFrustumMeshBuilder: Any + Send + Sync, ConicalFrustum: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CuboidMeshBuilder

where CuboidMeshBuilder: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for EllipseMeshBuilder

where EllipseMeshBuilder: Any + Send + Sync, Ellipse: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MeshTag

where MeshTag: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PlaneMeshBuilder

where PlaneMeshBuilder: Any + Send + Sync, Plane3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RectangleMeshBuilder

where RectangleMeshBuilder: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RegularPolygonMeshBuilder

where RegularPolygonMeshBuilder: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RhombusMeshBuilder

where RhombusMeshBuilder: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for SphereMeshBuilder

where SphereMeshBuilder: Any + Send + Sync, Sphere: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SphereKind: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TetrahedronMeshBuilder

where TetrahedronMeshBuilder: Any + Send + Sync, Tetrahedron: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TorusMeshBuilder

where TorusMeshBuilder: Any + Send + Sync, Torus: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RangeInclusive<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Triangle2dMeshBuilder

where Triangle2dMeshBuilder: Any + Send + Sync, Triangle2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Triangle3dMeshBuilder

where Triangle3dMeshBuilder: Any + Send + Sync, Triangle3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Aabb

where Aabb: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CascadesFrusta

where CascadesFrusta: Any + Send + Sync,

impl PartialReflect for CubemapFrusta

where CubemapFrusta: Any + Send + Sync,

impl PartialReflect for Frustum

where Frustum: Any + Send + Sync,

impl PartialReflect for ShaderStorageBuffer

where ShaderStorageBuffer: Any + Send + Sync,

impl PartialReflect for SyncToRenderWorld

where SyncToRenderWorld: Any + Send + Sync,

impl PartialReflect for TemporaryRenderEntity

where TemporaryRenderEntity: Any + Send + Sync,

impl PartialReflect for ColorGrading

where ColorGrading: Any + Send + Sync, ColorGradingGlobal: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ColorGradingSection: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ColorGradingGlobal

where ColorGradingGlobal: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Range<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ColorGradingSection

where ColorGradingSection: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for NoFrustumCulling

where NoFrustumCulling: Any + Send + Sync,

impl PartialReflect for RenderLayers

where RenderLayers: Any + Send + Sync, SmallVec<[u64; 1]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RenderVisibleEntities

where RenderVisibleEntities: Any + Send + Sync,

impl PartialReflect for VisibilityClass

where VisibilityClass: Any + Send + Sync, SmallVec<[TypeId; 1]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for VisibilityRange

where VisibilityRange: Any + Send + Sync, Range<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for VisibleEntities

where VisibleEntities: Any + Send + Sync,

impl PartialReflect for Screenshot

where Screenshot: Any + Send + Sync, RenderTarget: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ScreenshotCaptured

where ScreenshotCaptured: Any + Send + Sync, Image: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for InstanceId

where InstanceId: Any + Send + Sync, Uuid: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for SceneInstanceReady

where SceneInstanceReady: Any + Send + Sync, InstanceId: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Mesh2dWireframe

where Mesh2dWireframe: Any + Send + Sync, Handle<Wireframe2dMaterial>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for NoWireframe2d

where NoWireframe2d: Any + Send + Sync,

impl PartialReflect for Wireframe2d

where Wireframe2d: Any + Send + Sync,

impl PartialReflect for Wireframe2dColor

where Wireframe2dColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Wireframe2dConfig

where Wireframe2dConfig: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Wireframe2dMaterial

where Wireframe2dMaterial: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ComputedTextBlock

where ComputedTextBlock: Any + Send + Sync, SmallVec<[TextEntity; 1]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GlyphAtlasInfo

where GlyphAtlasInfo: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Handle<TextureAtlasLayout>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GlyphAtlasLocation: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GlyphAtlasLocation

where GlyphAtlasLocation: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PositionedGlyph

where PositionedGlyph: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GlyphAtlasInfo: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TextBounds

where TextBounds: Any + Send + Sync, Option<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TextEntity

where TextEntity: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TextLayoutInfo

where TextLayoutInfo: Any + Send + Sync, Vec<PositionedGlyph>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Stopwatch

where Stopwatch: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GhostNode

where GhostNode: Any + Send + Sync,

impl PartialReflect for ContentSize

where ContentSize: Any + Send + Sync,

impl PartialReflect for RelativeCursorPosition

where RelativeCursorPosition: Any + Send + Sync, Rect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec2>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ImageNodeSize

where ImageNodeSize: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TextNodeFlags

where TextNodeFlags: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CursorOptions

where CursorOptions: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CursorGrabMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for EnabledButtons

where EnabledButtons: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect 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,

impl PartialReflect for NormalizedWindowRef

where NormalizedWindowRef: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PrimaryMonitor

where PrimaryMonitor: Any + Send + Sync,

impl PartialReflect for PrimaryWindow

where PrimaryWindow: Any + Send + Sync,

impl PartialReflect for RequestRedraw

where RequestRedraw: Any + Send + Sync,

impl PartialReflect for VideoMode

where VideoMode: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowBackendScaleFactorChanged

where WindowBackendScaleFactorChanged: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowCloseRequested

where WindowCloseRequested: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowClosed

where WindowClosed: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowClosing

where WindowClosing: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowCreated

where WindowCreated: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowDestroyed

where WindowDestroyed: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowFocused

where WindowFocused: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowOccluded

where WindowOccluded: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowResized

where WindowResized: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowResolution

where WindowResolution: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowScaleFactorChanged

where WindowScaleFactorChanged: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowThemeChanged

where WindowThemeChanged: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowTheme: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for WakeUp

where WakeUp: Any + Send + Sync,

impl PartialReflect for AabbGizmoConfigGroup

where AabbGizmoConfigGroup: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Color>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AmbientLight

where AmbientLight: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AnimationClip

where AnimationClip: Any + Send + Sync, HashMap<AnimationEventTarget, Vec<TimedAnimationEvent>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for AnimationGraphHandle

where AnimationGraphHandle: Any + Send + Sync, Handle<AnimationGraph>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AnimationGraphNode

where AnimationGraphNode: Any + Send + Sync, AnimationNodeType: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AnimationPlayer

where AnimationPlayer: Any + Send + Sync, HashMap<NodeIndex, ActiveAnimation>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HashMap<NodeIndex, f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AnimationTransition

where AnimationTransition: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, NodeIndex: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Annulus

where Annulus: Any + Send + Sync, Circle: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Arc2d

where Arc2d: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BVec2

where BVec2: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BVec3

where BVec3: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BVec3A

where BVec3A: Any + Send + Sync,

impl PartialReflect for BVec4

where BVec4: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BVec4A

where BVec4A: Any + Send + Sync,

impl PartialReflect for BackgroundColor

where BackgroundColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BorderColor

where BorderColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BorderRadius

where BorderRadius: Any + Send + Sync, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BorderRect

where BorderRect: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BoxShadow

where BoxShadow: Any + Send + Sync, Vec<ShadowStyle>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for BoxShadowSamples

where BoxShadowSamples: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Button

where Button: Any + Send + Sync,

impl PartialReflect for CalculatedClip

where CalculatedClip: Any + Send + Sync, Rect: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Camera2d

where Camera2d: Any + Send + Sync,

impl PartialReflect 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,

impl PartialReflect 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,

impl PartialReflect for Cancel

where Cancel: Any + Send + Sync, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Capsule2d

where Capsule2d: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Capsule3d

where Capsule3d: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ChildOf

where ChildOf: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Children

where Children: Any + Send + Sync, Vec<Entity>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Circle

where Circle: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CircularSector

where CircularSector: Any + Send + Sync, Arc2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CircularSegment

where CircularSegment: Any + Send + Sync, Arc2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ClearColor

where ClearColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Click

where Click: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect 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,

impl PartialReflect for ComputedNodeTarget

where ComputedNodeTarget: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Cone

where Cone: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ConicalFrustum

where ConicalFrustum: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Cuboid

where Cuboid: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CursorEntered

where CursorEntered: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CursorLeft

where CursorLeft: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for CursorMoved

where CursorMoved: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec2>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Cylinder

where Cylinder: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DefaultGizmoConfigGroup

where DefaultGizmoConfigGroup: Any + Send + Sync,

impl PartialReflect for Dir2

where Dir2: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Dir3

where Dir3: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Dir3A

where Dir3A: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for DistanceFog

where DistanceFog: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, FogFalloff: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Drag

where Drag: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DragDrop

where DragDrop: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DragEnd

where DragEnd: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DragEnter

where DragEnter: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DragEntry

where DragEntry: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DragLeave

where DragLeave: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DragOver

where DragOver: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DragStart

where DragStart: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for DynamicSceneRoot

where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Ellipse

where Ellipse: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Entity

where Entity: Any + Send + Sync,

impl PartialReflect 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,

impl PartialReflect for Fixed

where Fixed: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect 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,

impl PartialReflect for Gizmo

where Gizmo: Any + Send + Sync, Handle<GizmoAsset>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GizmoLineConfig: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for GizmoConfigStore

where GizmoConfigStore: Any + Send + Sync,

impl PartialReflect 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,

impl PartialReflect for GlobalTransform

where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GlobalVolume

where GlobalVolume: Any + Send + Sync, Volume: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GlobalZIndex

where GlobalZIndex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GltfExtras

where GltfExtras: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GridPlacement

where GridPlacement: Any + Send + Sync, Option<NonZero<i16>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<NonZero<u16>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for GridTrack

where GridTrack: Any + Send + Sync, MinTrackSizingFunction: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MaxTrackSizingFunction: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Hsla

where Hsla: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Hsva

where Hsva: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Hwba

where Hwba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for IRect

where IRect: Any + Send + Sync, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for IVec2

where IVec2: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for IVec3

where IVec3: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for IVec4

where IVec4: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Image

where Image: Any + Send + Sync,

impl PartialReflect 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,

impl PartialReflect for InfinitePlane3d

where InfinitePlane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for InheritedVisibility

where InheritedVisibility: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Interval

where Interval: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Isometry2d

where Isometry2d: Any + Send + Sync, Rot2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Isometry3d

where Isometry3d: Any + Send + Sync, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Laba

where Laba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Label

where Label: Any + Send + Sync,

impl PartialReflect for LayoutConfig

where LayoutConfig: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Lcha

where Lcha: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for LightGizmoConfigGroup

where LightGizmoConfigGroup: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LightGizmoColor: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for LightProbe

where LightProbe: Any + Send + Sync,

impl PartialReflect for Line2d

where Line2d: Any + Send + Sync, Dir2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Line3d

where Line3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for LinearRgba

where LinearRgba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Mat2

where Mat2: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Mat3

where Mat3: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Mat3A

where Mat3A: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Mat4

where Mat4: Any + Send + Sync, Vec4: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Mesh2d

where Mesh2d: Any + Send + Sync, Handle<Mesh>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Mesh3d

where Mesh3d: Any + Send + Sync, Handle<Mesh>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for MeshPickingCamera

where MeshPickingCamera: Any + Send + Sync,

impl PartialReflect for MeshPickingSettings

where MeshPickingSettings: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RayCastVisibility: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for MorphWeights

where MorphWeights: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Handle<Mesh>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Move

where Move: Any + Send + Sync, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Name

where Name: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Cow<'static, str>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for Oklaba

where Oklaba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Oklcha

where Oklcha: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for OnAdd

where OnAdd: Any + Send + Sync,

impl PartialReflect for OnInsert

where OnInsert: Any + Send + Sync,

impl PartialReflect for OnRemove

where OnRemove: Any + Send + Sync,

impl PartialReflect for OnReplace

where OnReplace: Any + Send + Sync,

impl PartialReflect 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,

impl PartialReflect for Out

where Out: Any + Send + Sync, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Outline

where Outline: Any + Send + Sync, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Over

where Over: Any + Send + Sync, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Overflow

where Overflow: Any + Send + Sync, OverflowAxis: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for OverflowClipMargin

where OverflowClipMargin: Any + Send + Sync, OverflowClipBox: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PerspectiveProjection

where PerspectiveProjection: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Pickable

where Pickable: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PickingPlugin

where PickingPlugin: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Plane2d

where Plane2d: Any + Send + Sync, Dir2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Plane3d

where Plane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for PointLight

where PointLight: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for PointerInputPlugin

where PointerInputPlugin: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Pressed

where Pressed: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Quat

where Quat: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Ray2d

where Ray2d: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Dir2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Ray3d

where Ray3d: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RayCastBackfaces

where RayCastBackfaces: Any + Send + Sync,

impl PartialReflect for Real

where Real: Any + Send + Sync, Instant: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Instant>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Rect

where Rect: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Rectangle

where Rectangle: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RegularPolygon

where RegularPolygon: Any + Send + Sync, Circle: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Released

where Released: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for RepeatedGridTrack

where RepeatedGridTrack: Any + Send + Sync, GridTrackRepetition: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SmallVec<[GridTrack; 1]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ResolvedBorderRadius

where ResolvedBorderRadius: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Rhombus

where Rhombus: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Rot2

where Rot2: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for SceneRoot

where SceneRoot: Any + Send + Sync, Handle<Scene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Scroll

where Scroll: Any + Send + Sync, MouseScrollUnit: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ScrollPosition

where ScrollPosition: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Segment2d

where Segment2d: Any + Send + Sync, [Vec2; 2]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Segment3d

where Segment3d: Any + Send + Sync, [Vec3; 2]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ShadowStyle

where ShadowStyle: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ShowAabbGizmo

where ShowAabbGizmo: Any + Send + Sync, Option<Color>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ShowLightGizmo

where ShowLightGizmo: Any + Send + Sync, Option<LightGizmoColor>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for SpatialListener

where SpatialListener: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Sphere

where Sphere: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for SpotLight

where SpotLight: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for SpritePickingCamera

where SpritePickingCamera: Any + Send + Sync,

impl PartialReflect for SpritePickingSettings

where SpritePickingSettings: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SpritePickingMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Srgba

where Srgba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for String

where String: Any + Send + Sync,

impl PartialReflect for Tetrahedron

where Tetrahedron: Any + Send + Sync, [Vec3; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Text2d

where Text2d: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Text

where Text: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TextColor

where TextColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TextShadow

where TextShadow: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TextSpan

where TextSpan: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TextureAtlas

where TextureAtlas: Any + Send + Sync, Handle<TextureAtlasLayout>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TextureAtlasLayout

where TextureAtlasLayout: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<URect>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TextureSlicer

where TextureSlicer: Any + Send + Sync, BorderRect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SliceScaleMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for ThreadedAnimationGraphs

where ThreadedAnimationGraphs: Any + Send + Sync, HashMap<AssetId<AnimationGraph>, ThreadedAnimationGraph>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for Torus

where Torus: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for Transform

where Transform: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for TransformTreeChanged

where TransformTreeChanged: Any + Send + Sync,

impl PartialReflect for Triangle2d

where Triangle2d: Any + Send + Sync, [Vec2; 3]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Triangle3d

where Triangle3d: Any + Send + Sync, [Vec3; 3]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for URect

where URect: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for UVec2

where UVec2: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for UVec3

where UVec3: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for UVec4

where UVec4: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for UiPickingCamera

where UiPickingCamera: Any + Send + Sync,

impl PartialReflect for UiPickingSettings

where UiPickingSettings: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for UiRect

where UiRect: Any + Send + Sync, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for UiScale

where UiScale: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for UiTargetCamera

where UiTargetCamera: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Vec2

where Vec2: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Vec3

where Vec3: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Vec3A

where Vec3A: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Vec4

where Vec4: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ViewVisibility

where ViewVisibility: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Virtual

where Virtual: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect 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,

impl PartialReflect for WindowMoved

where WindowMoved: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for WindowResizeConstraints

where WindowResizeConstraints: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for Xyza

where Xyza: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl PartialReflect for ZIndex

where ZIndex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<'a> PartialReflect for AssetPath<'a>

where AssetPath<'a>: Any + Send + Sync,

impl<A> PartialReflect for AssetEvent<A>

where A: Asset + TypePath, AssetEvent<A>: Any + Send + Sync, AssetId<A>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<A> PartialReflect for AssetId<A>

where A: Asset + TypePath, AssetId<A>: Any + Send + Sync, AssetIndex: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Uuid: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<A> PartialReflect for Handle<A>

where A: Asset + TypePath, Handle<A>: Any + Send + Sync, Arc<StrongHandle>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AssetId<A>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<A> PartialReflect 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,

impl<B, E> PartialReflect for ExtendedMaterial<B, E>

where B: Material + FromReflect + TypePath + MaybeTyped + RegisterForReflection, E: MaterialExtension + FromReflect + TypePath + MaybeTyped + RegisterForReflection, ExtendedMaterial<B, E>: Any + Send + Sync,

impl<C> PartialReflect for SampleDerivativeWrapper<C>

where SampleDerivativeWrapper<C>: Any + Send + Sync, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<C> PartialReflect for SampleTwoDerivativesWrapper<C>

where SampleTwoDerivativesWrapper<C>: Any + Send + Sync, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<C> PartialReflect for bevy::prelude::WeightsCurve<C>

where WeightsCurve<C>: Any + Send + Sync, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<Config, Clear> PartialReflect 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,

impl<E> PartialReflect for EventId<E>

where E: Event + TypePath, EventId<E>: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MaybeLocation: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<E> PartialReflect for FocusedInput<E>

where E: Event + Clone + TypePath + FromReflect + MaybeTyped + RegisterForReflection, FocusedInput<E>: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<E> PartialReflect for Events<E>

where E: Event + TypePath, Events<E>: Any + Send + Sync, EventSequence<E>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<E> PartialReflect 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,

impl<K, V, S> PartialReflect for bevy::platform::collections::HashMap<K, V, S>

where K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Hash, V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration, S: TypePath + BuildHasher + Default + Send + Sync,

impl<M> PartialReflect for MaterialNode<M>

where M: UiMaterial + TypePath, MaterialNode<M>: Any + Send + Sync, Handle<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<M> PartialReflect for MeshMaterial2d<M>

where M: Material2d + TypePath, MeshMaterial2d<M>: Any + Send + Sync, Handle<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<M> PartialReflect for MeshMaterial3d<M>

where M: Material + TypePath, MeshMaterial3d<M>: Any + Send + Sync, Handle<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for LinearSpline<P>

where P: VectorSpace + TypePath, LinearSpline<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicBSpline<P>

where P: VectorSpace + TypePath, CubicBSpline<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicBezier<P>

where P: VectorSpace + TypePath, CubicBezier<P>: Any + Send + Sync, Vec<[P; 4]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicCardinalSpline<P>

where P: VectorSpace + TypePath, CubicCardinalSpline<P>: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicCurve<P>

where P: VectorSpace + TypePath, CubicCurve<P>: Any + Send + Sync, Vec<CubicSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicHermite<P>

where P: VectorSpace + TypePath, CubicHermite<P>: Any + Send + Sync, Vec<(P, P)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicNurbs<P>

where P: VectorSpace + TypePath, CubicNurbs<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicSegment<P>

where P: VectorSpace + TypePath, CubicSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for RationalCurve<P>

where P: VectorSpace + TypePath, RationalCurve<P>: Any + Send + Sync, Vec<RationalSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect 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,

impl<P, C> PartialReflect for AnimatableCurve<P, C>

where AnimatableCurve<P, C>: Any + Send + Sync, P: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<S> PartialReflect for NextState<S>

where S: FreelyMutableState + TypePath + FromReflect + MaybeTyped + RegisterForReflection, NextState<S>: Any + Send + Sync,

impl<S> PartialReflect for State<S>

where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, State<S>: Any + Send + Sync,

impl<S> PartialReflect for StateScoped<S>

where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, StateScoped<S>: Any + Send + Sync,

impl<S, T, C, D> PartialReflect 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,

impl<S, T, C, F> PartialReflect for MapCurve<S, T, C, F>

where MapCurve<S, T, C, F>: Any + Send + Sync, C: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, S: TypePath, T: TypePath,

impl<Source> PartialReflect for AudioPlayer<Source>

where AudioPlayer<Source>: Any + Send + Sync, Source: Asset + Decodable + TypePath, Handle<Source>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for InterpolationDatum<T>

where InterpolationDatum<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for CubicKeyframeCurve<T>

where CubicKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for SteppedKeyframeCurve<T>

where SteppedKeyframeCurve<T>: Any + Send + Sync, T: TypePath, UnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for WideCubicKeyframeCurve<T>

where WideCubicKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for WideLinearKeyframeCurve<T>

where WideLinearKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for WideSteppedKeyframeCurve<T>

where WideSteppedKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for ColorCurve<T>

where ColorCurve<T>: Any + Send + Sync, T: TypePath, EvenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for MaybeLocation<T>

where MaybeLocation<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection + ?Sized,

impl<T> PartialReflect for WithDerivative<T>

where WithDerivative<T>: Any + Send + Sync, T: HasTangent + TypePath + FromReflect + MaybeTyped + RegisterForReflection, <T as HasTangent>::Tangent: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect 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,

impl<T> PartialReflect for Arc<T>

where T: Send + Sync + TypePath + ?Sized, Arc<T>: Any + Send + Sync,

impl<T> PartialReflect for ChunkedUnevenCore<T>

where ChunkedUnevenCore<T>: Any + Send + Sync, T: TypePath, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for AnimatableKeyframeCurve<T>

where AnimatableKeyframeCurve<T>: Any + Send + Sync, T: TypePath, UnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for Axis<T>

where Axis<T>: Any + Send + Sync, T: TypePath, HashMap<T, f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for ButtonInput<T>

where T: Copy + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for ConstantCurve<T>

where ConstantCurve<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection, Interval: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for EasingCurve<T>

where EasingCurve<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection, EaseFunction: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for EvenCore<T>

where EvenCore<T>: Any + Send + Sync, T: TypePath, Interval: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for SampleAutoCurve<T>

where SampleAutoCurve<T>: Any + Send + Sync, T: TypePath, EvenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect 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,

impl<T> PartialReflect for UnevenCore<T>

where UnevenCore<T>: Any + Send + Sync, T: TypePath, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for UnevenSampleAutoCurve<T>

where UnevenSampleAutoCurve<T>: Any + Send + Sync, T: TypePath, UnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for Vec<T>

where T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,

impl<T, C> PartialReflect for ForeverCurve<T, C>

where ForeverCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C> PartialReflect for GraphCurve<T, C>

where GraphCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C> PartialReflect for LinearReparamCurve<T, C>

where LinearReparamCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T, C> PartialReflect for PingPongCurve<T, C>

where PingPongCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C> PartialReflect for RepeatCurve<T, C>

where RepeatCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T, C> PartialReflect for ReverseCurve<T, C>

where ReverseCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C, D> PartialReflect 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,

impl<T, C, D> PartialReflect 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,

impl<T, C, D> PartialReflect 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,

impl<T, C, F> PartialReflect 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,

impl<T, F> PartialReflect for FunctionCurve<T, F>

where FunctionCurve<T, F>: Any + Send + Sync, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

impl<T, I> PartialReflect for SampleCurve<T, I>

where SampleCurve<T, I>: Any + Send + Sync, EvenCore<T>: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

impl<T, I> PartialReflect for UnevenSampleCurve<T, I>

where UnevenSampleCurve<T, I>: Any + Send + Sync, UnevenCore<T>: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

impl<V> PartialReflect for EntityHashMap<V>

where EntityHashMap<V>: Any + Send + Sync, V: TypePath, HashMap<Entity, V, EntityHash>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<V> PartialReflect for EntityIndexMap<V>

where EntityIndexMap<V>: Any + Send + Sync, V: TypePath, IndexMap<Entity, V, EntityHash>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<V, S> PartialReflect for bevy::platform::collections::HashSet<V, S>

where V: FromReflect + TypePath + GetTypeRegistration + Eq + Hash, S: TypePath + BuildHasher + Default + Send + Sync,

impl<V, W> PartialReflect for Sum<V, W>

where Sum<V, W>: Any + Send + Sync, V: TypePath + FromReflect + MaybeTyped + RegisterForReflection, W: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

impl<const N: usize> PartialReflect for ConvexPolygonMeshBuilder<N>

where ConvexPolygonMeshBuilder<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<const N: usize> PartialReflect for ConvexPolygon<N>

where ConvexPolygon<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<const N: usize> PartialReflect for Polygon<N>

where Polygon<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<const N: usize> PartialReflect for Polyline2d<N>

where Polyline2d<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<const N: usize> PartialReflect for Polyline3d<N>

where Polyline3d<N>: Any + Send + Sync, [Vec3; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,