Trait bevy::reflect::prelude::Reflect

pub trait Reflect: DynamicTypePath + Any + Send + Sync {
Show 18 methods // Required methods fn get_represented_type_info(&self) -> Option<&'static TypeInfo>; fn into_any(self: Box<Self, Global>) -> Box<dyn Any, Global>; fn as_any(&self) -> &(dyn Any + 'static); fn as_any_mut(&mut self) -> &mut (dyn Any + 'static); fn into_reflect(self: Box<Self, Global>) -> Box<dyn Reflect, Global>; fn as_reflect(&self) -> &(dyn Reflect + 'static); fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static); fn apply(&mut self, value: &(dyn Reflect + 'static)); fn set( &mut self, value: Box<dyn Reflect, Global> ) -> Result<(), Box<dyn Reflect, Global>>; fn reflect_ref(&self) -> ReflectRef<'_>; fn reflect_mut(&mut self) -> ReflectMut<'_>; fn reflect_owned(self: Box<Self, Global>) -> ReflectOwned; fn clone_value(&self) -> Box<dyn Reflect, Global>; // Provided methods fn reflect_hash(&self) -> Option<u64> { ... } fn reflect_partial_eq( &self, _value: &(dyn Reflect + 'static) ) -> Option<bool> { ... } fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error> { ... } fn serializable(&self) -> Option<Serializable<'_>> { ... } fn is_dynamic(&self) -> bool { ... }
}
Expand description

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

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

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

Required Methods§

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

Returns the TypeInfo of the type represented by this value.

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

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

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

Returns the value as a Box<dyn Any>.

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

Returns the value as a &dyn Any.

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

Returns the value as a &mut dyn Any.

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

Casts this type to a boxed reflected value.

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

Casts this type to a reflected value.

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

Casts this type to a mutable reflected value.

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

Applies a reflected value to this value.

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

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

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

Panics

Derived implementations of this method will panic:

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

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

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.

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

Returns an enumeration of “kinds” of type.

See ReflectRef.

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

Returns a mutable enumeration of “kinds” of type.

See ReflectMut.

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

Returns an owned enumeration of “kinds” of type.

See ReflectOwned.

fn clone_value(&self) -> Box<dyn Reflect, Global>

Clones the value as a Reflect trait object.

When deriving Reflect for a struct, tuple struct or enum, the value is cloned via Struct::clone_dynamic, TupleStruct::clone_dynamic, or Enum::clone_dynamic, respectively. Implementors of other Reflect subtraits (e.g. List, Map) should use those subtraits’ respective clone_dynamic methods.

Provided Methods§

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

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

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

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

Returns a “partial equality” comparison result.

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

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

Debug formatter for the value.

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

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

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

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

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

By default, this method will return false.

Implementations§

§

impl dyn Reflect

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

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

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

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

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

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

pub fn represents<T>(&self) -> boolwhere T: Reflect + TypePath,

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

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

pub fn is<T>(&self) -> boolwhere T: Reflect,

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.

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

Downcasts the value to type T by reference.

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

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

Downcasts the value to type T by mutable reference.

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

Trait Implementations§

§

impl Debug for dyn Reflect

§

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

Formats the value using the given formatter. Read more
§

impl TypePath for dyn Reflect

§

fn type_path() -> &'static str

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

fn short_type_path() -> &'static str

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

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

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

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

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

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

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

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 i64

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<RangeFrom<T>, Global>) -> ReflectOwned

§

impl Reflect for isize

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl Reflect for Cow<'static, Path>

§

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

§

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

§

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>, Global> ) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

impl Reflect for i16

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<(A, B), Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

impl Reflect for bool

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl Reflect for NonZeroU16

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<NonZeroU16, Global>) -> ReflectOwned

§

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

§

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

§

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

§

impl Reflect for u32

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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), Global> ) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D, E, F, G, H, I), Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

impl Reflect for u8

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl Reflect for SmolStr

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<SmolStr, Global>) -> ReflectOwned

§

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

§

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

§

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

§

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

§

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

§

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

§

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), Global>) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C), Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

impl Reflect for NonZeroU32

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<NonZeroU32, Global>) -> ReflectOwned

§

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

§

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

§

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

§

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 + TypePath, B: Reflect + TypePath, C: Reflect + TypePath, D: Reflect + TypePath, E: Reflect + TypePath, F: Reflect + TypePath, G: Reflect + TypePath, H: Reflect + TypePath, I: Reflect + TypePath, J: Reflect + TypePath, K: Reflect + TypePath,

§

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

§

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

§

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), Global> ) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned( self: Box<(A, B, C, D, E, F, G, H, I, J, K), Global> ) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

impl<T, E> Reflect for Result<T, E>where T: Clone + Reflect + TypePath, E: Clone + Reflect + TypePath,

§

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

§

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

§

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>, Global>) -> Box<dyn Reflect, Global>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<Result<T, E>, Global>) -> ReflectOwned

§

impl Reflect for NonZeroU8

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<NonZeroU8, Global>) -> ReflectOwned

§

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

§

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

§

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

§

impl Reflect for NonZeroU128

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<NonZeroU128, Global>) -> ReflectOwned

§

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

§

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

§

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

§

impl Reflect for i128

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl Reflect for usize

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<usize, Global>) -> ReflectOwned

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<RangeInclusive<T>, Global>) -> ReflectOwned

§

impl Reflect for char

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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), Global>) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D, E), Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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), Global> ) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D, E, F), Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

impl Reflect for &'static Path

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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), Global> ) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D, E, F, G), Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

impl Reflect for NonZeroIsize

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<NonZeroIsize, Global>) -> ReflectOwned

§

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

§

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

§

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

§

impl Reflect for Cow<'static, str>

§

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

§

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

§

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>, Global> ) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

impl Reflect for RangeFull

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<RangeFull, Global>) -> ReflectOwned

§

