Trait Reflect

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

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

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

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

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

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

Required Methods

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

Returns the value as a Box<dyn Any>.

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

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

Returns the value as a &dyn Any.

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

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

Returns the value as a &mut dyn Any.

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

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

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

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

Casts this type to a fully-reflected value.

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

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

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

Performs a type-checked assignment of a reflected value to this value.

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

Implementations

impl dyn Reflect

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

where T: Any,

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

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

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

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

where T: Any,

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

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

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

Examples found in repository

examples/reflection/type_data.rs (line 64)

fn main() {
    trait Damageable {
        type Health;
        fn damage(&mut self, damage: Self::Health);
    }

    #[derive(Reflect, PartialEq, Debug)]
    struct Zombie {
        health: u32,
    }

    impl Damageable for Zombie {
        type Health = u32;
        fn damage(&mut self, damage: Self::Health) {
            self.health -= damage;
        }
    }

    // Let's say we have a reflected value.
    // Here we know it's a `Zombie`, but for demonstration purposes let's pretend we don't.
    // Pretend it's just some `Box<dyn Reflect>` value.
    let mut value: Box<dyn Reflect> = Box::new(Zombie { health: 100 });

    // We think `value` might contain a type that implements `Damageable`
    // and now we want to call `Damageable::damage` on it.
    // How can we do this without knowing in advance the concrete type is `Zombie`?

    // This is where type data comes in.
    // Type data is a way of associating type-specific data with a type for use in dynamic contexts.
    // This type data can then be used at runtime to perform type-specific operations.

    // Let's create a type data struct for `Damageable` that we can associate with `Zombie`!

    // Firstly, type data must be cloneable.
    #[derive(Clone)]
    // Next, they are usually named with the `Reflect` prefix (we'll see why in a bit).
    struct ReflectDamageable {
        // Type data can contain whatever you want, but it's common to include function pointers
        // to the type-specific operations you want to perform (such as trait methods).
        // Just remember that we're working with `Reflect` data,
        // so we can't use `Self`, generics, or associated types.
        // In those cases, we'll have to use `dyn Reflect` trait objects.
        damage: fn(&mut dyn Reflect, damage: Box<dyn Reflect>),
    }

    // Now, we can create a blanket implementation of the `FromType` trait to construct our type data
    // for any type that implements `Reflect` and `Damageable`.
    impl<T: Reflect + Damageable<Health: Reflect>> FromType<T> for ReflectDamageable {
        fn from_type() -> Self {
            Self {
                damage: |reflect, damage| {
                    // This requires that `reflect` is `T` and not a dynamic representation like `DynamicStruct`.
                    // We could have the function pointer return a `Result`, but we'll just `unwrap` for simplicity.
                    let damageable = reflect.downcast_mut::<T>().unwrap();
                    let damage = damage.take::<T::Health>().unwrap();
                    damageable.damage(damage);
                },
            }
        }
    }

    // It's also common to provide convenience methods for calling the type-specific operations.
    impl ReflectDamageable {
        pub fn damage(&self, reflect: &mut dyn Reflect, damage: Box<dyn Reflect>) {
            (self.damage)(reflect, damage);
        }
    }

    // With all this done, we're ready to make use of `ReflectDamageable`!
    // It starts with registering our type along with its type data:
    let mut registry = TypeRegistry::default();
    registry.register::<Zombie>();
    registry.register_type_data::<Zombie, ReflectDamageable>();

    // Then at any point we can retrieve the type data from the registry:
    let type_id = value.reflect_type_info().type_id();
    let reflect_damageable = registry
        .get_type_data::<ReflectDamageable>(type_id)
        .unwrap();

    // And call our method:
    reflect_damageable.damage(value.as_reflect_mut(), Box::new(25u32));
    assert_eq!(value.take::<Zombie>().unwrap(), Zombie { health: 75 });

    // This is a simple example, but type data can be used for much more complex operations.
    // Bevy also provides some useful shorthand for working with type data.

    // For example, we can have the type data be automatically registered when we register the type
    // by using the `#[reflect(MyTrait)]` attribute when defining our type.
    #[derive(Reflect)]
    // Notice that we don't need to type out `ReflectDamageable`.
    // This is why we named it with the `Reflect` prefix:
    // the derive macro will automatically look for a type named `ReflectDamageable` in the current scope.
    #[reflect(Damageable)]
    struct Skeleton {
        health: u32,
    }

    impl Damageable for Skeleton {
        type Health = u32;
        fn damage(&mut self, damage: Self::Health) {
            self.health -= damage;
        }
    }

    // This will now register `Skeleton` along with its `ReflectDamageable` type data.
    registry.register::<Skeleton>();

    // And for object-safe traits (see https://doc.rust-lang.org/reference/items/traits.html#object-safety),
    // Bevy provides a convenience macro for generating type data that converts `dyn Reflect` into `dyn MyTrait`.
    #[reflect_trait]
    trait Health {
        fn health(&self) -> u32;
    }

    impl Health for Skeleton {
        fn health(&self) -> u32 {
            self.health
        }
    }

    // Using the `#[reflect_trait]` macro we're able to automatically generate a `ReflectHealth` type data struct,
    // which can then be registered like any other type data:
    registry.register_type_data::<Skeleton, ReflectHealth>();

    // Now we can use `ReflectHealth` to convert `dyn Reflect` into `dyn Health`:
    let value: Box<dyn Reflect> = Box::new(Skeleton { health: 50 });

    let type_id = value.reflect_type_info().type_id();
    let reflect_health = registry.get_type_data::<ReflectHealth>(type_id).unwrap();

    // Type data generated by `#[reflect_trait]` comes with a `get`, `get_mut`, and `get_boxed` method,
    // which convert `&dyn Reflect` into `&dyn MyTrait`, `&mut dyn Reflect` into `&mut dyn MyTrait`,
    // and `Box<dyn Reflect>` into `Box<dyn MyTrait>`, respectively.
    let value: &dyn Health = reflect_health.get(value.as_reflect()).unwrap();
    assert_eq!(value.health(), 50);

    // Lastly, here's a list of some useful type data provided by Bevy that you might want to register for your types:
    // - `ReflectDefault` for types that implement `Default`
    // - `ReflectFromWorld` for types that implement `FromWorld`
    // - `ReflectComponent` for types that implement `Component`
    // - `ReflectResource` for types that implement `Resource`
    // - `ReflectSerialize` for types that implement `Serialize`
    // - `ReflectDeserialize` for types that implement `Deserialize`
    //
    // And here are some that are automatically registered by the `Reflect` derive macro:
    // - `ReflectFromPtr`
    // - `ReflectFromReflect` (if not `#[reflect(from_reflect = false)]`)
}

examples/reflection/reflection_types.rs (line 140)

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]);
}

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

where T: Any,

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

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

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

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

where T: Any,

Downcasts the value to type T by reference.

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

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

Examples found in repository

examples/reflection/custom_attributes.rs (line 63)

fn main() {
    // Bevy supports statically registering custom attribute data on reflected types,
    // which can then be accessed at runtime via the type's `TypeInfo`.
    // Attributes are registered using the `#[reflect(@...)]` syntax,
    // where the `...` is any expression that resolves to a value which implements `Reflect`.
    // Note that these attributes are stored based on their type:
    // if two attributes have the same type, the second one will overwrite the first.

    // Here is an example of registering custom attributes on a type:
    #[derive(Reflect)]
    struct Slider {
        #[reflect(@RangeInclusive::<f32>::new(0.0, 1.0))]
        // Alternatively, we could have used the `0.0..=1.0` syntax,
        // but remember to ensure the type is the one you want!
        #[reflect(@0.0..=1.0_f32)]
        value: f32,
    }

    // Now, we can access the custom attributes at runtime:
    let TypeInfo::Struct(type_info) = Slider::type_info() else {
        panic!("expected struct");
    };

    let field = type_info.field("value").unwrap();

    let range = field.get_attribute::<RangeInclusive<f32>>().unwrap();
    assert_eq!(*range, 0.0..=1.0);

    // And remember that our attributes can be any type that implements `Reflect`:
    #[derive(Reflect)]
    struct Required;

    #[derive(Reflect, PartialEq, Debug)]
    struct Tooltip(String);

    impl Tooltip {
        fn new(text: &str) -> Self {
            Self(text.to_string())
        }
    }

    #[derive(Reflect)]
    #[reflect(@Required, @Tooltip::new("An ID is required!"))]
    struct Id(u8);

    let TypeInfo::TupleStruct(type_info) = Id::type_info() else {
        panic!("expected struct");
    };

    // We can check if an attribute simply exists on our type:
    assert!(type_info.has_attribute::<Required>());

    // We can also get attribute data dynamically:
    let some_type_id = TypeId::of::<Tooltip>();

    let tooltip: &dyn Reflect = type_info.get_attribute_by_id(some_type_id).unwrap();
    assert_eq!(
        tooltip.downcast_ref::<Tooltip>(),
        Some(&Tooltip::new("An ID is required!"))
    );

    // And again, attributes of the same type will overwrite each other:
    #[derive(Reflect)]
    enum Status {
        // This will result in `false` being stored:
        #[reflect(@true)]
        #[reflect(@false)]
        Disabled,
        // This will result in `true` being stored:
        #[reflect(@false)]
        #[reflect(@true)]
        Enabled,
    }

    let TypeInfo::Enum(type_info) = Status::type_info() else {
        panic!("expected enum");
    };

    let disabled = type_info.variant("Disabled").unwrap();
    assert!(!disabled.get_attribute::<bool>().unwrap());

    let enabled = type_info.variant("Enabled").unwrap();
    assert!(enabled.get_attribute::<bool>().unwrap());
}

