Enum TypeInfo 

pub enum TypeInfo {
    Struct(StructInfo),
    TupleStruct(TupleStructInfo),
    Tuple(TupleInfo),
    List(ListInfo),
    Array(ArrayInfo),
    Map(MapInfo),
    Set(SetInfo),
    Enum(EnumInfo),
    Opaque(OpaqueInfo),
}

Compile-time type information for various reflected types.

Generally, for any given type, this value can be retrieved in one of four ways:

1. Typed::type_info
2. DynamicTyped::reflect_type_info
3. PartialReflect::get_represented_type_info
4. TypeRegistry::get_type_info

Each returns a static reference to TypeInfo, but they all have their own use cases. For example, if you know the type at compile time, Typed::type_info is probably the simplest. If you have a dyn Reflect you can use DynamicTyped::reflect_type_info. If all you have is a dyn PartialReflect, you’ll probably want PartialReflect::get_represented_type_info. Lastly, if all you have is a TypeId or type path, you will need to go through TypeRegistry::get_type_info.

You may also opt to use TypeRegistry::get_type_info in place of the other methods simply because it can be more performant. This is because those other methods may require attaining a lock on the static TypeInfo, while the registry simply checks a map.

Variants

Struct(StructInfo)

Type information for a struct-like type.

TupleStruct(TupleStructInfo)

Type information for a tuple-struct-like type.

Tuple(TupleInfo)

Type information for a tuple-like type.

List(ListInfo)

Type information for a list-like type.

Array(ArrayInfo)

Type information for an array-like type.

Map(MapInfo)

Type information for a map-like type.

Set(SetInfo)

Type information for a set-like type.

Enum(EnumInfo)

Type information for an enum-like type.

Opaque(OpaqueInfo)

Type information for an opaque type - see the OpaqueInfo docs for a discussion of opaque types.

Implementations

impl TypeInfo

pub fn ty(&self) -> &Type

The underlying Rust type.

pub fn type_id(&self) -> TypeId

The TypeId of the underlying type.

Examples found in repository

examples/reflection/mutation_by_reflection.rs (line 212)