impl Reflect for f64

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl Reflect for f32

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl Reflect for NonZeroUsize

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<NonZeroUsize, Global>) -> ReflectOwned

§

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

§

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

§

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

§

impl Reflect for ()

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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), Global> ) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D, E, F, G, H), Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<RangeToInclusive<T>, Global>) -> ReflectOwned

§

impl Reflect for String

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<String, Global>) -> ReflectOwned

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<[T; N], Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

impl Reflect for NonZeroI8

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<NonZeroI8, Global>) -> ReflectOwned

§

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

§

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

§

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

§

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

§

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

§

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]>, Global> ) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<Cow<'static, [T]>, Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<RangeTo<T>, Global>) -> ReflectOwned

§

impl<T> Reflect for Option<T>where T: FromReflect + TypePath,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<Option<T>, Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<SmallVec<T>, Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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 + TypePath, B: Reflect + TypePath, C: Reflect + TypePath, D: Reflect + TypePath, E: Reflect + TypePath, F: Reflect + TypePath, G: Reflect + TypePath, H: Reflect + TypePath, I: Reflect + TypePath, J: Reflect + TypePath, K: Reflect + TypePath, L: Reflect + TypePath,

§

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

§

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

§

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), Global> ) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned( self: Box<(A, B, C, D, E, F, G, H, I, J, K, L), Global> ) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

impl Reflect for NonZeroI16

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<NonZeroI16, Global>) -> ReflectOwned

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<(A,), Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

impl Reflect for u16

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<T> Reflect for Vec<T, Global>where T: FromReflect + TypePath,

§

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

§

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

§

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

§

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

§

fn into_reflect(self: Box<Vec<T, Global>, Global>) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<Vec<T, Global>, Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<Range<T>, Global>) -> ReflectOwned

§

impl Reflect for i32

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl Reflect for NonZeroI64

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<NonZeroI64, Global>) -> ReflectOwned

§

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

§

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

§

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

§

impl Reflect for NonZeroI128

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<NonZeroI128, Global>) -> ReflectOwned

§

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

§

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

§

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

§

impl Reflect for NonZeroI32

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<NonZeroI32, Global>) -> ReflectOwned

§

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

§

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

§

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

§

impl<T> Reflect for Arc<T, Global>where T: Send + Sync + TypePath,

§

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

§

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

§

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

§

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

§

fn into_reflect(self: Box<Arc<T, Global>, Global>) -> Box<dyn Reflect, Global>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<Arc<T, Global>, Global>) -> ReflectOwned

§

impl Reflect for NonZeroU64

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<NonZeroU64, Global>) -> ReflectOwned

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<VecDeque<T, Global>, Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

impl Reflect for OsString

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<OsString, Global>) -> ReflectOwned

§

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

§

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

§

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

§

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

§

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

§

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

§

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), Global>) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D), Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

impl Reflect for PathBuf

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

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

§

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

§

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

§

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

§

fn reflect_owned(self: Box<PathBuf, Global>) -> ReflectOwned

§

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

§

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

§

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

§

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 + TypePath, B: Reflect + TypePath, C: Reflect + TypePath, D: Reflect + TypePath, E: Reflect + TypePath, F: Reflect + TypePath, G: Reflect + TypePath, H: Reflect + TypePath, I: Reflect + TypePath, J: Reflect + TypePath,

§

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

§

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

§

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), Global> ) -> Box<dyn Reflect, Global>

§

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

§

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

§

