Trait bevy::reflect::FromReflect

pub trait FromReflect: Reflect {
    fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<Self>;
}

Required methods

fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<Self>

Creates a clone of a reflected value, converting it to a concrete type if it was a dynamic types (e.g. DynamicStruct)

Implementations on Foreign Types

impl FromReflect for String

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<String>

impl FromReflect for i64

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<i64>

impl FromReflect for u128

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<u128>

impl FromReflect for i16

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<i16>

impl FromReflect for i32

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<i32>

impl FromReflect for Cow<'static, str>

pub fn from_reflect(
    reflect: &(dyn Reflect + 'static)
) -> Option<Cow<'static, str>>

impl<A, B> FromReflect for (A, B) where
    A: FromReflect,
    B: FromReflect, 

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<(A, B)>

impl<T> FromReflect for SmallVec<T> where
    T: 'static + Array + Send + Sync,
    <T as Array>::Item: FromReflect,
    <T as Array>::Item: Clone, 

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<SmallVec<T>>

impl FromReflect for i128

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<i128>

impl FromReflect for bool

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<bool>

impl FromReflect for f64

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<f64>

impl<T> FromReflect for HashSet<T, RandomState> where
    T: 'static + Serialize + Hash + Eq + Clone + for<'de> Deserialize<'de> + Send + Sync, 

pub fn from_reflect(
    reflect: &(dyn Reflect + 'static)
) -> Option<HashSet<T, RandomState>>

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

pub fn from_reflect(
    reflect: &(dyn Reflect + 'static)
) -> Option<(A, B, C, D, E, F, G, H, I)>

impl FromReflect for isize

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<isize>

impl FromReflect for usize

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<usize>

impl<A> FromReflect for (A,) where
    A: FromReflect, 

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<(A,)>

impl<T> FromReflect for Vec<T, Global> where
    T: FromReflect, 

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<Vec<T, Global>>

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

pub fn from_reflect(
    reflect: &(dyn Reflect + 'static)
) -> Option<(A, B, C, D, E, F, G, H)>

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

pub fn from_reflect(
    reflect: &(dyn Reflect + 'static)
) -> Option<(A, B, C, D, E, F, G, H, I, J, K)>

impl FromReflect for u8

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<u8>

impl<T> FromReflect for Option<T> where
    T: 'static + Serialize + Clone + for<'de> Deserialize<'de> + Reflect, 

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<Option<T>>

impl<A, B, C> FromReflect for (A, B, C) where
    A: FromReflect,
    B: FromReflect,
    C: FromReflect, 

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<(A, B, C)>

impl FromReflect for u64

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<u64>

impl FromReflect for u32

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<u32>

impl FromReflect for ()

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<()>

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

pub fn from_reflect(
    reflect: &(dyn Reflect + 'static)
) -> Option<(A, B, C, D, E, F, G, H, I, J)>

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

pub fn from_reflect(
    reflect: &(dyn Reflect + 'static)
) -> Option<(A, B, C, D, E, F, G)>

impl FromReflect for i8

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<i8>

impl<T> FromReflect for Range<T> where
    T: 'static + Serialize + Clone + for<'de> Deserialize<'de> + Send + Sync, 

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<Range<T>>

impl<K, V> FromReflect for HashMap<K, V, RandomState> where
    K: FromReflect + Eq + Hash,
    V: FromReflect, 

pub fn from_reflect(
    reflect: &(dyn Reflect + 'static)
) -> Option<HashMap<K, V, RandomState>>

impl<A, B, C, D, E, F> FromReflect for (A, B, C, D, E, F) where
    A: FromReflect,
    B: FromReflect,
    C: FromReflect,
    D: FromReflect,
    E: FromReflect,
    F: FromReflect, 

pub fn from_reflect(
    reflect: &(dyn Reflect + 'static)
) -> Option<(A, B, C, D, E, F)>

impl FromReflect for f32

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<f32>

impl<A, B, C, D> FromReflect for (A, B, C, D) where
    A: FromReflect,
    B: FromReflect,
    C: FromReflect,
    D: FromReflect, 

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<(A, B, C, D)>

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

pub fn from_reflect(
    reflect: &(dyn Reflect + 'static)
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L)>

impl<A, B, C, D, E> FromReflect for (A, B, C, D, E) where
    A: FromReflect,
    B: FromReflect,
    C: FromReflect,
    D: FromReflect,
    E: FromReflect, 

pub fn from_reflect(
    reflect: &(dyn Reflect + 'static)
) -> Option<(A, B, C, D, E)>

impl FromReflect for u16

pub fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<u16>

Implementors

impl FromReflect for HandleId

impl FromReflect for Color

impl FromReflect for Entity

impl FromReflect for Mat4

impl FromReflect for Vec3

impl FromReflect for IVec2

impl FromReflect for IVec3

impl FromReflect for IVec4

impl FromReflect for Mat3

impl FromReflect for Quat

impl FromReflect for UVec2

impl FromReflect for UVec3

impl FromReflect for UVec4

impl FromReflect for Vec2

impl FromReflect for Vec4

impl FromReflect for TextSection where
    String: FromReflect,
    TextStyle: FromReflect, 

impl FromReflect for TextStyle where
    Handle<Font>: FromReflect,
    f32: FromReflect,
    Color: FromReflect, 

impl FromReflect for Duration

impl<T> FromReflect for Handle<T> where
    T: Asset,
    HandleId: FromReflect,