examples/reflection/reflection.rs (line 76)

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/dynamic_types.rs (line 43)

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 downcast_mut<T>(&mut self) -> Option<&mut T>

where T: Any,

Downcasts the value to type T by mutable reference.

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

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

Examples found in repository

examples/reflection/type_data.rs (line 63)

        fn from_type() -> Self {
            Self {
                damage: |reflect, damage| {
                    // This requires that `reflect` is `T` and not a dynamic representation like `DynamicStruct`.
                    // We could have the function pointer return a `Result`, but we'll just `unwrap` for simplicity.
                    let damageable = reflect.downcast_mut::<T>().unwrap();
                    let damage = damage.take::<T::Health>().unwrap();
                    damageable.damage(damage);
                },
            }
        }

Trait Implementations

impl Debug for dyn Reflect

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

Formats the value using the given formatter.

impl TypePath for dyn Reflect

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.

impl Typed for dyn Reflect

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

Implementations on Foreign Types

impl Reflect for &'static str

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

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

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

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

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

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

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

impl Reflect for &'static Location<'static>

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

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

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

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

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

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

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

impl Reflect for &'static Path

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

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

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

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

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

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

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

impl Reflect for Cow<'static, str>

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

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

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

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

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

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

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

impl Reflect for Cow<'static, Path>

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

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

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

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

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

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

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

impl Reflect for SocketAddr

where SocketAddr: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for bool

where bool: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for char

where char: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for f32

where f32: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for f64

where f64: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for i8

where i8: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for i16

where i16: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for i32

where i32: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for i64

where i64: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for i128

where i128: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for isize

where isize: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for u8

where u8: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for u16

where u16: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for u32

where u32: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for u64

where u64: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for u128

where u128: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for ()

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

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

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

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

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

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

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

impl Reflect for usize

where usize: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for TypeId

where TypeId: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NonZero<i8>

where NonZero<i8>: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NonZero<i16>

where NonZero<i16>: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NonZero<i32>

where NonZero<i32>: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NonZero<i64>

where NonZero<i64>: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NonZero<i128>

where NonZero<i128>: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NonZero<isize>

where NonZero<isize>: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NonZero<u8>

where NonZero<u8>: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NonZero<u16>

where NonZero<u16>: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NonZero<u32>

where NonZero<u32>: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NonZero<u64>

where NonZero<u64>: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NonZero<u128>

where NonZero<u128>: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NonZero<usize>

where NonZero<usize>: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for RangeFull

where RangeFull: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for Duration

where Duration: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for OsString

where OsString: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for PathBuf

where PathBuf: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for NodeIndex

where NodeIndex: Any + Send + Sync,

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

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

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

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

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

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

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

impl Reflect for SmolStr

where SmolStr: Any + Send + Sync,

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

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

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

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

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

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

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

impl<A> Reflect for (A,)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<A, B> Reflect for (A, B)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<A, B, C> Reflect for (A, B, C)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<A, B, C, D> Reflect for (A, B, C, D)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<A, B, C, D, E> Reflect for (A, B, C, D, E)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<A, B, C, D, E, F> Reflect for (A, B, C, D, E, F)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<A, B, C, D, E, F, G> Reflect for (A, B, C, D, E, F, G)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<A, B, C, D, E, F, G, H> Reflect for (A, B, C, D, E, F, G, H)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<A, B, C, D, E, F, G, H, I> Reflect for (A, B, C, D, E, F, G, H, I)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration, I: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<A, B, C, D, E, F, G, H, I, J> Reflect for (A, B, C, D, E, F, G, H, I, J)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration, I: Reflect + MaybeTyped + TypePath + GetTypeRegistration, J: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K> Reflect for (A, B, C, D, E, F, G, H, I, J, K)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration, I: Reflect + MaybeTyped + TypePath + GetTypeRegistration, J: Reflect + MaybeTyped + TypePath + GetTypeRegistration, K: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L> Reflect for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration, I: Reflect + MaybeTyped + TypePath + GetTypeRegistration, J: Reflect + MaybeTyped + TypePath + GetTypeRegistration, K: Reflect + MaybeTyped + TypePath + GetTypeRegistration, L: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<K, V> Reflect for BTreeMap<K, V>

where K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Ord, V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<K, V, S> Reflect 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 into_any(self: Box<HashMap<K, V, S>>) -> Box<dyn Any>

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

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

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

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

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

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

impl<N, E, Ix> Reflect for Graph<N, E, Directed, Ix>

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

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

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

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

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

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

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

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

impl<T> Reflect for Cow<'static, [T]>

where T: FromReflect + Clone + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<T> Reflect for Bound<T>

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

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

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

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

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

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

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

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

impl<T> Reflect for Option<T>

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

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

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

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

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

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

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

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

impl<T> Reflect for BinaryHeap<T>

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

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

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

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

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

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

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

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

impl<T> Reflect for BTreeSet<T>

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

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

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

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

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

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

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

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

impl<T> Reflect for VecDeque<T>

where T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

impl<T> Reflect for Saturating<T>

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

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

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

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

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

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

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

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

impl<T> Reflect for Wrapping<T>

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

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

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

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

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

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

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

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

impl<T> Reflect for Range<T>

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

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

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

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

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

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

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

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

impl<T> Reflect for RangeFrom<T>

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

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

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

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

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

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

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

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

impl<T> Reflect for RangeInclusive<T>

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

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

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

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

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

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

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

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

impl<T> Reflect for RangeTo<T>

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

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

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

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

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

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

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

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

impl<T> Reflect for RangeToInclusive<T>

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

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

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

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

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

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

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

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

impl<T> Reflect for SmallVec<T>

where T: Array + TypePath + Send + Sync, <T as Array>::Item: FromReflect + MaybeTyped + TypePath,

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

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

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

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

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

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

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

impl<T, E> Reflect for Result<T, E>

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

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

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

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

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

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

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

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

impl<T, const N: usize> Reflect for [T; N]

where T: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

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

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

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

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

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

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

where V: FromReflect + TypePath + GetTypeRegistration + Eq + Hash, S: TypePath + BuildHasher + Default + Send + Sync,

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

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

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

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

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

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

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

Implementors

impl Reflect for AccessibilitySystem

where AccessibilitySystem: Any + Send + Sync,

impl Reflect for RepeatAnimation

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

impl Reflect for bevy::animation::gltf_curves::WeightsCurve

where WeightsCurve: Any + Send + Sync, ConstantCurve<Vec<f32>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WideLinearKeyframeCurve<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WideSteppedKeyframeCurve<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WideCubicKeyframeCurve<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PlaybackMode

where PlaybackMode: Any + Send + Sync,

impl Reflect for Volume

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

impl Reflect for BloomCompositeMode

where BloomCompositeMode: Any + Send + Sync,

impl Reflect for Camera3dDepthLoadOp

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

impl Reflect for ScreenSpaceTransmissionQuality

where ScreenSpaceTransmissionQuality: Any + Send + Sync,

impl Reflect for DepthOfFieldMode

where DepthOfFieldMode: Any + Send + Sync,

impl Reflect for Sensitivity

where Sensitivity: Any + Send + Sync,

impl Reflect for SmaaPreset