fn apply(&mut self, value: &(dyn Reflect + 'static))

§

fn set( &mut self, value: Box<dyn Reflect, Global> ) -> Result<(), Box<dyn Reflect, Global>>

§

fn reflect_ref(&self) -> ReflectRef<'_>

§

fn reflect_mut(&mut self) -> ReflectMut<'_>

§

fn reflect_owned( self: Box<(A, B, C, D, E, F, G, H, I, J), Global> ) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

§

impl Reflect for Instant

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Instant, Global>) -> Box<dyn Any, Global>

§

fn as_any(&self) -> &(dyn Any + 'static)

§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

§

fn into_reflect(self: Box<Instant, Global>) -> Box<dyn Reflect, Global>

§

fn as_reflect(&self) -> &(dyn Reflect + 'static)

§

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

fn apply(&mut self, value: &(dyn Reflect + 'static))

§

fn set( &mut self, value: Box<dyn Reflect, Global> ) -> Result<(), Box<dyn Reflect, Global>>

§

fn reflect_ref(&self) -> ReflectRef<'_>

§

fn reflect_mut(&mut self) -> ReflectMut<'_>

§

fn reflect_owned(self: Box<Instant, Global>) -> ReflectOwned

§

fn reflect_hash(&self) -> Option<u64>

§

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

§

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

§

impl Reflect for u128

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<u128, Global>) -> Box<dyn Any, Global>

§

fn as_any(&self) -> &(dyn Any + 'static)

§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

§

fn into_reflect(self: Box<u128, Global>) -> Box<dyn Reflect, Global>

§

fn as_reflect(&self) -> &(dyn Reflect + 'static)

§

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

fn apply(&mut self, value: &(dyn Reflect + 'static))

§

fn set( &mut self, value: Box<dyn Reflect, Global> ) -> Result<(), Box<dyn Reflect, Global>>

§

fn reflect_ref(&self) -> ReflectRef<'_>

§

fn reflect_mut(&mut self) -> ReflectMut<'_>

§

fn reflect_owned(self: Box<u128, Global>) -> ReflectOwned

§

fn reflect_hash(&self) -> Option<u64>

§

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

§

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

§

impl<K, V, S> Reflect for HashMap<K, V, S>where K: FromReflect + TypePath + Eq + Hash, V: FromReflect + TypePath, S: TypePath + BuildHasher + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<HashMap<K, V, S>, Global>) -> Box<dyn Any, Global>

§

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>, Global>) -> Box<dyn Reflect, Global>

§

fn as_reflect(&self) -> &(dyn Reflect + 'static)

§

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

§

fn apply(&mut self, value: &(dyn Reflect + 'static))

§

fn set( &mut self, value: Box<dyn Reflect, Global> ) -> Result<(), Box<dyn Reflect, Global>>

§

fn reflect_ref(&self) -> ReflectRef<'_>

§

fn reflect_mut(&mut self) -> ReflectMut<'_>

§

fn reflect_owned(self: Box<HashMap<K, V, S>, Global>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

§

impl Reflect for u64

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<u64, Global>) -> Box<dyn Any, Global>

§

fn as_any(&self) -> &(dyn Any + 'static)

§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

§

fn into_reflect(self: Box<u64, Global>) -> Box<dyn Reflect, Global>

§

fn as_reflect(&self) -> &(dyn Reflect + 'static)

§

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

fn apply(&mut self, value: &(dyn Reflect + 'static))

§

fn set( &mut self, value: Box<dyn Reflect, Global> ) -> Result<(), Box<dyn Reflect, Global>>

§

fn reflect_ref(&self) -> ReflectRef<'_>

§

fn reflect_mut(&mut self) -> ReflectMut<'_>

§

fn reflect_owned(self: Box<u64, Global>) -> ReflectOwned

§

fn reflect_hash(&self) -> Option<u64>

§

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

§

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

§

impl Reflect for i8

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<i8, Global>) -> Box<dyn Any, Global>

§

fn as_any(&self) -> &(dyn Any + 'static)

§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

§

fn into_reflect(self: Box<i8, Global>) -> Box<dyn Reflect, Global>

§

fn as_reflect(&self) -> &(dyn Reflect + 'static)

§

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

§

fn clone_value(&self) -> Box<dyn Reflect, Global>

§

fn apply(&mut self, value: &(dyn Reflect + 'static))

§

fn set( &mut self, value: Box<dyn Reflect, Global> ) -> Result<(), Box<dyn Reflect, Global>>

§

fn reflect_ref(&self) -> ReflectRef<'_>

§

fn reflect_mut(&mut self) -> ReflectMut<'_>

§

fn reflect_owned(self: Box<i8, Global>) -> ReflectOwned

§

fn reflect_hash(&self) -> Option<u64>

§

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

§

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Implementors§

§

impl Reflect for Keyframeswhere Vec<Quat, Global>: FromReflect + TypePath, Vec<Vec3, Global>: FromReflect + TypePath, Vec<f32, Global>: FromReflect + TypePath,

§

impl Reflect for RepeatAnimationwhere u32: FromReflect + TypePath,

§

impl Reflect for PlaybackMode

§

impl Reflect for Volumewhere VolumeLevel: FromReflect + TypePath,

§

impl Reflect for BloomCompositeMode

§

impl Reflect for ClearColorConfigwhere Color: FromReflect + TypePath,

§

impl Reflect for Camera3dDepthLoadOpwhere f32: FromReflect + TypePath,

§

impl Reflect for ScreenSpaceTransmissionQuality

§

impl Reflect for Sensitivity

§

impl Reflect for DebandDither

§

impl Reflect for Tonemapping

§

impl Reflect for ButtonState

§

impl Reflect for GamepadAxisTypewhere u8: FromReflect + TypePath,

§

impl Reflect for GamepadButtonTypewhere u8: FromReflect + TypePath,

§

impl Reflect for GamepadConnectionwhere GamepadInfo: FromReflect + TypePath,

§

impl Reflect for GamepadEventwhere GamepadConnectionEvent: FromReflect + TypePath, GamepadButtonChangedEvent: FromReflect + TypePath, GamepadAxisChangedEvent: FromReflect + TypePath,

§

impl Reflect for KeyCode

§

impl Reflect for MouseButtonwhere u16: FromReflect + TypePath,

§

impl Reflect for MouseScrollUnit

§

impl Reflect for ForceTouchwhere f64: FromReflect + TypePath, Option<f64>: FromReflect + TypePath,

§

impl Reflect for TouchPhase

§

impl Reflect for EulerRot

§

impl Reflect for AlphaModewhere f32: FromReflect + TypePath,

§

impl Reflect for ClusterConfigwhere UVec3: FromReflect + TypePath, ClusterZConfig: FromReflect + TypePath, bool: FromReflect + TypePath, u32: FromReflect + TypePath,

§

impl Reflect for ClusterFarZModewhere f32: FromReflect + TypePath,

§

impl Reflect for FogFalloffwhere f32: FromReflect + TypePath, Vec3: FromReflect + TypePath,

§

impl Reflect for OpaqueRendererMethod

§

impl Reflect for ParallaxMappingMethodwhere u32: FromReflect + TypePath,

§

impl Reflect for ScreenSpaceAmbientOcclusionQualityLevelwhere u32: FromReflect + TypePath,

§

impl Reflect for ShadowFilteringMethod

§

impl Reflect for NormalizedRenderTargetwhere NormalizedWindowRef: FromReflect + TypePath, Handle<Image>: FromReflect + TypePath, ManualTextureViewHandle: FromReflect + TypePath,

§

impl Reflect for Projectionwhere PerspectiveProjection: FromReflect + TypePath, OrthographicProjection: FromReflect + TypePath,

§

impl Reflect for RenderTargetwhere WindowRef: FromReflect + TypePath, Handle<Image>: FromReflect + TypePath, ManualTextureViewHandle: FromReflect + TypePath,

§

impl Reflect for ScalingModewhere f32: FromReflect + TypePath,

§

impl Reflect for Colorwhere f32: FromReflect + TypePath,

§

impl Reflect for Indiceswhere Vec<u16, Global>: FromReflect + TypePath, Vec<u32, Global>: FromReflect + TypePath,

§

impl Reflect for Msaa

§

impl Reflect for Visibility

§

impl Reflect for Anchorwhere Vec2: FromReflect + TypePath,

§

impl Reflect for BreakLineOn

§

impl Reflect for JustifyText

§

impl Reflect for TimerMode

§

impl Reflect for AlignContent

§

impl Reflect for AlignItems

§

impl Reflect for AlignSelf

§

impl Reflect for Direction

§

impl Reflect for Display

§

impl Reflect for FlexDirection

§

impl Reflect for FlexWrap

§

impl Reflect for FocusPolicy

§

impl Reflect for GridAutoFlow

§

impl Reflect for GridTrackRepetitionwhere u16: FromReflect + TypePath,

§

impl Reflect for Interaction

§

impl Reflect for JustifyContent

§

impl Reflect for JustifyItems

§

impl Reflect for JustifySelf

§

impl Reflect for MaxTrackSizingFunction

§

impl Reflect for MinTrackSizingFunction

§

impl Reflect for OverflowAxis

§

impl Reflect for PositionType

§

impl Reflect for Valwhere f32: FromReflect + TypePath,

§

impl Reflect for ZIndexwhere i32: FromReflect + TypePath,

§

impl Reflect for ApplicationLifetime

§

impl Reflect for CompositeAlphaMode

§

impl Reflect for CursorGrabMode

§

impl Reflect for CursorIcon

§

impl Reflect for FileDragAndDropwhere Entity: FromReflect + TypePath, PathBuf: FromReflect + TypePath,

§

impl Reflect for Imewhere Entity: FromReflect + TypePath, String: FromReflect + TypePath, Option<(usize, usize)>: FromReflect + TypePath,

§

impl Reflect for MonitorSelectionwhere usize: FromReflect + TypePath,

§

impl Reflect for PresentMode

§

impl Reflect for WindowLevel

§

impl Reflect for WindowMode

§

impl Reflect for WindowPositionwhere MonitorSelection: FromReflect + TypePath, IVec2: FromReflect + TypePath,

§

impl Reflect for WindowRefwhere Entity: FromReflect + TypePath,

§

impl Reflect for WindowTheme

§

impl Reflect for AnimationClipwhere Vec<Vec<VariableCurve, Global>, Global>: FromReflect + TypePath, HashMap<EntityPath, usize, BuildHasherDefault<AHasher>, Global>: FromReflect + TypePath, f32: FromReflect + TypePath,

§

impl Reflect for AnimationPlayerwhere bool: FromReflect + TypePath, PlayingAnimation: FromReflect + TypePath, Vec<AnimationTransition, Global>: Any + Send + Sync,

§

impl Reflect for EntityPathwhere Vec<Name, Global>: FromReflect + TypePath,

§

impl Reflect for VariableCurvewhere Vec<f32, Global>: FromReflect + TypePath, Keyframes: FromReflect + TypePath,

§

impl Reflect for AssetIndexwhere u32: FromReflect + TypePath,

§

impl Reflect for AssetPath<'static>

§

impl Reflect for GlobalVolumewhere VolumeLevel: FromReflect + TypePath,

§

impl Reflect for PlaybackSettingswhere PlaybackMode: FromReflect + TypePath, Volume: FromReflect + TypePath, f32: FromReflect + TypePath, bool: FromReflect + TypePath,

§

impl Reflect for SpatialListenerwhere Vec3: FromReflect + TypePath,

§

impl Reflect for SpatialScalewhere Vec3: FromReflect + TypePath,

§

impl Reflect for VolumeLevelwhere f32: FromReflect + TypePath,

§

impl Reflect for Namewhere u64: FromReflect + TypePath, Cow<'static, str>: FromReflect + TypePath,

§

impl Reflect for BloomPrefilterSettingswhere f32: FromReflect + TypePath,

§

impl Reflect for BloomSettingswhere f32: FromReflect + TypePath, BloomPrefilterSettings: FromReflect + TypePath, BloomCompositeMode: FromReflect + TypePath,

§

impl Reflect for ClearColorwhere Color: FromReflect + TypePath,

§

impl Reflect for ContrastAdaptiveSharpeningSettingswhere bool: FromReflect + TypePath, f32: FromReflect + TypePath,

§

impl Reflect for DenoiseCASwhere bool: FromReflect + TypePath,

§

impl Reflect for Camera2dwhere ClearColorConfig: FromReflect + TypePath,

§

impl Reflect for Camera3dwhere ClearColorConfig: FromReflect + TypePath, Camera3dDepthLoadOp: FromReflect + TypePath, Camera3dDepthTextureUsage: FromReflect + TypePath, usize: FromReflect + TypePath, ScreenSpaceTransmissionQuality: FromReflect + TypePath,

§

impl Reflect for Camera3dDepthTextureUsagewhere u32: FromReflect + TypePath,

§

impl Reflect for TemporalAntiAliasSettingswhere bool: FromReflect + TypePath,

§

impl Reflect for Fxaawhere bool: FromReflect + TypePath, Sensitivity: FromReflect + TypePath,

§

impl Reflect for DeferredPrepass

§

impl Reflect for DepthPrepass

§

impl Reflect for MotionVectorPrepass

§

impl Reflect for NormalPrepass

§

impl Reflect for Entity

§

impl Reflect for AabbGizmowhere Option<Color>: FromReflect + TypePath,

§

impl Reflect for AabbGizmoConfigwhere bool: FromReflect + TypePath, Option<Color>: FromReflect + TypePath,

§

impl Reflect for GizmoConfigwhere bool: FromReflect + TypePath, f32: FromReflect + TypePath, AabbGizmoConfig: FromReflect + TypePath, RenderLayers: FromReflect + TypePath,

§

impl Reflect for GltfExtraswhere String: FromReflect + TypePath,

§

impl Reflect for Childrenwhere SmallVec<[Entity; 8]>: FromReflect + TypePath,

§

impl Reflect for Parentwhere Entity: FromReflect + TypePath,

§

impl Reflect for AxisSettingswhere f32: FromReflect + TypePath,

§

impl Reflect for ButtonAxisSettingswhere f32: FromReflect + TypePath,

§

impl Reflect for ButtonSettingswhere f32: FromReflect + TypePath,

§

impl Reflect for Gamepadwhere usize: FromReflect + TypePath,

§

impl Reflect for GamepadAxiswhere Gamepad: FromReflect + TypePath, GamepadAxisType: FromReflect + TypePath,

§

impl Reflect for GamepadAxisChangedEventwhere Gamepad: FromReflect + TypePath, GamepadAxisType: FromReflect + TypePath, f32: FromReflect + TypePath,

§

impl Reflect for GamepadButtonwhere Gamepad: FromReflect + TypePath, GamepadButtonType: FromReflect + TypePath,

§

impl Reflect for GamepadButtonChangedEventwhere Gamepad: FromReflect + TypePath, GamepadButtonType: FromReflect + TypePath, f32: FromReflect + TypePath,

§

impl Reflect for GamepadButtonInputwhere GamepadButton: FromReflect + TypePath, ButtonState: FromReflect + TypePath,

§

impl Reflect for GamepadConnectionEventwhere Gamepad: FromReflect + TypePath, GamepadConnection: FromReflect + TypePath,

§

impl Reflect for GamepadInfowhere String: FromReflect + TypePath,

§

impl Reflect for GamepadSettingswhere ButtonSettings: FromReflect + TypePath, AxisSettings: FromReflect + TypePath, ButtonAxisSettings: FromReflect + TypePath, HashMap<GamepadButton, ButtonSettings, BuildHasherDefault<AHasher>, Global>: FromReflect + TypePath, HashMap<GamepadAxis, AxisSettings, BuildHasherDefault<AHasher>, Global>: FromReflect + TypePath, HashMap<GamepadButton, ButtonAxisSettings, BuildHasherDefault<AHasher>, Global>: FromReflect + TypePath,

§

impl Reflect for KeyboardInputwhere u32: FromReflect + TypePath, Option<KeyCode>: FromReflect + TypePath, ButtonState: FromReflect + TypePath, Entity: FromReflect + TypePath,

§

impl Reflect for ScanCodewhere u32: FromReflect + TypePath,

§

impl Reflect for MouseButtonInputwhere MouseButton: FromReflect + TypePath, ButtonState: FromReflect + TypePath, Entity: FromReflect + TypePath,

§

impl Reflect for MouseMotionwhere Vec2: FromReflect + TypePath,

§

impl Reflect for MouseWheelwhere MouseScrollUnit: FromReflect + TypePath, f32: FromReflect + TypePath, Entity: FromReflect + TypePath,

§

impl Reflect for TouchInputwhere TouchPhase: FromReflect + TypePath, Vec2: FromReflect + TypePath, Option<ForceTouch>: FromReflect + TypePath, u64: FromReflect + TypePath,

§

impl Reflect for TouchpadMagnifywhere f32: FromReflect + TypePath,

§

impl Reflect for TouchpadRotatewhere f32: FromReflect + TypePath,

§

impl Reflect for BVec2where bool: FromReflect + TypePath,

§

impl Reflect for BVec3where bool: FromReflect + TypePath,

§

impl Reflect for BVec4where bool: FromReflect + TypePath,

§

impl Reflect for Mat2where Vec2: FromReflect + TypePath,

§

impl Reflect for Mat3where Vec3: FromReflect + TypePath,

§

impl Reflect for Mat4where Vec4: FromReflect + TypePath,

§

impl Reflect for Quatwhere f32: FromReflect + TypePath,

§

impl Reflect for Vec2where f32: FromReflect + TypePath,

§

impl Reflect for Vec3where f32: FromReflect + TypePath,

§

impl Reflect for Vec4where f32: FromReflect + TypePath,

§

impl Reflect for IVec2where i32: FromReflect + TypePath,

§

impl Reflect for IVec3where i32: FromReflect + TypePath,

§

impl Reflect for IVec4where i32: FromReflect + TypePath,

§

impl Reflect for Affine2where Mat2: FromReflect + TypePath, Vec2: FromReflect + TypePath,

§

impl Reflect for Affine3Awhere Mat3A: FromReflect + TypePath, Vec3A: FromReflect + TypePath,

§

impl Reflect for BVec3A

§

impl Reflect for BVec4A

§

impl Reflect for DAffine2where DMat2: FromReflect + TypePath, DVec2: FromReflect + TypePath,

§

impl Reflect for DAffine3where DMat3: FromReflect + TypePath, DVec3: FromReflect + TypePath,

§

impl Reflect for DMat2where DVec2: FromReflect + TypePath,

§

impl Reflect for DMat3where DVec3: FromReflect + TypePath,

§

impl Reflect for DMat4where DVec4: FromReflect + TypePath,

§

impl Reflect for DQuatwhere f64: FromReflect + TypePath,

§

impl Reflect for DVec2where f64: FromReflect + TypePath,

§

impl Reflect for DVec3where f64: FromReflect + TypePath,

§

impl Reflect for DVec4where f64: FromReflect + TypePath,

§

impl Reflect for I64Vec2where i64: FromReflect + TypePath,

§

impl Reflect for I64Vec3where i64: FromReflect + TypePath,

§

impl Reflect for I64Vec4where i64: FromReflect + TypePath,

§

impl Reflect for IRectwhere IVec2: FromReflect + TypePath,

§

impl Reflect for Mat3Awhere Vec3A: FromReflect + TypePath,

§

impl Reflect for Rectwhere Vec2: FromReflect + TypePath,

§

impl Reflect for U64Vec2where u64: FromReflect + TypePath,

§

impl Reflect for U64Vec3where u64: FromReflect + TypePath,

§

impl Reflect for U64Vec4where u64: FromReflect + TypePath,

§

impl Reflect for URectwhere UVec2: FromReflect + TypePath,

§

impl Reflect for Vec3Awhere f32: FromReflect + TypePath,

§

impl Reflect for UVec2where u32: FromReflect + TypePath,

§

impl Reflect for UVec3where u32: FromReflect + TypePath,

§

impl Reflect for UVec4where u32: FromReflect + TypePath,

§

impl Reflect for AmbientLightwhere Color: FromReflect + TypePath, f32: FromReflect + TypePath,

§

impl Reflect for Cascadewhere Mat4: FromReflect + TypePath, f32: FromReflect + TypePath,

§

impl Reflect for CascadeShadowConfigwhere Vec<f32, Global>: FromReflect + TypePath, f32: FromReflect + TypePath,

§

impl Reflect for Cascadeswhere HashMap<Entity, Vec<Cascade, Global>, BuildHasherDefault<AHasher>, Global>: FromReflect + TypePath,

§

impl Reflect for CascadesVisibleEntitieswhere HashMap<Entity, Vec<VisibleEntities, Global>, BuildHasherDefault<AHasher>, Global>: Any + Send + Sync,

§

impl Reflect for ClusterZConfigwhere f32: FromReflect + TypePath, ClusterFarZMode: FromReflect + TypePath,

§

impl Reflect for CubemapVisibleEntitieswhere [VisibleEntities; 6]: Any + Send + Sync,

§

impl Reflect for DefaultOpaqueRendererMethodwhere OpaqueRendererMethod: FromReflect + TypePath,

§

impl Reflect for DirectionalLightwhere Color: FromReflect + TypePath, f32: FromReflect + TypePath, bool: FromReflect + TypePath,

§

impl Reflect for DirectionalLightShadowMapwhere usize: FromReflect + TypePath,

§

impl Reflect for EnvironmentMapLightwhere Handle<Image>: FromReflect + TypePath,

§

impl Reflect for FogSettingswhere Color: FromReflect + TypePath, f32: FromReflect + TypePath, FogFalloff: FromReflect + TypePath,

§

impl Reflect for NotShadowCaster

§

impl Reflect for NotShadowReceiver

§

impl Reflect for PointLightwhere Color: FromReflect + TypePath, f32: FromReflect + TypePath, bool: FromReflect + TypePath,

§

impl Reflect for PointLightShadowMapwhere usize: FromReflect + TypePath,

§

impl Reflect for ScreenSpaceAmbientOcclusionSettingswhere ScreenSpaceAmbientOcclusionQualityLevel: FromReflect + TypePath,

§

impl Reflect for SpotLightwhere Color: FromReflect + TypePath, f32: FromReflect + TypePath, bool: FromReflect + TypePath,

§

impl Reflect for StandardMaterialwhere Color: FromReflect + TypePath, Option<Handle<Image>>: FromReflect + TypePath, f32: FromReflect + TypePath, bool: FromReflect + TypePath, AlphaMode: FromReflect + TypePath, ParallaxMappingMethod: FromReflect + TypePath, OpaqueRendererMethod: FromReflect + TypePath, u8: FromReflect + TypePath, Option<Face>: Any + Send + Sync,

§

impl Reflect for TransmittedShadowReceiver

§

impl Reflect for NoWireframe

§

impl Reflect for Wireframe

§

impl Reflect for WireframeColorwhere Color: FromReflect + TypePath,

§

impl Reflect for WireframeConfigwhere bool: FromReflect + TypePath, Color: FromReflect + TypePath,

§

impl Reflect for Camerawhere Option<Viewport>: FromReflect + TypePath, isize: FromReflect + TypePath, bool: FromReflect + TypePath, ComputedCameraValues: Any + Send + Sync, RenderTarget: Any + Send + Sync, CameraOutputMode: Any + Send + Sync,

§

impl Reflect for CameraRenderGraphwhere Cow<'static, str>: FromReflect + TypePath,

§

impl Reflect for ManualTextureViewHandlewhere u32: FromReflect + TypePath,

§

impl Reflect for OrthographicProjectionwhere f32: FromReflect + TypePath, Vec2: FromReflect + TypePath, ScalingMode: FromReflect + TypePath, Rect: FromReflect + TypePath,

§

impl Reflect for PerspectiveProjectionwhere f32: FromReflect + TypePath,

§

impl Reflect for Viewportwhere UVec2: FromReflect + TypePath, Range<f32>: FromReflect + TypePath,

§

impl Reflect for GlobalsUniformwhere f32: FromReflect + TypePath, u32: FromReflect + TypePath,

§

impl Reflect for MeshMorphWeightswhere Vec<f32, Global>: FromReflect + TypePath,

§

impl Reflect for MorphWeightswhere Vec<f32, Global>: FromReflect + TypePath, Option<Handle<Mesh>>: FromReflect + TypePath,

§

impl Reflect for SkinnedMeshwhere Handle<SkinnedMeshInverseBindposes>: FromReflect + TypePath, Vec<Entity, Global>: FromReflect + TypePath,

§

impl Reflect for Meshwhere Option<Indices>: FromReflect + TypePath, Option<Handle<Image>>: FromReflect + TypePath, Option<Vec<String, Global>>: FromReflect + TypePath, PrimitiveTopology: Any + Send + Sync, BTreeMap<MeshVertexAttributeId, MeshAttributeData, Global>: Any + Send + Sync,

§

impl Reflect for Aabbwhere Vec3A: FromReflect + TypePath,

§

impl Reflect for CascadesFrustawhere HashMap<Entity, Vec<Frustum, Global>, BuildHasherDefault<AHasher>, Global>: Any + Send + Sync,

§

impl Reflect for CubemapFrustawhere [Frustum; 6]: Any + Send + Sync,

§

impl Reflect for Frustumwhere [HalfSpace; 6]: Any + Send + Sync,

§

impl Reflect for Image

§

impl Reflect for ColorGradingwhere f32: FromReflect + TypePath,

§

impl Reflect for InheritedVisibilitywhere bool: FromReflect + TypePath,

§

impl Reflect for NoFrustumCulling

§

impl Reflect for RenderLayerswhere u32: FromReflect + TypePath,

§

impl Reflect for ViewVisibilitywhere bool: FromReflect + TypePath,

§

impl Reflect for VisibleEntitieswhere Vec<Entity, Global>: Any + Send + Sync,

§

impl Reflect for ColorMaterialwhere Color: FromReflect + TypePath, Option<Handle<Image>>: FromReflect + TypePath,

§

impl Reflect for Mesh2dHandlewhere Handle<Mesh>: FromReflect + TypePath,

§

impl Reflect for Spritewhere Color: FromReflect + TypePath, bool: FromReflect + TypePath, Option<Vec2>: FromReflect + TypePath, Option<Rect>: FromReflect + TypePath, Anchor: FromReflect + TypePath,

§

impl Reflect for TextureAtlaswhere Handle<Image>: FromReflect + TypePath, Vec2: FromReflect + TypePath, Vec<Rect, Global>: FromReflect + TypePath, Option<HashMap<AssetId<Image>, usize, BuildHasherDefault<AHasher>, Global>>: FromReflect + TypePath,

§

impl Reflect for TextureAtlasSpritewhere Color: FromReflect + TypePath, usize: FromReflect + TypePath, bool: FromReflect + TypePath, Option<Vec2>: FromReflect + TypePath, Anchor: FromReflect + TypePath,

§

impl Reflect for GlyphAtlasInfowhere Handle<TextureAtlas>: FromReflect + TypePath, usize: FromReflect + TypePath,

§

impl Reflect for PositionedGlyphwhere Vec2: FromReflect + TypePath, GlyphAtlasInfo: FromReflect + TypePath, usize: FromReflect + TypePath,

§

impl Reflect for Text2dBoundswhere Vec2: FromReflect + TypePath,

§

impl Reflect for Textwhere Vec<TextSection, Global>: FromReflect + TypePath, JustifyText: FromReflect + TypePath, BreakLineOn: FromReflect + TypePath,

§

impl Reflect for TextLayoutInfowhere Vec<PositionedGlyph, Global>: FromReflect + TypePath, Vec2: FromReflect + TypePath,

§

impl Reflect for TextSectionwhere String: FromReflect + TypePath, TextStyle: FromReflect + TypePath,

§

impl Reflect for TextStylewhere Handle<Font>: FromReflect + TypePath, f32: FromReflect + TypePath, Color: FromReflect + TypePath,

§

impl Reflect for Fixedwhere Duration: FromReflect + TypePath,

§

impl Reflect for Realwhere Instant: FromReflect + TypePath, Option<Instant>: FromReflect + TypePath,

§

impl Reflect for Stopwatchwhere Duration: FromReflect + TypePath, bool: FromReflect + TypePath,

§

impl Reflect for Timerwhere Stopwatch: FromReflect + TypePath, Duration: FromReflect + TypePath, TimerMode: FromReflect + TypePath, bool: FromReflect + TypePath, u32: FromReflect + TypePath,

§

impl Reflect for Virtualwhere Duration: FromReflect + TypePath, bool: FromReflect + TypePath, f64: FromReflect + TypePath,

§

impl Reflect for GlobalTransformwhere Affine3A: FromReflect + TypePath,

§

impl Reflect for Transformwhere Vec3: FromReflect + TypePath, Quat: FromReflect + TypePath,

§

impl Reflect for UiCameraConfigwhere bool: FromReflect + TypePath,

§

impl Reflect for BackgroundColorwhere Color: FromReflect + TypePath,

§

impl Reflect for BorderColorwhere Color: FromReflect + TypePath,

§

impl Reflect for CalculatedClipwhere Rect: FromReflect + TypePath,

§

impl Reflect for ContentSizewhere Option<MeasureFunc>: Any + Send + Sync,

§

impl Reflect for GridPlacementwhere Option<NonZeroI16>: FromReflect + TypePath, Option<NonZeroU16>: FromReflect + TypePath,

§

impl Reflect for GridTrackwhere MinTrackSizingFunction: FromReflect + TypePath, MaxTrackSizingFunction: FromReflect + TypePath,

§

impl Reflect for Nodewhere u32: FromReflect + TypePath, Vec2: FromReflect + TypePath, f32: FromReflect + TypePath,

§

impl Reflect for Outlinewhere Val: FromReflect + TypePath, Color: FromReflect + TypePath,

§

impl Reflect for Overflowwhere OverflowAxis: FromReflect + TypePath,

§

impl Reflect for RelativeCursorPositionwhere Rect: FromReflect + TypePath, Option<Vec2>: FromReflect + TypePath,

§

impl Reflect for RepeatedGridTrackwhere GridTrackRepetition: FromReflect + TypePath, SmallVec<[GridTrack; 1]>: FromReflect + TypePath,

§

impl Reflect for Stylewhere Display: FromReflect + TypePath, PositionType: FromReflect + TypePath, Overflow: FromReflect + TypePath, Direction: FromReflect + TypePath, Val: FromReflect + TypePath, Option<f32>: FromReflect + TypePath, AlignItems: FromReflect + TypePath, JustifyItems: FromReflect + TypePath, AlignSelf: FromReflect + TypePath, JustifySelf: FromReflect + TypePath, AlignContent: FromReflect + TypePath, JustifyContent: FromReflect + TypePath, UiRect: FromReflect + TypePath, FlexDirection: FromReflect + TypePath, FlexWrap: FromReflect + TypePath, f32: FromReflect + TypePath, GridAutoFlow: FromReflect + TypePath, Vec<RepeatedGridTrack, Global>: FromReflect + TypePath, Vec<GridTrack, Global>: FromReflect + TypePath, GridPlacement: FromReflect + TypePath,

§

impl Reflect for UiImagewhere Handle<Image>: FromReflect + TypePath, bool: FromReflect + TypePath,

§

impl Reflect for UiRectwhere Val: FromReflect + TypePath,

§

impl Reflect for UiScalewhere f64: FromReflect + TypePath,

§

impl Reflect for UiTextureAtlasImagewhere usize: FromReflect + TypePath, bool: FromReflect + TypePath,

§

impl Reflect for Button

§

impl Reflect for Label

§

impl Reflect for TextFlagswhere bool: FromReflect + TypePath,

§

impl Reflect for UiImageSizewhere Vec2: FromReflect + TypePath,

§

impl Reflect for Duration

§

impl Reflect for Uuid

§

impl Reflect for Cursorwhere CursorIcon: FromReflect + TypePath, bool: FromReflect + TypePath, CursorGrabMode: FromReflect + TypePath,

§

impl Reflect for CursorEnteredwhere Entity: FromReflect + TypePath,

§

impl Reflect for CursorLeftwhere Entity: FromReflect + TypePath,

§

impl Reflect for CursorMovedwhere Entity: FromReflect + TypePath, Vec2: FromReflect + TypePath,

§

impl Reflect for EnabledButtonswhere bool: FromReflect + TypePath,

§

impl Reflect for InternalWindowStatewhere Option<bool>: FromReflect + TypePath, Option<DVec2>: FromReflect + TypePath,

§

impl Reflect for NormalizedWindowRefwhere Entity: FromReflect + TypePath,

§

impl Reflect for PrimaryWindow

§

impl Reflect for ReceivedCharacterwhere Entity: FromReflect + TypePath, char: FromReflect + TypePath,

§

impl Reflect for RequestRedraw

§

impl Reflect for Windowwhere Cursor: FromReflect + TypePath, PresentMode: FromReflect + TypePath, WindowMode: FromReflect + TypePath, WindowPosition: FromReflect + TypePath, WindowResolution: FromReflect + TypePath, String: FromReflect + TypePath, CompositeAlphaMode: FromReflect + TypePath, WindowResizeConstraints: FromReflect + TypePath, bool: FromReflect + TypePath, EnabledButtons: FromReflect + TypePath, WindowLevel: FromReflect + TypePath, Option<String>: FromReflect + TypePath, InternalWindowState: FromReflect + TypePath, Vec2: FromReflect + TypePath, Option<WindowTheme>: FromReflect + TypePath,

§

impl Reflect for WindowBackendScaleFactorChangedwhere Entity: FromReflect + TypePath, f64: FromReflect + TypePath,

§

impl Reflect for WindowCloseRequestedwhere Entity: FromReflect + TypePath,

§

impl Reflect for WindowClosedwhere Entity: FromReflect + TypePath,

§

impl Reflect for WindowCreatedwhere Entity: FromReflect + TypePath,

§

impl Reflect for WindowDestroyedwhere Entity: FromReflect + TypePath,

§

impl Reflect for WindowFocusedwhere Entity: FromReflect + TypePath, bool: FromReflect + TypePath,

§

impl Reflect for WindowMovedwhere Entity: FromReflect + TypePath, IVec2: FromReflect + TypePath,

§

impl Reflect for WindowOccludedwhere Entity: FromReflect + TypePath, bool: FromReflect + TypePath,

§

impl Reflect for WindowResizeConstraintswhere f32: FromReflect + TypePath,

§

impl Reflect for WindowResizedwhere Entity: FromReflect + TypePath, f32: FromReflect + TypePath,

§

impl Reflect for WindowResolutionwhere u32: FromReflect + TypePath, Option<f64>: FromReflect + TypePath, f64: FromReflect + TypePath,

§

impl Reflect for WindowScaleFactorChangedwhere Entity: FromReflect + TypePath, f64: FromReflect + TypePath,

§

impl Reflect for WindowThemeChangedwhere Entity: FromReflect + TypePath, WindowTheme: FromReflect + TypePath,

§

impl Reflect for DynamicArray

§

impl Reflect for DynamicEnum

§

impl Reflect for DynamicList

§

impl Reflect for DynamicMap

§

impl Reflect for DynamicStruct

§

impl Reflect for DynamicTuple

§

impl Reflect for DynamicTupleStruct

§

impl<A> Reflect for AssetId<A>where A: Asset + TypePath, AssetIndex: FromReflect + TypePath, Uuid: FromReflect + TypePath, PhantomData<fn() -> A>: Any + Send + Sync,

§

impl<A> Reflect for Handle<A>where A: Asset + TypePath, Arc<StrongHandle, Global>: FromReflect + TypePath, AssetId<A>: FromReflect + TypePath,

§

impl<B, E> Reflect for ExtendedMaterial<B, E>where B: Material + FromReflect + TypePath, E: MaterialExtension + FromReflect + TypePath,

§

impl<K, V, S> Reflect for bevy::utils::hashbrown::HashMap<K, V, S, Global>where K: FromReflect + TypePath + Eq + Hash, V: FromReflect + TypePath, S: TypePath + BuildHasher + Send + Sync,

§

impl<S> Reflect for NextState<S>where S: States + TypePath, Option<S>: FromReflect + TypePath,

§

impl<S> Reflect for State<S>where S: States + FromReflect + TypePath,

§

impl<T> Reflect for ButtonInput<T>where T: Copy + Eq + Hash + Send + Sync + 'static + TypePath, HashSet<T, BuildHasherDefault<AHasher>, Global>: FromReflect + TypePath,

§

impl<T> Reflect for Time<T>where T: Default + FromReflect + TypePath, Duration: FromReflect + TypePath, f32: FromReflect + TypePath, f64: FromReflect + TypePath,

§

impl<T> Reflect for HashSet<T, BuildHasherDefault<AHasher>, Global>where T: Hash + Eq + Clone + Send + Sync + TypePath,