fn modify_selected_component(world: &mut World) {
    // We're using keyboard input to trigger modifications for simplicity.
    let button_input = world.resource::<ButtonInput<KeyCode>>();
    let direction_of_modification = if button_input.pressed(KeyCode::ArrowUp) {
        1.0
    } else if button_input.pressed(KeyCode::ArrowDown) {
        -1.0
    } else {
        return; // No modification requested
    };

    let selected = world.resource::<SelectedComponent>().clone();

    let mut sprite_query = world.query_filtered::<Entity, With<Sprite>>();

    // This entity should generally be gathered via UI selection in a real application
    let entity = sprite_query.iter(world).next().unwrap();

    // We could cheat and use `TypeId::of::<T>()` to get the type ID of a known type,
    // but real applications identify types by name (from a UI dropdown, text entry or a script).
    let type_name = match selected {
        // Note that Bevy's native types are registered under their full subcrate paths:
        // `bevy_transform`, not `bevy::transform`, `bevy::prelude`, or `bevy_transform::prelude`.
        // You can use `<T as TypePath>::type_path()` to look this up.
        SelectedComponent::Transform => "bevy_transform::components::transform::Transform",
        SelectedComponent::Sprite => "bevy_sprite::sprite::Sprite",
    };

    // Then, we need to use a type registry to resolve the type name to a `TypeId`.
    // Types are (for the most part) registered automatically by Bevy,
    // but you can also register your own types using `App::register_type`.
    // Generic types always need to be registered manually;
    // if a type is not showing up in your tool, check if that's the problem.
    // You can check which types are registered by calling `TypeRegistry::iter()`,
    // and then use the `Debug` impl for `TypeRegistration` objects to see their names and paths.
    let app_registry = world.resource::<AppTypeRegistry>().clone();
    let type_id = app_registry
        .read()
        .get_with_type_path(type_name)
        .expect("Type was not registered, or its full path was ambiguous")
        .type_id();

    let mut reflected_component: Mut<dyn Reflect> = world.get_reflect_mut(entity, type_id).unwrap();

    match selected {
        // Downcasting is the easy path:
        // if you happen to know the type, you can downcast and modify directly.
        // The problem is that each of these paths would need to be hard-coded (or rely on extensive code-gen),
        // largely defeating the purpose of using reflection in the first place.
        SelectedComponent::Sprite => {
            // Make sure that the type matches the component type you requested to modify.
            // In a real project, you would want to handle this gracefully.
            // Downcasting converts the value *directly* into a specified concrete type,
            // allowing you to escape back into faster, strongly-typed code.
            let downcast_sprite: &mut Sprite =
                reflected_component.downcast_mut::<Sprite>().unwrap();
            // Be careful not to modify a copy of the color — use `&mut`!
            let color = &mut downcast_sprite.color;

            let new_alpha = (color.alpha() + 0.01 * direction_of_modification).clamp(0.0, 1.0);
            color.set_alpha(new_alpha);
        }
        // This arm demonstrates the more realistic, generic pattern:
        // walking the reflected type info to find fields to modify.
        // The benefit is that we can use these patterns
        // to operate over *any* data based on our knowledge of its shape (recorded using reflection),
        // without needing to know the concrete type at compile time.
        SelectedComponent::Transform => {
            let reflect_mut: ReflectMut<'_> = reflected_component.reflect_mut();
            // In the fully generic case, we would need to match on the `ReflectMut` variants
            // and handle each of the arms exhaustively.
            // `struct_mut` is of type `&mut dyn Struct`, one of a number
            // of traits that encodes the logic of Rust's type system into a runtime representation.
            let ReflectMut::Struct(struct_mut) = reflect_mut else {
                error!("Expected the Transform component type to be a struct");
                return;
            };

            // Get the `translation` field as a `&mut dyn PartialReflect`,
            // which is a type-erased representation of a value that can be modified.
            let translation_field = struct_mut.field_mut("translation").unwrap();

            // Now, we can repeat the process to get the `y` field of the `translation` Vec3
            // In a real application, this would probably be done via a recursive function!
            let ReflectMut::Struct(translation_struct) = translation_field.reflect_mut() else {
                error!("Expected the translation field to be a struct");
                return;
            };

            // We could downcast to an f32 again here, but that would be cheating!
            // How do you generalize this sort of operation, if, for example,
            // you wanted to build a generic inspector that could modify any numeric field of any component type?
            // The solution lies in the way that Bevy can reflect *traits* as well as types,
            // allowing type owners to define and register additional behavior for their types.
            // This data is registered automatically at compile time using an inventory-like solution,
            // and operates on a per-type x per-trait basis,
            // just like ordinary type reflection.
            //
            // We want to increase or decrease the value here,
            // so we need the `AddAssign` trait
            // which are already implemented for f32.
            //
            // But `AddAssign` is not a supertrait of `PartialReflect`!
            // We don't have access to its methods! How could that possibly work?
            //
            // The solution is again to register the compile time information that we want to use at runtime;
            // storing function pointers to the trait methods in the type registry.
            // In order to make this work, we need shadow "reflect" versions of the traits we want to use at runtime.
            // Bevy provides a few of these out of the box, including `ReflectAddAssign` and `ReflectSubAssign`.
            // That's what the `#[reflect(Add)]` attributes that you see scattered about in Bevy's source code are doing:
            // generating implementations of the reflect versions of the traits, so they can later be registered and used at runtime.
            //
            // For more information, see the `type_data` example.
            let y_field: &mut dyn PartialReflect = translation_struct.field_mut("y").unwrap();
            let field_type_id = y_field
                .get_represented_type_info()
                .expect("Found a dynamic type unexpectedly")
                .type_id();

            let add_assign_trait_data = app_registry
                .read()
                .get_type_data::<ReflectAddAssign>(field_type_id)
                .expect("f32 failed to register ReflectAddAssign")
                .clone();

            // We need to operate on the value as a concrete type,
            // so we need to convert it into the more powerful &dyn Reflect type.
            let y_field: &mut dyn Reflect = y_field.try_as_reflect_mut().expect(
                "Found a dynamic type unexpectedly, but we need a concrete type to modify it",
            );

            // We're still cheating a bit here!
            // By doing this we just *assume* that there's an f32 value when trying to determine what to add to the field.
            // We *could* try all of the common numeric types, but that would be slow and non-extensible.
            //
            // In a real workflow, you would want a dedicated trait with additional methods that exposes
            // something like dedicated `increment` and `decrement` methods, which handle the type-specific logic of how to modify the value.
            // Remember to register that trait, and create your own analog of `ReflectAddAssign` for it!
            //
            // We don't do that here to avoid making this example *even more* complicated.
            const MAGNITUDE_OF_MODIFICATION: f32 = 10.;
            let delta = direction_of_modification * MAGNITUDE_OF_MODIFICATION;
            let boxed_delta: Box<dyn PartialReflect> = Box::new(delta);
            add_assign_trait_data
                .add_assign(y_field, boxed_delta)
                .expect("We cheated and know the types match, so this should always succeed.");
        }
    }
}