where SmaaPreset: Any + Send + Sync,

impl Reflect for DebandDither

where DebandDither: Any + Send + Sync,

impl Reflect for Tonemapping

where Tonemapping: Any + Send + Sync,

impl Reflect for ButtonState

where ButtonState: Any + Send + Sync,

impl Reflect for GamepadConnection

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

impl Reflect for GamepadEvent

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

impl Reflect for GamepadInput

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

impl Reflect for GamepadRumbleRequest

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

impl Reflect for RawGamepadEvent

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

impl Reflect for Key

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

impl Reflect for NativeKey

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

impl Reflect for NativeKeyCode

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

impl Reflect for MouseScrollUnit

where MouseScrollUnit: Any + Send + Sync,

impl Reflect for ForceTouch

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

impl Reflect for TouchPhase

where TouchPhase: Any + Send + Sync,

impl Reflect for CompassOctant

where CompassOctant: Any + Send + Sync,

impl Reflect for CompassQuadrant

where CompassQuadrant: Any + Send + Sync,

impl Reflect for ClusterConfig

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

impl Reflect for ClusterFarZMode

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

impl Reflect for OpaqueRendererMethod

where OpaqueRendererMethod: Any + Send + Sync,

impl Reflect for ScreenSpaceAmbientOcclusionQualityLevel

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

impl Reflect for ShadowFilteringMethod

where ShadowFilteringMethod: Any + Send + Sync,

impl Reflect for UvChannel

where UvChannel: Any + Send + Sync,

impl Reflect for PickingInteraction

where PickingInteraction: Any + Send + Sync,

impl Reflect for Backfaces

where Backfaces: Any + Send + Sync,

impl Reflect for PointerAction

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

impl Reflect for PointerId

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

impl Reflect for PressDirection

where PressDirection: Any + Send + Sync,

impl Reflect for AlignContent

where AlignContent: Any + Send + Sync,

impl Reflect for AlignItems

where AlignItems: Any + Send + Sync,

impl Reflect for AlignSelf

where AlignSelf: Any + Send + Sync,

impl Reflect for AlphaMode

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

impl Reflect for AnimationNodeType

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

impl Reflect for BoxSizing

where BoxSizing: Any + Send + Sync,

impl Reflect for ClearColorConfig

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

impl Reflect for Color

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

impl Reflect for Display

where Display: Any + Send + Sync,

impl Reflect for EaseFunction

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

impl Reflect for EulerRot

where EulerRot: Any + Send + Sync,

impl Reflect for FileDragAndDrop

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

impl Reflect for FlexDirection

where FlexDirection: Any + Send + Sync,

impl Reflect for FlexWrap

where FlexWrap: Any + Send + Sync,

impl Reflect for FogFalloff

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

impl Reflect for GamepadAxis

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

impl Reflect for GamepadButton

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

impl Reflect for GizmoLineJoint

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

impl Reflect for GizmoLineStyle

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

impl Reflect for GridAutoFlow

where GridAutoFlow: Any + Send + Sync,

impl Reflect for GridTrackRepetition

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

impl Reflect for Ime

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

impl Reflect for Interaction

where Interaction: Any + Send + Sync,

impl Reflect for JumpAt

where JumpAt: Any + Send + Sync,

impl Reflect for JustifyContent

where JustifyContent: Any + Send + Sync,

impl Reflect for JustifyItems

where JustifyItems: Any + Send + Sync,

impl Reflect for JustifySelf

where JustifySelf: Any + Send + Sync,

impl Reflect for JustifyText

where JustifyText: Any + Send + Sync,

impl Reflect for KeyCode

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

impl Reflect for LightGizmoColor

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

impl Reflect for LineBreak

where LineBreak: Any + Send + Sync,

impl Reflect for MaxTrackSizingFunction

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

impl Reflect for MinTrackSizingFunction

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

impl Reflect for MonitorSelection

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

impl Reflect for MouseButton

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

impl Reflect for Msaa

where Msaa: Any + Send + Sync,

impl Reflect for NodeImageMode

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

impl Reflect for OverflowAxis

where OverflowAxis: Any + Send + Sync,

impl Reflect for OverflowClipBox

where OverflowClipBox: Any + Send + Sync,

impl Reflect for ParallaxMappingMethod

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

impl Reflect for PointerButton

where PointerButton: Any + Send + Sync,

impl Reflect for PositionType

where PositionType: Any + Send + Sync,

impl Reflect for Projection

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

impl Reflect for RayCastVisibility

where RayCastVisibility: Any + Send + Sync,

impl Reflect for bevy::prelude::ScalingMode

where ScalingMode: Any + Send + Sync,

impl Reflect for SliceScaleMode

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

impl Reflect for SpriteImageMode

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

impl Reflect for SpritePickingMode

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

impl Reflect for TimerMode

where TimerMode: Any + Send + Sync,

impl Reflect for UiAntiAlias

where UiAntiAlias: Any + Send + Sync,

impl Reflect for Val

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

impl Reflect for VideoModeSelection

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

impl Reflect for Visibility

where Visibility: Any + Send + Sync,

impl Reflect for WindowPosition

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

impl Reflect for NormalizedRenderTarget

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

impl Reflect for RenderTarget

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

impl Reflect for bevy::render::camera::ScalingMode

where ScalingMode: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CapsuleUvProfile

where CapsuleUvProfile: Any + Send + Sync,

impl Reflect for CircularMeshUvMode

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

impl Reflect for ConeAnchor

where ConeAnchor: Any + Send + Sync,

impl Reflect for CylinderAnchor

where CylinderAnchor: Any + Send + Sync,

impl Reflect for Indices

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

impl Reflect for SphereKind

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

impl Reflect for AlphaMode2d

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

impl Reflect for Anchor

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

impl Reflect for FontSmoothing

where FontSmoothing: Any + Send + Sync,

impl Reflect for LineHeight

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

impl Reflect for FocusPolicy

where FocusPolicy: Any + Send + Sync,

impl Reflect for AppLifecycle

where AppLifecycle: Any + Send + Sync,

impl Reflect for CompositeAlphaMode

where CompositeAlphaMode: Any + Send + Sync,

impl Reflect for CursorGrabMode

where CursorGrabMode: Any + Send + Sync,

impl Reflect for PresentMode

where PresentMode: Any + Send + Sync,

impl Reflect for SystemCursorIcon

where SystemCursorIcon: Any + Send + Sync,

impl Reflect for WindowEvent

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

impl Reflect for WindowLevel

where WindowLevel: Any + Send + Sync,

impl Reflect for WindowMode

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

impl Reflect for WindowRef

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

impl Reflect for WindowTheme

where WindowTheme: Any + Send + Sync,

impl Reflect for CursorIcon

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

impl Reflect for CustomCursor

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

impl Reflect for AccessibilityRequested

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

impl Reflect for ManageAccessibilityUpdates

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

impl Reflect for CubicRotationCurve

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

impl Reflect for ActiveAnimation

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

impl Reflect for AnimationTarget

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

impl Reflect for AnimationTargetId

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

impl Reflect for AssetIndex

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

impl Reflect for RenderAssetUsages

where RenderAssetUsages: Any + Send + Sync,

impl Reflect for Uuid

where Uuid: Any + Send + Sync,

impl Reflect for DefaultSpatialScale

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

impl Reflect for SpatialScale

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

impl Reflect for AutoExposure

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

impl Reflect for AutoExposureCompensationCurve

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

impl Reflect for Bloom

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

impl Reflect for BloomPrefilter

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

impl Reflect for ContrastAdaptiveSharpening

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

impl Reflect for DenoiseCas

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

impl Reflect for Camera3dDepthTextureUsage

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

impl Reflect for DepthOfField

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

impl Reflect for TemporalAntiAliasing

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

impl Reflect for Fxaa

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

impl Reflect for MotionBlur

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

impl Reflect for OrderIndependentTransparencySettings

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

impl Reflect for ChromaticAberration

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

impl Reflect for DeferredPrepass

where DeferredPrepass: Any + Send + Sync,

impl Reflect for DepthPrepass

where DepthPrepass: Any + Send + Sync,

impl Reflect for MotionVectorPrepass

where MotionVectorPrepass: Any + Send + Sync,

impl Reflect for NormalPrepass

where NormalPrepass: Any + Send + Sync,

impl Reflect for Smaa

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

impl Reflect for Skybox

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

impl Reflect for ComponentId

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

