mirror of
https://github.com/bevyengine/bevy
synced 2024-11-22 12:43:34 +00:00
11b41206eb
This updates the `pipelined-rendering` branch to use the latest `bevy_ecs` from `main`. This accomplishes a couple of goals: 1. prepares for upcoming `custom-shaders` branch changes, which were what drove many of the recent bevy_ecs changes on `main` 2. prepares for the soon-to-happen merge of `pipelined-rendering` into `main`. By including bevy_ecs changes now, we make that merge simpler / easier to review. I split this up into 3 commits: 1. **add upstream bevy_ecs**: please don't bother reviewing this content. it has already received thorough review on `main` and is a literal copy/paste of the relevant folders (the old folders were deleted so the directories are literally exactly the same as `main`). 2. **support manual buffer application in stages**: this is used to enable the Extract step. we've already reviewed this once on the `pipelined-rendering` branch, but its worth looking at one more time in the new context of (1). 3. **support manual archetype updates in QueryState**: same situation as (2).
60 lines
2.1 KiB
Rust
60 lines
2.1 KiB
Rust
use bevy::{prelude::*, reflect::TypeRegistry};
|
|
|
|
fn main() {
|
|
App::new()
|
|
.add_plugins(DefaultPlugins)
|
|
.add_startup_system(setup)
|
|
.register_type::<MyType>()
|
|
.run();
|
|
}
|
|
|
|
#[derive(Reflect)]
|
|
#[reflect(DoThing)]
|
|
struct MyType {
|
|
value: String,
|
|
}
|
|
|
|
impl DoThing for MyType {
|
|
fn do_thing(&self) -> String {
|
|
format!("{} World!", self.value)
|
|
}
|
|
}
|
|
|
|
#[reflect_trait]
|
|
pub trait DoThing {
|
|
fn do_thing(&self) -> String;
|
|
}
|
|
|
|
fn setup(type_registry: Res<TypeRegistry>) {
|
|
// 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
|
|
}
|