Remove copying/constructing traits from Parent/Children

Author: james7132

crates/bevy_transform/src/components/children.rs

@@ -1,14 +1,16 @@
 use bevy_ecs::{
     component::Component,
     entity::{Entity, EntityMap, MapEntities, MapEntitiesError},
+    prelude::FromWorld,
     reflect::{ReflectComponent, ReflectMapEntities},
+    world::World,
 };
 use bevy_reflect::Reflect;
 use smallvec::SmallVec;
 use std::ops::Deref;
 
 /// Contains references to the child entities of this entity
-#[derive(Component, Default, Clone, Debug, Reflect)]
+#[derive(Component, Debug, Reflect)]
 #[reflect(Component, MapEntities)]
 pub struct Children(pub(crate) SmallVec<[Entity; 8]>);
 
@@ -22,6 +24,16 @@ impl MapEntities for Children {
     }
 }
 
+// TODO: We need to impl either FromWorld or Default so Children can be registered as Reflect.
+// This is because Reflect deserialize by creating an instance and apply a patch on top.
+// However Children should only ever be set with a real user-defined entities.  Its worth looking 
+// into better ways to handle cases like this.
+impl FromWorld for Children {
+    fn from_world(_world: &mut World) -> Self {
+        Children(SmallVec::new())
+    }
+}
+
 impl Children {
     /// Builds and returns a [`Children`] component with the given entities
     pub fn with(entity: &[Entity]) -> Self {

crates/bevy_transform/src/components/parent.rs

@@ -9,12 +9,12 @@ use std::ops::Deref;
 
 /// Holds a reference to the parent entity of this entity.
 /// This component should only be present on entities that actually have a parent entity.
-#[derive(Component, Debug, Copy, Clone, Eq, PartialEq, Reflect)]
+#[derive(Component, Debug, Eq, PartialEq, Reflect)]
 #[reflect(Component, MapEntities, PartialEq)]
 pub struct Parent(pub(crate) Entity);
 
-// TODO: We need to impl either FromWorld or Default so Parent can be registered as Properties.
-// This is because Properties deserialize by creating an instance and apply a patch on top.
+// TODO: We need to impl either FromWorld or Default so Parent can be registered as Reflect.
+// This is because Reflect deserialize by creating an instance and apply a patch on top.
 // However Parent should only ever be set with a real user-defined entity.  Its worth looking into
 // better ways to handle cases like this.
 impl FromWorld for Parent {

crates/bevy_transform/src/hierarchy/child_builder.rs

@@ -50,9 +50,9 @@ fn push_child_unchecked(world: &mut World, parent: Entity, child: Entity) {
 fn update_parent(world: &mut World, child: Entity, new_parent: Entity) -> Option<Entity> {
     let mut child = world.entity_mut(child);
     if let Some(mut parent) = child.get_mut::<Parent>() {
-        let previous = *parent;
+        let previous = parent.0;
         *parent = Parent(new_parent);
-        Some(*previous)
+        Some(previous)
     } else {
         child.insert(Parent(new_parent));
         None