impl Reflect for ComponentTicks

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

impl Reflect for Tick

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

impl Reflect for EntityHash

where EntityHash: Any + Send + Sync,

impl Reflect for EntityHashSet

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

impl Reflect for DefaultQueryFilters

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

impl Reflect for Disabled

where Disabled: Any + Send + Sync,

impl Reflect for Identifier

where Identifier: Any + Send + Sync,

impl Reflect for RemovedComponentEntity

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

impl Reflect for SystemIdMarker

where SystemIdMarker: Any + Send + Sync,

impl Reflect for OnDespawn

where OnDespawn: Any + Send + Sync,

impl Reflect for ErasedGizmoConfigGroup

where ErasedGizmoConfigGroup: Any + Send + Sync,

impl Reflect for GltfMaterialExtras

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

impl Reflect for GltfMaterialName

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

impl Reflect for GltfMeshExtras

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

impl Reflect for GltfSceneExtras

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

impl Reflect for AxisSettings

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

impl Reflect for ButtonAxisSettings

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

impl Reflect for ButtonSettings

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

impl Reflect for GamepadAxisChangedEvent

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

impl Reflect for GamepadButtonChangedEvent

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

impl Reflect for GamepadButtonStateChangedEvent

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

impl Reflect for GamepadConnectionEvent

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

impl Reflect for GamepadRumbleIntensity

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

impl Reflect for RawGamepadAxisChangedEvent

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

impl Reflect for RawGamepadButtonChangedEvent

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

impl Reflect for DoubleTapGesture

where DoubleTapGesture: Any + Send + Sync,

impl Reflect for PanGesture

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

impl Reflect for PinchGesture

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

impl Reflect for RotationGesture

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

impl Reflect for KeyboardFocusLost

where KeyboardFocusLost: Any + Send + Sync,

impl Reflect for KeyboardInput

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

impl Reflect for AccumulatedMouseMotion

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

impl Reflect for AccumulatedMouseScroll

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

impl Reflect for MouseButtonInput

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

impl Reflect for MouseMotion

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

impl Reflect for MouseWheel

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

impl Reflect for DirectionalNavigationMap

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

impl Reflect for NavNeighbors

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

impl Reflect for AutoFocus

where AutoFocus: Any + Send + Sync,

impl Reflect for InputFocus

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

impl Reflect for InputFocusVisible

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

impl Reflect for TabGroup

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

impl Reflect for TabIndex

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

impl Reflect for Aabb2d

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

impl Reflect for Aabb3d

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

impl Reflect for AabbCast2d

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

impl Reflect for AabbCast3d

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

impl Reflect for BoundingCircle

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

impl Reflect for BoundingCircleCast

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

impl Reflect for BoundingSphere

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

impl Reflect for BoundingSphereCast

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

impl Reflect for RayCast2d

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

impl Reflect for RayCast3d

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

impl Reflect for Affine2

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

impl Reflect for Affine3

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

impl Reflect for Affine3A

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

impl Reflect for AspectRatio

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

impl Reflect for DAffine2

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

impl Reflect for DAffine3

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

impl Reflect for DMat2

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

impl Reflect for DMat3

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

impl Reflect for DMat4

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

impl Reflect for DQuat

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

impl Reflect for DVec2

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

impl Reflect for DVec3

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

impl Reflect for DVec4

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

impl Reflect for FloatOrd

where FloatOrd: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for I8Vec2

where I8Vec2: Any + Send + Sync, i8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for I8Vec3

where I8Vec3: Any + Send + Sync, i8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for I8Vec4

where I8Vec4: Any + Send + Sync, i8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for I16Vec2

where I16Vec2: Any + Send + Sync, i16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for I16Vec3

where I16Vec3: Any + Send + Sync, i16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for I16Vec4

where I16Vec4: Any + Send + Sync, i16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for I64Vec2

where I64Vec2: Any + Send + Sync, i64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for I64Vec3

where I64Vec3: Any + Send + Sync, i64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for I64Vec4

where I64Vec4: Any + Send + Sync, i64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for U8Vec2

where U8Vec2: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for U8Vec3

where U8Vec3: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for U8Vec4

where U8Vec4: Any + Send + Sync, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for U16Vec2

where U16Vec2: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for U16Vec3

where U16Vec3: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for U16Vec4

where U16Vec4: Any + Send + Sync, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for U64Vec2

where U64Vec2: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for U64Vec3

where U64Vec3: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for U64Vec4

where U64Vec4: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ClusteredDecal

where ClusteredDecal: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ForwardDecal

where ForwardDecal: Any + Send + Sync,

impl Reflect for MeshletMesh3d

where MeshletMesh3d: Any + Send + Sync, Handle<MeshletMesh>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for IrradianceVolume

where IrradianceVolume: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Atmosphere

where Atmosphere: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for AtmosphereSettings

where AtmosphereSettings: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, UVec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Cascade

where Cascade: Any + Send + Sync, Mat4: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CascadeShadowConfig

where CascadeShadowConfig: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Cascades

where Cascades: Any + Send + Sync, EntityHashMap<Vec<Cascade>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CascadesVisibleEntities

where CascadesVisibleEntities: Any + Send + Sync,

impl Reflect for ClusterZConfig

where ClusterZConfig: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ClusterFarZMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CubemapVisibleEntities

where CubemapVisibleEntities: Any + Send + Sync,

impl Reflect for DefaultOpaqueRendererMethod

where DefaultOpaqueRendererMethod: Any + Send + Sync, OpaqueRendererMethod: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for DirectionalLightShadowMap

where DirectionalLightShadowMap: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for FogVolume

where FogVolume: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Handle<Image>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Lightmap

where Lightmap: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Rect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for MaterialBindGroupIndex

where MaterialBindGroupIndex: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for MaterialBindGroupSlot

where MaterialBindGroupSlot: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for MaterialBindingId

where MaterialBindingId: Any + Send + Sync, MaterialBindGroupIndex: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MaterialBindGroupSlot: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for NotShadowCaster

where NotShadowCaster: Any + Send + Sync,

impl Reflect for NotShadowReceiver

where NotShadowReceiver: Any + Send + Sync,

impl Reflect for PointLightShadowMap

where PointLightShadowMap: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for RenderCascadesVisibleEntities

where RenderCascadesVisibleEntities: Any + Send + Sync,

impl Reflect for RenderCubemapVisibleEntities

where RenderCubemapVisibleEntities: Any + Send + Sync,

impl Reflect for RenderVisibleMeshEntities

where RenderVisibleMeshEntities: Any + Send + Sync,

impl Reflect for ScreenSpaceAmbientOcclusion

where ScreenSpaceAmbientOcclusion: Any + Send + Sync, ScreenSpaceAmbientOcclusionQualityLevel: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ScreenSpaceReflections

where ScreenSpaceReflections: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TransmittedShadowReceiver

where TransmittedShadowReceiver: Any + Send + Sync,

impl Reflect for VisibleMeshEntities

where VisibleMeshEntities: Any + Send + Sync,

impl Reflect for VolumetricFog

where VolumetricFog: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for VolumetricLight

where VolumetricLight: Any + Send + Sync,

impl Reflect for Mesh3dWireframe

where Mesh3dWireframe: Any + Send + Sync, Handle<WireframeMaterial>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for NoWireframe

where NoWireframe: Any + Send + Sync,

impl Reflect for Wireframe

where Wireframe: Any + Send + Sync,

impl Reflect for WireframeColor

where WireframeColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WireframeConfig

where WireframeConfig: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WireframeMaterial

where WireframeMaterial: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for RayId

where RayId: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PointerId: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for HitData

where HitData: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec3>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PointerHits

where PointerHits: Any + Send + Sync, PointerId: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<(Entity, HitData)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for RayMeshHit

where RayMeshHit: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<[Vec3; 3]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<usize>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for SimplifiedMesh

where SimplifiedMesh: Any + Send + Sync, Handle<Mesh>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for bevy::picking::pointer::Location

where Location: Any + Send + Sync, NormalizedRenderTarget: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PointerInput

where PointerInput: Any + Send + Sync, PointerId: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Location: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PointerAction: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PointerInteraction

where PointerInteraction: Any + Send + Sync, Vec<(Entity, HitData)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PointerLocation

where PointerLocation: Any + Send + Sync,

impl Reflect for PointerPress

where PointerPress: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for AtomicBool

where AtomicBool: Any + Send + Sync,

impl Reflect for AtomicI8

