add #[reflect(Default)] to create default value for reflected types (bevyengine#3733)

### Problem
It currently isn't possible to construct the default value of a reflected type. Because of that, it isn't possible to use `add_component` of `ReflectComponent` to add a new component to an entity because you can't know what the initial value should be.

### Solution

1. add `ReflectDefault` type
```rust
#[derive(Clone)]
pub struct ReflectDefault {
    default: fn() -> Box<dyn Reflect>,
}

impl ReflectDefault {
    pub fn default(&self) -> Box<dyn Reflect> {
        (self.default)()
    }
}

impl<T: Reflect + Default> FromType<T> for ReflectDefault {
    fn from_type() -> Self {
        ReflectDefault {
            default: || Box::new(T::default()),
        }
    }
}
```

2. add `#[reflect(Default)]` to all component types that implement `Default` and are user facing (so not `ComputedSize`, `CubemapVisibleEntities` etc.)



This makes it possible to add the default value of a component to an entity without any compile-time information:

```rust
fn main() {
    let mut app = App::new();
    app.register_type::<Camera>();

    let type_registry = app.world.get_resource::<TypeRegistry>().unwrap();
    let type_registry = type_registry.read();

    let camera_registration = type_registry.get(std::any::TypeId::of::<Camera>()).unwrap();
    let reflect_default = camera_registration.data::<ReflectDefault>().unwrap();
    let reflect_component = camera_registration
        .data::<ReflectComponent>()
        .unwrap()
        .clone();

    let default = reflect_default.default();

    drop(type_registry);

    let entity = app.world.spawn().id();
    reflect_component.add_component(&mut app.world, entity, &*default);

    let camera = app.world.entity(entity).get::<Camera>().unwrap();
    dbg!(&camera);
}
```

### Open questions
- should we have `ReflectDefault` or `ReflectFromWorld` or both?

Author: jakobhellermann

crates/bevy_core/src/name.rs

@@ -1,4 +1,5 @@
 use bevy_ecs::{component::Component, reflect::ReflectComponent};