pub fn type_path_table(&self) -> &TypePathTable

A representation of the type path of the underlying type.

Provides dynamic access to all methods on TypePath.

pub fn type_path(&self) -> &'static str

The stable, full type path of the underlying type.

Use type_path_table if you need access to the other methods on TypePath.

Examples found in repository

examples/reflection/generic_reflection.rs (line 28)

fn setup(type_registry: Res<AppTypeRegistry>) {
    let type_registry = type_registry.read();

    let registration = type_registry.get(TypeId::of::<MyType<u32>>()).unwrap();
    info!(
        "Registration for {} exists",
        registration.type_info().type_path(),
    );

    // MyType<String> was not manually registered, so it does not exist
    assert!(type_registry.get(TypeId::of::<MyType<String>>()).is_none());
}

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

where T: Any,

Check if the given type matches this one.

This only compares the TypeId of the types and does not verify they share the same TypePath (though it implies they do).

pub fn docs(&self) -> Option<&str>

Available on crate feature reflect_documentation only.

The docstring of the underlying type, if any.

pub fn kind(&self) -> ReflectKind

Returns the kind of this TypeInfo.

pub fn generics(&self) -> &Generics

Gets the generic parameters for this type.

impl TypeInfo

Conversion convenience methods for TypeInfo.

pub fn as_struct(&self) -> Result<&StructInfo, TypeInfoError>

Attempts a cast to StructInfo.

Returns an error if self is not TypeInfo::Struct.

pub fn as_tuple_struct(&self) -> Result<&TupleStructInfo, TypeInfoError>

Attempts a cast to TupleStructInfo.

Returns an error if self is not TypeInfo::TupleStruct.

pub fn as_tuple(&self) -> Result<&TupleInfo, TypeInfoError>

Attempts a cast to TupleInfo.

Returns an error if self is not TypeInfo::Tuple.

pub fn as_list(&self) -> Result<&ListInfo, TypeInfoError>

Attempts a cast to ListInfo.

Returns an error if self is not TypeInfo::List.

pub fn as_array(&self) -> Result<&ArrayInfo, TypeInfoError>

Attempts a cast to ArrayInfo.

Returns an error if self is not TypeInfo::Array.

pub fn as_map(&self) -> Result<&MapInfo, TypeInfoError>

Attempts a cast to MapInfo.

Returns an error if self is not TypeInfo::Map.

pub fn as_set(&self) -> Result<&SetInfo, TypeInfoError>

Attempts a cast to SetInfo.

Returns an error if self is not TypeInfo::Set.

pub fn as_enum(&self) -> Result<&EnumInfo, TypeInfoError>

Attempts a cast to EnumInfo.

Returns an error if self is not TypeInfo::Enum.

pub fn as_opaque(&self) -> Result<&OpaqueInfo, TypeInfoError>

Attempts a cast to OpaqueInfo.

Returns an error if self is not TypeInfo::Opaque.

Trait Implementations

impl Clone for TypeInfo

fn clone(&self) -> TypeInfo

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TypeInfo

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

Formats the value using the given formatter.

impl TypedProperty for TypeInfo

type Stored = TypeInfo

The type of the value stored in GenericTypeCell.