where AtomicI8: Any + Send + Sync,

impl Reflect for AtomicI16

where AtomicI16: Any + Send + Sync,

impl Reflect for AtomicI32

where AtomicI32: Any + Send + Sync,

impl Reflect for AtomicI64

where AtomicI64: Any + Send + Sync,

impl Reflect for AtomicIsize

where AtomicIsize: Any + Send + Sync,

impl Reflect for AtomicU8

where AtomicU8: Any + Send + Sync,

impl Reflect for AtomicU16

where AtomicU16: Any + Send + Sync,

impl Reflect for AtomicU32

where AtomicU32: Any + Send + Sync,

impl Reflect for AtomicU64

where AtomicU64: Any + Send + Sync,

impl Reflect for AtomicUsize

where AtomicUsize: Any + Send + Sync,

impl Reflect for Instant

where Instant: Any + Send + Sync,

impl Reflect for AabbGizmoConfigGroup

where AabbGizmoConfigGroup: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Color>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for AmbientLight

where AmbientLight: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for AnimationClip

where AnimationClip: Any + Send + Sync, HashMap<AnimationEventTarget, Vec<TimedAnimationEvent>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for AnimationGraph

where AnimationGraph: Any + Send + Sync, Graph<AnimationGraphNode, ()>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, NodeIndex: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HashMap<AnimationTargetId, u64>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for AnimationGraphHandle

where AnimationGraphHandle: Any + Send + Sync, Handle<AnimationGraph>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for AnimationGraphNode

where AnimationGraphNode: Any + Send + Sync, AnimationNodeType: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for AnimationPlayer

where AnimationPlayer: Any + Send + Sync, HashMap<NodeIndex, ActiveAnimation>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HashMap<NodeIndex, f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for AnimationTransition

where AnimationTransition: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, NodeIndex: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for AnimationTransitions

where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Annulus

where Annulus: Any + Send + Sync, Circle: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Arc2d

where Arc2d: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for BVec2

where BVec2: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for BVec3

where BVec3: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for BVec3A

where BVec3A: Any + Send + Sync,

impl Reflect for BVec4

where BVec4: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for BVec4A

where BVec4A: Any + Send + Sync,

impl Reflect for BackgroundColor

where BackgroundColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for BorderColor

where BorderColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for BorderRadius

where BorderRadius: Any + Send + Sync, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for BorderRect

where BorderRect: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for BoxShadow

where BoxShadow: Any + Send + Sync, Vec<ShadowStyle>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for BoxShadowSamples

where BoxShadowSamples: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Button

where Button: Any + Send + Sync,

impl Reflect for CalculatedClip

where CalculatedClip: Any + Send + Sync, Rect: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Camera2d

where Camera2d: Any + Send + Sync,

impl Reflect for Camera3d

where Camera3d: Any + Send + Sync, Camera3dDepthLoadOp: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Camera3dDepthTextureUsage: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ScreenSpaceTransmissionQuality: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Camera

where Camera: Any + Send + Sync, Option<Viewport>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, isize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RenderTarget: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ClearColorConfig: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<SubCameraView>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Cancel

where Cancel: Any + Send + Sync, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Capsule2d

where Capsule2d: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Capsule3d

where Capsule3d: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ChildOf

where ChildOf: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Children

where Children: Any + Send + Sync, Vec<Entity>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Circle

where Circle: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CircularSector

where CircularSector: Any + Send + Sync, Arc2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CircularSegment

where CircularSegment: Any + Send + Sync, Arc2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ClearColor

where ClearColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Click

where Click: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ColorMaterial

where ColorMaterial: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AlphaMode2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Affine2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Handle<Image>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ComputedNode

where ComputedNode: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, BorderRect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ResolvedBorderRadius: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ComputedNodeTarget

where ComputedNodeTarget: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Cone

where Cone: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ConicalFrustum

where ConicalFrustum: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Cuboid

where Cuboid: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CursorEntered

where CursorEntered: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CursorLeft

where CursorLeft: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CursorMoved

where CursorMoved: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec2>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Cylinder

where Cylinder: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for DefaultGizmoConfigGroup

where DefaultGizmoConfigGroup: Any + Send + Sync,

impl Reflect for Dir2

where Dir2: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Dir3

where Dir3: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Dir3A

where Dir3A: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for DirectionalLight

where DirectionalLight: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for DistanceFog

where DistanceFog: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, FogFalloff: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Drag

where Drag: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for DragDrop

where DragDrop: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for DragEnd

where DragEnd: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for DragEnter

where DragEnter: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for DragEntry

where DragEntry: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for DragLeave

where DragLeave: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for DragOver

where DragOver: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for DragStart

where DragStart: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for DynamicSceneRoot

where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Ellipse

where Ellipse: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Entity

where Entity: Any + Send + Sync,

impl Reflect for EnvironmentMapLight

where EnvironmentMapLight: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Fixed

where Fixed: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Gamepad

where Gamepad: Any + Send + Sync, Option<u16>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ButtonInput<GamepadButton>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Axis<GamepadInput>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for GamepadSettings

where GamepadSettings: Any + Send + Sync, ButtonSettings: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AxisSettings: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ButtonAxisSettings: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HashMap<GamepadButton, ButtonSettings>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HashMap<GamepadAxis, AxisSettings>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HashMap<GamepadButton, ButtonAxisSettings>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Gizmo

where Gizmo: Any + Send + Sync, Handle<GizmoAsset>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GizmoLineConfig: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for GizmoConfig

where GizmoConfig: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GizmoLineConfig: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RenderLayers: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for GizmoConfigStore

where GizmoConfigStore: Any + Send + Sync,

impl Reflect for GizmoLineConfig

where GizmoLineConfig: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GizmoLineStyle: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GizmoLineJoint: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for GlobalTransform

where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for GlobalVolume

where GlobalVolume: Any + Send + Sync, Volume: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for GlobalZIndex

where GlobalZIndex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for GltfExtras

where GltfExtras: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for GridPlacement

where GridPlacement: Any + Send + Sync, Option<NonZero<i16>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<NonZero<u16>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for GridTrack

where GridTrack: Any + Send + Sync, MinTrackSizingFunction: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MaxTrackSizingFunction: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Hsla

where Hsla: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Hsva

where Hsva: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Hwba

where Hwba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for IRect

where IRect: Any + Send + Sync, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for IVec2

where IVec2: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for IVec3

where IVec3: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for IVec4

where IVec4: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Image

where Image: Any + Send + Sync,

impl Reflect for ImageNode

where ImageNode: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<TextureAtlas>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Rect>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, NodeImageMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for InfinitePlane3d

where InfinitePlane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for InheritedVisibility

where InheritedVisibility: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Interval

where Interval: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Isometry2d

where Isometry2d: Any + Send + Sync, Rot2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Isometry3d

where Isometry3d: Any + Send + Sync, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Laba

where Laba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Label

where Label: Any + Send + Sync,

impl Reflect for LayoutConfig

where LayoutConfig: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Lcha

where Lcha: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for LightGizmoConfigGroup

where LightGizmoConfigGroup: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LightGizmoColor: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for LightProbe

where LightProbe: Any + Send + Sync,

impl Reflect for Line2d

where Line2d: Any + Send + Sync, Dir2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Line3d

where Line3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for LinearRgba

where LinearRgba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Mat2

where Mat2: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Mat3

where Mat3: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Mat3A

where Mat3A: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Mat4

where Mat4: Any + Send + Sync, Vec4: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Mesh2d

where Mesh2d: Any + Send + Sync, Handle<Mesh>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Mesh3d

where Mesh3d: Any + Send + Sync, Handle<Mesh>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Mesh

where Mesh: Any + Send + Sync, Option<Indices>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Handle<Image>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec<String>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RenderAssetUsages: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for MeshPickingCamera

where MeshPickingCamera: Any + Send + Sync,

impl Reflect for MeshPickingSettings

where MeshPickingSettings: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RayCastVisibility: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for MorphWeights

where MorphWeights: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Handle<Mesh>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Move

where Move: Any + Send + Sync, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Name

where Name: Any + Send + Sync, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Cow<'static, str>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Node