+use bevy_reflect::std_traits::ReflectDefault;
 use bevy_reflect::Reflect;
 use bevy_utils::AHasher;
 use std::{
@@ -14,7 +15,7 @@ use std::{
 /// as multiple entities can have the same name.  [`bevy_ecs::entity::Entity`] should be
 /// used instead as the default unique identifier.
 #[derive(Component, Debug, Clone, Reflect)]
-#[reflect(Component)]
+#[reflect(Component, Default)]
 pub struct Name {
     hash: u64, // TODO: Shouldn't be serialized
     name: Cow<'static, str>,

crates/bevy_core/src/time/stopwatch.rs

@@ -1,3 +1,4 @@
+use bevy_reflect::prelude::*;
 use bevy_reflect::Reflect;
 use bevy_utils::Duration;
 
@@ -23,6 +24,7 @@ use bevy_utils::Duration;
 /// assert_eq!(stopwatch.elapsed_secs(), 0.0);
 /// ```
 #[derive(Clone, Debug, Default, Reflect)]
+#[reflect(Default)]
 pub struct Stopwatch {
     elapsed: Duration,
     paused: bool,

crates/bevy_core/src/time/timer.rs

@@ -1,5 +1,5 @@
 use crate::Stopwatch;
-use bevy_reflect::Reflect;
+use bevy_reflect::prelude::*;
 use bevy_utils::Duration;
 
 /// Tracks elapsed time. Enters the finished state once `duration` is reached.
@@ -10,6 +10,7 @@ use bevy_utils::Duration;
 ///
 /// Paused timers will not have elapsed time increased.
 #[derive(Clone, Debug, Default, Reflect)]
+#[reflect(Default)]
 pub struct Timer {
     stopwatch: Stopwatch,
     duration: Duration,

crates/bevy_pbr/src/alpha.rs

@@ -1,10 +1,11 @@
 use bevy_ecs::{component::Component, reflect::ReflectComponent};
+use bevy_reflect::std_traits::ReflectDefault;
 use bevy_reflect::Reflect;
 
 // FIXME: This should probably be part of bevy_render2!
 /// Alpha mode
 #[derive(Component, Debug, Reflect, Copy, Clone, PartialEq)]
-#[reflect(Component)]
+#[reflect(Component, Default)]
 pub enum AlphaMode {
     Opaque,
     /// An alpha cutoff must be supplied where alpha values >= the cutoff

crates/bevy_pbr/src/light.rs

@@ -3,7 +3,7 @@ use std::collections::HashSet;
 use bevy_asset::Assets;
 use bevy_ecs::prelude::*;
 use bevy_math::{Mat4, UVec2, UVec3, Vec2, Vec3, Vec3A, Vec3Swizzles, Vec4, Vec4Swizzles};
-use bevy_reflect::Reflect;
+use bevy_reflect::prelude::*;
 use bevy_render::{
     camera::{Camera, CameraProjection, OrthographicProjection},
     color::Color,
@@ -41,7 +41,7 @@ use crate::{
 ///
 /// Source: [Wikipedia](https://en.wikipedia.org/wiki/Lumen_(unit)#Lighting)
 #[derive(Component, Debug, Clone, Copy, Reflect)]
-#[reflect(Component)]
+#[reflect(Component, Default)]
 pub struct PointLight {
     pub color: Color,
     pub intensity: f32,
@@ -113,7 +113,7 @@ impl Default for PointLightShadowMap {
 ///
 /// Source: [Wikipedia](https://en.wikipedia.org/wiki/Lux)
 #[derive(Component, Debug, Clone, Reflect)]
-#[reflect(Component)]
+#[reflect(Component, Default)]
 pub struct DirectionalLight {
     pub color: Color,
     /// Illuminance in lux
@@ -185,10 +185,12 @@ impl Default for AmbientLight {
 }
 
 /// Add this component to make a [`Mesh`](bevy_render::mesh::Mesh) not cast shadows.
-#[derive(Component)]
+#[derive(Component, Reflect, Default)]
+#[reflect(Component, Default)]
 pub struct NotShadowCaster;
 /// Add this component to make a [`Mesh`](bevy_render::mesh::Mesh) not receive shadows.
-#[derive(Component)]
+#[derive(Component, Reflect, Default)]
+#[reflect(Component, Default)]
 pub struct NotShadowReceiver;
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, SystemLabel)]

crates/bevy_pbr/src/wireframe.rs

@@ -4,6 +4,7 @@ use bevy_app::Plugin;
 use bevy_asset::{load_internal_asset, Handle, HandleUntyped};
 use bevy_core_pipeline::Opaque3d;
 use bevy_ecs::{prelude::*, reflect::ReflectComponent};
+use bevy_reflect::std_traits::ReflectDefault;
 use bevy_reflect::{Reflect, TypeUuid};
 use bevy_render::{
     mesh::{Mesh, MeshVertexBufferLayout},
@@ -61,7 +62,7 @@ fn extract_wireframes(mut commands: Commands, query: Query<Entity, With<Wirefram
 
 /// Controls whether an entity should rendered in wireframe-mode if the [`WireframePlugin`] is enabled
 #[derive(Component, Debug, Clone, Default, Reflect)]
-#[reflect(Component)]
+#[reflect(Component, Default)]
 pub struct Wireframe;
 
 #[derive(Debug, Clone, Default)]

crates/bevy_reflect/src/lib.rs

@@ -24,7 +24,10 @@ mod impls {
 }
 
 pub mod serde;
+pub mod std_traits;
+
 pub mod prelude {
+    pub use crate::std_traits::*;
     #[doc(hidden)]
     pub use crate::{
         reflect_trait, GetField, GetTupleStructField, Reflect, ReflectDeserialize, Struct,

crates/bevy_reflect/src/std_traits.rs

@@ -0,0 +1,23 @@
+use crate::{FromType, Reflect};
+
+/// A struct used to provide the default value of a type.
+///
+/// A [`ReflectDefault`] for type `T` can be obtained via [`FromType::from_type`].
+#[derive(Clone)]
+pub struct ReflectDefault {
+    default: fn() -> Box<dyn Reflect>,
+}
+
+impl ReflectDefault {
+    pub fn default(&self) -> Box<dyn Reflect> {
+        (self.default)()
+    }
+}
+
+impl<T: Reflect + Default> FromType<T> for ReflectDefault {
+    fn from_type() -> Self {
+        ReflectDefault {
+            default: || Box::new(T::default()),
+        }
+    }
+}

crates/bevy_render/src/camera/camera.rs

@@ -21,15 +21,15 @@ use bevy_ecs::{
     system::{Commands, ParamSet, Query, Res, ResMut},
 };
 use bevy_math::{Mat4, UVec2, Vec2, Vec3};
-use bevy_reflect::{Reflect, ReflectDeserialize};
+use bevy_reflect::prelude::*;
 use bevy_transform::components::GlobalTransform;
 use bevy_utils::HashSet;
 use bevy_window::{WindowCreated, WindowId, WindowResized, Windows};
 use serde::{Deserialize, Serialize};
 use wgpu::Extent3d;
 
 #[derive(Component, Default, Debug, Reflect, Clone)]
-#[reflect(Component)]
+#[reflect(Component, Default)]
 pub struct Camera {
     pub projection_matrix: Mat4,
     #[reflect(ignore)]

crates/bevy_render/src/camera/projection.rs

@@ -1,6 +1,7 @@
 use super::DepthCalculation;
 use bevy_ecs::{component::Component, reflect::ReflectComponent};
 use bevy_math::Mat4;
+use bevy_reflect::std_traits::ReflectDefault;
 use bevy_reflect::{Reflect, ReflectDeserialize};
 use serde::{Deserialize, Serialize};
 
@@ -12,7 +13,7 @@ pub trait CameraProjection {
 }
 
 #[derive(Component, Debug, Clone, Reflect)]
-#[reflect(Component)]
+#[reflect(Component, Default)]
 pub struct PerspectiveProjection {
     pub fov: f32,
     pub aspect_ratio: f32,
@@ -72,7 +73,7 @@ pub enum ScalingMode {
 }
 
 #[derive(Component, Debug, Clone, Reflect)]
-#[reflect(Component)]
+#[reflect(Component, Default)]
 pub struct OrthographicProjection {
     pub left: f32,
     pub right: f32,