1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

//! Allows reflection with trait objects.

use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .register_type::<MyType>()
        .add_systems(Startup, setup)
        .run();
}

#[derive(Reflect)]
#[reflect(DoThing)]
struct MyType {
    value: String,
}

impl DoThing for MyType {
    fn do_thing(&self) -> String {
        format!("{} World!", self.value)
    }
}

#[reflect_trait]
trait DoThing {
    fn do_thing(&self) -> String;
}

fn setup(type_registry: Res<AppTypeRegistry>) {
    // First, lets box our type as a Box<dyn Reflect>
    let reflect_value: Box<dyn Reflect> = Box::new(MyType {
        value: "Hello".to_string(),
    });

    // This means we no longer have direct access to MyType or its methods. We can only call Reflect
    // methods on reflect_value. What if we want to call `do_thing` on our type? We could
    // downcast using reflect_value.downcast_ref::<MyType>(), but what if we don't know the type
    // at compile time?

    // Normally in rust we would be out of luck at this point. Lets use our new reflection powers to
    // do something cool!
    let type_registry = type_registry.read();

    // The #[reflect] attribute we put on our DoThing trait generated a new `ReflectDoThing` struct,
    // which implements TypeData. This was added to MyType's TypeRegistration.
    let reflect_do_thing = type_registry
        .get_type_data::<ReflectDoThing>(reflect_value.type_id())
        .unwrap();

    // We can use this generated type to convert our `&dyn Reflect` reference to a `&dyn DoThing`
    // reference
    let my_trait: &dyn DoThing = reflect_do_thing.get(&*reflect_value).unwrap();

    // Which means we can now call do_thing(). Magic!
    info!("{}", my_trait.do_thing());

    // This works because the #[reflect(MyTrait)] we put on MyType informed the Reflect derive to
    // insert a new instance of ReflectDoThing into MyType's registration. The instance knows
    // how to cast &dyn Reflect to &dyn MyType, because it knows that &dyn Reflect should first
    // be downcasted to &MyType, which can then be safely casted to &dyn MyType
}