where Node: Any + Send + Sync, Display: FromReflect + TypePath + MaybeTyped + RegisterForReflection, BoxSizing: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PositionType: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Overflow: FromReflect + TypePath + MaybeTyped + RegisterForReflection, OverflowClipMargin: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AlignItems: FromReflect + TypePath + MaybeTyped + RegisterForReflection, JustifyItems: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AlignSelf: FromReflect + TypePath + MaybeTyped + RegisterForReflection, JustifySelf: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AlignContent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, JustifyContent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, UiRect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, FlexDirection: FromReflect + TypePath + MaybeTyped + RegisterForReflection, FlexWrap: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GridAutoFlow: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<RepeatedGridTrack>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<GridTrack>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GridPlacement: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Oklaba

where Oklaba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Oklcha

where Oklcha: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for OnAdd

where OnAdd: Any + Send + Sync,

impl Reflect for OnInsert

where OnInsert: Any + Send + Sync,

impl Reflect for OnRemove

where OnRemove: Any + Send + Sync,

impl Reflect for OnReplace

where OnReplace: Any + Send + Sync,

impl Reflect for OrthographicProjection

where OrthographicProjection: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ScalingMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Rect: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Out

where Out: Any + Send + Sync, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Outline

where Outline: Any + Send + Sync, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Over

where Over: Any + Send + Sync, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Overflow

where Overflow: Any + Send + Sync, OverflowAxis: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for OverflowClipMargin

where OverflowClipMargin: Any + Send + Sync, OverflowClipBox: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PerspectiveProjection

where PerspectiveProjection: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Pickable

where Pickable: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PickingPlugin

where PickingPlugin: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Plane2d

where Plane2d: Any + Send + Sync, Dir2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Plane3d

where Plane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PlaybackSettings

where PlaybackSettings: Any + Send + Sync, PlaybackMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Volume: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<SpatialScale>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PointLight

where PointLight: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PointerInputPlugin

where PointerInputPlugin: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Pressed

where Pressed: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Quat

where Quat: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Ray2d

where Ray2d: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Dir2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Ray3d

where Ray3d: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for RayCastBackfaces

where RayCastBackfaces: Any + Send + Sync,

impl Reflect for Real

where Real: Any + Send + Sync, Instant: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Instant>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Rect

where Rect: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Rectangle

where Rectangle: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for RegularPolygon

where RegularPolygon: Any + Send + Sync, Circle: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Released

where Released: Any + Send + Sync, PointerButton: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for RepeatedGridTrack

where RepeatedGridTrack: Any + Send + Sync, GridTrackRepetition: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SmallVec<[GridTrack; 1]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ResolvedBorderRadius

where ResolvedBorderRadius: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Rhombus

where Rhombus: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Rot2

where Rot2: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for SceneRoot

where SceneRoot: Any + Send + Sync, Handle<Scene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Scroll

where Scroll: Any + Send + Sync, MouseScrollUnit: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, HitData: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ScrollPosition

where ScrollPosition: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Segment2d

where Segment2d: Any + Send + Sync, [Vec2; 2]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Segment3d

where Segment3d: Any + Send + Sync, [Vec3; 2]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ShadowStyle

where ShadowStyle: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ShowAabbGizmo

where ShowAabbGizmo: Any + Send + Sync, Option<Color>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ShowLightGizmo

where ShowLightGizmo: Any + Send + Sync, Option<LightGizmoColor>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for SpatialListener

where SpatialListener: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Sphere

where Sphere: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for SpotLight

where SpotLight: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Sprite

where Sprite: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<TextureAtlas>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec2>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Rect>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Anchor: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SpriteImageMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for SpritePickingCamera

where SpritePickingCamera: Any + Send + Sync,

impl Reflect for SpritePickingSettings

where SpritePickingSettings: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SpritePickingMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Srgba

where Srgba: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for StandardMaterial

where StandardMaterial: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection, UvChannel: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Handle<Image>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LinearRgba: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AlphaMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ParallaxMappingMethod: FromReflect + TypePath + MaybeTyped + RegisterForReflection, OpaqueRendererMethod: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u8: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Affine2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for String

where String: Any + Send + Sync,

impl Reflect for Tetrahedron

where Tetrahedron: Any + Send + Sync, [Vec3; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Text2d

where Text2d: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Text

where Text: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TextColor

where TextColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TextFont

where TextFont: Any + Send + Sync, Handle<Font>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineHeight: FromReflect + TypePath + MaybeTyped + RegisterForReflection, FontSmoothing: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TextShadow

where TextShadow: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TextSpan

where TextSpan: Any + Send + Sync, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TextureAtlas

where TextureAtlas: Any + Send + Sync, Handle<TextureAtlasLayout>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TextureAtlasLayout

where TextureAtlasLayout: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<URect>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TextureSlicer

where TextureSlicer: Any + Send + Sync, BorderRect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SliceScaleMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ThreadedAnimationGraph

where ThreadedAnimationGraph: Any + Send + Sync, Vec<NodeIndex>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<Range<u32>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<u64>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ThreadedAnimationGraphs

where ThreadedAnimationGraphs: Any + Send + Sync, HashMap<AssetId<AnimationGraph>, ThreadedAnimationGraph>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Timer

where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Torus

where Torus: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TouchInput

where TouchInput: Any + Send + Sync, TouchPhase: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<ForceTouch>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Transform

where Transform: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TransformTreeChanged

where TransformTreeChanged: Any + Send + Sync,

impl Reflect for Triangle2d

where Triangle2d: Any + Send + Sync, [Vec2; 3]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Triangle3d

where Triangle3d: Any + Send + Sync, [Vec3; 3]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for URect

where URect: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for UVec2

where UVec2: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for UVec3

where UVec3: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for UVec4

where UVec4: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for UiPickingCamera

where UiPickingCamera: Any + Send + Sync,

impl Reflect for UiPickingSettings

where UiPickingSettings: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for UiRect

where UiRect: Any + Send + Sync, Val: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for UiScale

where UiScale: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for UiTargetCamera

where UiTargetCamera: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Vec2

where Vec2: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Vec3

where Vec3: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Vec3A

where Vec3A: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Vec4

where Vec4: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ViewVisibility

where ViewVisibility: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Virtual

where Virtual: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Window

where Window: Any + Send + Sync, CursorOptions: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PresentMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowPosition: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowResolution: FromReflect + TypePath + MaybeTyped + RegisterForReflection, String: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<String>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CompositeAlphaMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowResizeConstraints: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, EnabledButtons: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowLevel: FromReflect + TypePath + MaybeTyped + RegisterForReflection, InternalWindowState: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<WindowTheme>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<NonZero<u32>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<(u8, u8)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowMoved

where WindowMoved: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowResizeConstraints

where WindowResizeConstraints: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Xyza

where Xyza: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ZIndex

where ZIndex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CameraMainTextureUsages

where CameraMainTextureUsages: Any + Send + Sync,

impl Reflect for CameraRenderGraph

where CameraRenderGraph: Any + Send + Sync,

impl Reflect for CustomProjection

where CustomProjection: Any + Send + Sync,

impl Reflect for Exposure

where Exposure: Any + Send + Sync,

impl Reflect for ImageRenderTarget

where ImageRenderTarget: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, FloatOrd: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ManualTextureViewHandle

where ManualTextureViewHandle: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for MipBias

where MipBias: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for SubCameraView

where SubCameraView: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TemporalJitter

where TemporalJitter: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Viewport

where Viewport: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Range<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for OcclusionCulling

where OcclusionCulling: Any + Send + Sync,

impl Reflect for GlobalsUniform

where GlobalsUniform: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ReadbackComplete

where ReadbackComplete: Any + Send + Sync, Vec<u8>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for MeshMorphWeights

where MeshMorphWeights: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for SkinnedMesh

where SkinnedMesh: Any + Send + Sync, Handle<SkinnedMeshInverseBindposes>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<Entity>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for AnnulusMeshBuilder

where AnnulusMeshBuilder: Any + Send + Sync, Annulus: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Capsule2dMeshBuilder

where Capsule2dMeshBuilder: Any + Send + Sync, Capsule2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Capsule3dMeshBuilder

where Capsule3dMeshBuilder: Any + Send + Sync, Capsule3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CapsuleUvProfile: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CircleMeshBuilder

where CircleMeshBuilder: Any + Send + Sync, Circle: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CircularSectorMeshBuilder

where CircularSectorMeshBuilder: Any + Send + Sync, CircularSector: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CircularMeshUvMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CircularSegmentMeshBuilder

where CircularSegmentMeshBuilder: Any + Send + Sync, CircularSegment: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CircularMeshUvMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ConeMeshBuilder

where ConeMeshBuilder: Any + Send + Sync, Cone: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ConeAnchor: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ConicalFrustumMeshBuilder

where ConicalFrustumMeshBuilder: Any + Send + Sync, ConicalFrustum: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CuboidMeshBuilder

where CuboidMeshBuilder: Any + Send + Sync, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CylinderMeshBuilder

where CylinderMeshBuilder: Any + Send + Sync, Cylinder: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CylinderAnchor: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for EllipseMeshBuilder

where EllipseMeshBuilder: Any + Send + Sync, Ellipse: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for MeshTag

where MeshTag: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PlaneMeshBuilder

where PlaneMeshBuilder: Any + Send + Sync, Plane3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for RectangleMeshBuilder

where RectangleMeshBuilder: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for RegularPolygonMeshBuilder

where RegularPolygonMeshBuilder: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for RhombusMeshBuilder

where RhombusMeshBuilder: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for SphereMeshBuilder

where SphereMeshBuilder: Any + Send + Sync, Sphere: FromReflect + TypePath + MaybeTyped + RegisterForReflection, SphereKind: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TetrahedronMeshBuilder

where TetrahedronMeshBuilder: Any + Send + Sync, Tetrahedron: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TorusMeshBuilder

where TorusMeshBuilder: Any + Send + Sync, Torus: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, RangeInclusive<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Triangle2dMeshBuilder

where Triangle2dMeshBuilder: Any + Send + Sync, Triangle2d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Triangle3dMeshBuilder

where Triangle3dMeshBuilder: Any + Send + Sync, Triangle3d: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Aabb

where Aabb: Any + Send + Sync, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CascadesFrusta

where CascadesFrusta: Any + Send + Sync,

impl Reflect for CubemapFrusta

where CubemapFrusta: Any + Send + Sync,

impl Reflect for Frustum

where Frustum: Any + Send + Sync,

impl Reflect for ShaderStorageBuffer

where ShaderStorageBuffer: Any + Send + Sync,

impl Reflect for SyncToRenderWorld

where SyncToRenderWorld: Any + Send + Sync,

impl Reflect for TemporaryRenderEntity

where TemporaryRenderEntity: Any + Send + Sync,

impl Reflect for ColorGrading

where ColorGrading: Any + Send + Sync, ColorGradingGlobal: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ColorGradingSection: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ColorGradingGlobal

where ColorGradingGlobal: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Range<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ColorGradingSection

where ColorGradingSection: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for NoFrustumCulling

where NoFrustumCulling: Any + Send + Sync,

impl Reflect for RenderLayers

where RenderLayers: Any + Send + Sync, SmallVec<[u64; 1]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for RenderVisibleEntities

where RenderVisibleEntities: Any + Send + Sync,

impl Reflect for VisibilityClass

where VisibilityClass: Any + Send + Sync, SmallVec<[TypeId; 1]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for VisibilityRange

where VisibilityRange: Any + Send + Sync, Range<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for VisibleEntities

where VisibleEntities: Any + Send + Sync,

impl Reflect for Screenshot

where Screenshot: Any + Send + Sync, RenderTarget: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ScreenshotCaptured

where ScreenshotCaptured: Any + Send + Sync, Image: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for InstanceId

where InstanceId: Any + Send + Sync, Uuid: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for SceneInstanceReady

where SceneInstanceReady: Any + Send + Sync, InstanceId: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Mesh2dWireframe

where Mesh2dWireframe: Any + Send + Sync, Handle<Wireframe2dMaterial>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for NoWireframe2d

where NoWireframe2d: Any + Send + Sync,

impl Reflect for Wireframe2d

where Wireframe2d: Any + Send + Sync,

impl Reflect for Wireframe2dColor

where Wireframe2dColor: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Wireframe2dConfig

where Wireframe2dConfig: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Wireframe2dMaterial

where Wireframe2dMaterial: Any + Send + Sync, Color: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ComputedTextBlock

where ComputedTextBlock: Any + Send + Sync, SmallVec<[TextEntity; 1]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for GlyphAtlasInfo

where GlyphAtlasInfo: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Handle<TextureAtlasLayout>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GlyphAtlasLocation: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for GlyphAtlasLocation

where GlyphAtlasLocation: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PositionedGlyph

where PositionedGlyph: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, GlyphAtlasInfo: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TextBounds

where TextBounds: Any + Send + Sync, Option<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TextEntity

where TextEntity: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TextLayoutInfo

where TextLayoutInfo: Any + Send + Sync, Vec<PositionedGlyph>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Stopwatch

where Stopwatch: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for GhostNode

where GhostNode: Any + Send + Sync,

impl Reflect for ContentSize

where ContentSize: Any + Send + Sync,

impl Reflect for RelativeCursorPosition

where RelativeCursorPosition: Any + Send + Sync, Rect: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<Vec2>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for ImageNodeSize

where ImageNodeSize: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for TextNodeFlags

where TextNodeFlags: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CursorOptions

where CursorOptions: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CursorGrabMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for EnabledButtons

where EnabledButtons: Any + Send + Sync, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for InternalWindowState

where InternalWindowState: Any + Send + Sync, Option<bool>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<CompassOctant>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<DVec2>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for Monitor

where Monitor: Any + Send + Sync, Option<String>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, IVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<u32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<VideoMode>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for NormalizedWindowRef

where NormalizedWindowRef: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for PrimaryMonitor

where PrimaryMonitor: Any + Send + Sync,

impl Reflect for PrimaryWindow

where PrimaryWindow: Any + Send + Sync,

impl Reflect for RequestRedraw

where RequestRedraw: Any + Send + Sync,

impl Reflect for VideoMode

where VideoMode: Any + Send + Sync, UVec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u16: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowBackendScaleFactorChanged

where WindowBackendScaleFactorChanged: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowCloseRequested

where WindowCloseRequested: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowClosed

where WindowClosed: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowClosing

where WindowClosing: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowCreated

where WindowCreated: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowDestroyed

where WindowDestroyed: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowFocused

where WindowFocused: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowOccluded

where WindowOccluded: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowResized

where WindowResized: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowResolution

where WindowResolution: Any + Send + Sync, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowScaleFactorChanged

where WindowScaleFactorChanged: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WindowThemeChanged

where WindowThemeChanged: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, WindowTheme: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for CustomCursorImage

where CustomCursorImage: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<TextureAtlas>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Option<URect>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, (u16, u16): FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl Reflect for WakeUp

where WakeUp: Any + Send + Sync,

impl<'a> Reflect for AssetPath<'a>

where AssetPath<'a>: Any + Send + Sync,

impl<A> Reflect for AssetEvent<A>

where A: Asset + TypePath, AssetEvent<A>: Any + Send + Sync, AssetId<A>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<A> Reflect for AssetId<A>

where A: Asset + TypePath, AssetId<A>: Any + Send + Sync, AssetIndex: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Uuid: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<A> Reflect for Handle<A>

where A: Asset + TypePath, Handle<A>: Any + Send + Sync, Arc<StrongHandle>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, AssetId<A>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<A> Reflect for AnimatableCurveEvaluator<A>

where A: Animatable + TypePath, AnimatableCurveEvaluator<A>: Any + Send + Sync, BasicAnimationCurveEvaluator<A>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Box<dyn AnimatableProperty<Property = A>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<B, E> Reflect for ExtendedMaterial<B, E>

where B: Material + FromReflect + TypePath + MaybeTyped + RegisterForReflection, E: MaterialExtension + FromReflect + TypePath + MaybeTyped + RegisterForReflection, ExtendedMaterial<B, E>: Any + Send + Sync,

impl<C> Reflect for SampleDerivativeWrapper<C>

where SampleDerivativeWrapper<C>: Any + Send + Sync, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<C> Reflect for SampleTwoDerivativesWrapper<C>

where SampleTwoDerivativesWrapper<C>: Any + Send + Sync, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<C> Reflect for bevy::prelude::WeightsCurve<C>

where WeightsCurve<C>: Any + Send + Sync, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<Config, Clear> Reflect for GizmoBuffer<Config, Clear>

where GizmoBuffer<Config, Clear>: Any + Send + Sync, Config: GizmoConfigGroup + TypePath, Clear: 'static + Send + Sync + TypePath, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<Vec3>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<LinearRgba>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<E> Reflect for EventId<E>

where E: Event + TypePath, EventId<E>: Any + Send + Sync, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection, MaybeLocation: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<E> Reflect for FocusedInput<E>

where E: Event + Clone + TypePath + FromReflect + MaybeTyped + RegisterForReflection, FocusedInput<E>: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<E> Reflect for Events<E>

where E: Event + TypePath, Events<E>: Any + Send + Sync, EventSequence<E>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<E> Reflect for Pointer<E>

where E: Debug + Clone + Reflect + TypePath + FromReflect + MaybeTyped + RegisterForReflection, Pointer<E>: Any + Send + Sync, Entity: FromReflect + TypePath + MaybeTyped + RegisterForReflection, PointerId: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Location: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<K, V, S> Reflect 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> Reflect for MaterialNode<M>

where M: UiMaterial + TypePath, MaterialNode<M>: Any + Send + Sync, Handle<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<M> Reflect for MeshMaterial2d<M>

where M: Material2d + TypePath, MeshMaterial2d<M>: Any + Send + Sync, Handle<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<M> Reflect for MeshMaterial3d<M>

where M: Material + TypePath, MeshMaterial3d<M>: Any + Send + Sync, Handle<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> Reflect for LinearSpline<P>

where P: VectorSpace + TypePath, LinearSpline<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> Reflect for CubicBSpline<P>

where P: VectorSpace + TypePath, CubicBSpline<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> Reflect for CubicBezier<P>

where P: VectorSpace + TypePath, CubicBezier<P>: Any + Send + Sync, Vec<[P; 4]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> Reflect for CubicCardinalSpline<P>

where P: VectorSpace + TypePath, CubicCardinalSpline<P>: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> Reflect for CubicCurve<P>

where P: VectorSpace + TypePath, CubicCurve<P>: Any + Send + Sync, Vec<CubicSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> Reflect for CubicHermite<P>

where P: VectorSpace + TypePath, CubicHermite<P>: Any + Send + Sync, Vec<(P, P)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> Reflect for CubicNurbs<P>

where P: VectorSpace + TypePath, CubicNurbs<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> Reflect for CubicSegment<P>

where P: VectorSpace + TypePath, CubicSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> Reflect for RationalCurve<P>

where P: VectorSpace + TypePath, RationalCurve<P>: Any + Send + Sync, Vec<RationalSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> Reflect for RationalSegment<P>

where P: VectorSpace + TypePath, RationalSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection, [f32; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P, C> Reflect for AnimatableCurve<P, C>

where AnimatableCurve<P, C>: Any + Send + Sync, P: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<S> Reflect for NextState<S>

where S: FreelyMutableState + TypePath + FromReflect + MaybeTyped + RegisterForReflection, NextState<S>: Any + Send + Sync,

impl<S> Reflect for State<S>

where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, State<S>: Any + Send + Sync,

impl<S> Reflect for StateScoped<S>

where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, StateScoped<S>: Any + Send + Sync,

impl<S, T, C, D> Reflect for ZipCurve<S, T, C, D>

where ZipCurve<S, T, C, D>: Any + Send + Sync, S: TypePath, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, D: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<S, T, C, F> Reflect for MapCurve<S, T, C, F>

where MapCurve<S, T, C, F>: Any + Send + Sync, C: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, S: TypePath, T: TypePath,

impl<Source> Reflect for AudioPlayer<Source>

where AudioPlayer<Source>: Any + Send + Sync, Source: Asset + Decodable + TypePath, Handle<Source>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for InterpolationDatum<T>

where InterpolationDatum<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for CubicKeyframeCurve<T>

where CubicKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for SteppedKeyframeCurve<T>

where SteppedKeyframeCurve<T>: Any + Send + Sync, T: TypePath, UnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for WideCubicKeyframeCurve<T>

where WideCubicKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for WideLinearKeyframeCurve<T>

where WideLinearKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for WideSteppedKeyframeCurve<T>

where WideSteppedKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for ColorCurve<T>

where ColorCurve<T>: Any + Send + Sync, T: TypePath, EvenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for MaybeLocation<T>

where MaybeLocation<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection + ?Sized,

impl<T> Reflect for WithDerivative<T>

where WithDerivative<T>: Any + Send + Sync, T: HasTangent + TypePath + FromReflect + MaybeTyped + RegisterForReflection, <T as HasTangent>::Tangent: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for WithTwoDerivatives<T>

where WithTwoDerivatives<T>: Any + Send + Sync, T: HasTangent + TypePath + FromReflect + MaybeTyped + RegisterForReflection, <T as HasTangent>::Tangent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, <<T as HasTangent>::Tangent as HasTangent>::Tangent: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for Arc<T>

where T: Send + Sync + TypePath + ?Sized, Arc<T>: Any + Send + Sync,

impl<T> Reflect for ChunkedUnevenCore<T>

where ChunkedUnevenCore<T>: Any + Send + Sync, T: TypePath, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for AnimatableKeyframeCurve<T>

where AnimatableKeyframeCurve<T>: Any + Send + Sync, T: TypePath, UnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for Axis<T>

where Axis<T>: Any + Send + Sync, T: TypePath, HashMap<T, f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for ButtonInput<T>

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

impl<T> Reflect for ConstantCurve<T>

where ConstantCurve<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection, Interval: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for EasingCurve<T>

where EasingCurve<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection, EaseFunction: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for EvenCore<T>

where EvenCore<T>: Any + Send + Sync, T: TypePath, Interval: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for SampleAutoCurve<T>

where SampleAutoCurve<T>: Any + Send + Sync, T: TypePath, EvenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for Time<T>

where T: Default + TypePath + FromReflect + MaybeTyped + RegisterForReflection, Time<T>: Any + Send + Sync, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, f64: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for UnevenCore<T>

where UnevenCore<T>: Any + Send + Sync, T: TypePath, Vec<f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for UnevenSampleAutoCurve<T>

where UnevenSampleAutoCurve<T>: Any + Send + Sync, T: TypePath, UnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> Reflect for Vec<T>

where T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,

impl<T, C> Reflect for ForeverCurve<T, C>

where ForeverCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C> Reflect for GraphCurve<T, C>

where GraphCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C> Reflect for LinearReparamCurve<T, C>

where LinearReparamCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T, C> Reflect for PingPongCurve<T, C>

where PingPongCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C> Reflect for RepeatCurve<T, C>

where RepeatCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T, C> Reflect for ReverseCurve<T, C>

where ReverseCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C, D> Reflect for ChainCurve<T, C, D>

where ChainCurve<T, C, D>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, D: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C, D> Reflect for ContinuationCurve<T, C, D>

where ContinuationCurve<T, C, D>: Any + Send + Sync, T: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, D: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C, D> Reflect for CurveReparamCurve<T, C, D>

where CurveReparamCurve<T, C, D>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, D: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C, F> Reflect for ReparamCurve<T, C, F>

where ReparamCurve<T, C, F>: Any + Send + Sync, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, C: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

impl<T, F> Reflect for FunctionCurve<T, F>

where FunctionCurve<T, F>: Any + Send + Sync, Interval: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

impl<T, I> Reflect for SampleCurve<T, I>

where SampleCurve<T, I>: Any + Send + Sync, EvenCore<T>: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

impl<T, I> Reflect for UnevenSampleCurve<T, I>

where UnevenSampleCurve<T, I>: Any + Send + Sync, UnevenCore<T>: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

impl<V> Reflect for EntityHashMap<V>

where EntityHashMap<V>: Any + Send + Sync, V: TypePath, HashMap<Entity, V, EntityHash>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<V> Reflect for EntityIndexMap<V>

where EntityIndexMap<V>: Any + Send + Sync, V: TypePath, IndexMap<Entity, V, EntityHash>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<V, S> Reflect for bevy::platform::collections::HashSet<V, S>

where V: FromReflect + TypePath + GetTypeRegistration + Eq + Hash, S: TypePath + BuildHasher + Default + Send + Sync,

impl<V, W> Reflect for Sum<V, W>

where Sum<V, W>: Any + Send + Sync, V: TypePath + FromReflect + MaybeTyped + RegisterForReflection, W: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

impl<const N: usize> Reflect for ConvexPolygon<N>

where ConvexPolygon<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<const N: usize> Reflect for Polygon<N>

where Polygon<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<const N: usize> Reflect for Polyline2d<N>

where Polyline2d<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<const N: usize> Reflect for Polyline3d<N>

where Polyline3d<N>: Any + Send + Sync, [Vec3; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<const N: usize> Reflect for ConvexPolygonMeshBuilder<N>

where ConvexPolygonMeshBuilder<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,