Merge pull request #456 from Freyja-moth/cleanup

Cleanup

Author: janhohenheim

src/main.rs

@@ -18,8 +18,10 @@ mod third_party;
 mod ui_camera;
 
 use asset_processing::default_image_sampler_descriptor;
+use bevy::app::HierarchyPropagatePlugin;
 use bevy::gltf::GltfPlugin;
 use bevy::gltf::convert_coordinates::GltfConvertCoordinates;
+use bevy::light::NotShadowCaster;
 use bevy::log::LogPlugin;
 use bevy::log::tracing_subscriber::field::MakeExt;
 use bevy::pbr::DefaultOpaqueRendererMethod;
@@ -112,6 +114,7 @@ fn main() -> AppExit {
         SeedlingPlugin::default(),
         #[cfg(feature = "web")]
         SeedlingPlugin::new_web_audio(),
+        HierarchyPropagatePlugin::<NotShadowCaster>::new(Update),
     ));
 
     app.insert_resource(GlobalAmbientLight::NONE);

src/props/brush_entity/light_window.rs

@@ -1,9 +1,6 @@
-use bevy::prelude::*;
-
+use bevy::{app::Propagate, light::NotShadowCaster, prelude::*};
 use bevy_trenchbroom::prelude::*;
 
-use crate::props::effects::disable_shadow_casting;
-
 pub(super) fn plugin(app: &mut App) {
     app.add_observer(setup_light_window_brush_entity);
 }
@@ -15,13 +12,13 @@ fn setup_light_window_brush_entity(add: On<Add, LightWindow>, mut commands: Comm
     let entity = add.entity;
     commands
         .entity(entity)
+        .insert((NotShadowCaster, Propagate(NotShadowCaster)))
         // Using `children!` here would run into https://github.com/Noxmore/bevy_trenchbroom/issues/95
         .with_child(SpotLight {
             color: Color::srgb_u8(239, 173, 144),
             intensity: 200_000.0,
             radius: 0.1,
             shadows_enabled: true,
             ..default()
-        })
-        .queue(disable_shadow_casting);
+        });
 }

src/props/effects.rs

@@ -1,35 +1,5 @@
 //! Utility functions for adding special effects to props.
 
-use bevy::{light::NotShadowCaster, prelude::*, scene::SceneInstanceReady};
-
-use std::iter;
+use bevy::app::App;
 
 pub(super) fn plugin(_app: &mut App) {}
-
-pub(crate) fn disable_shadow_casting_on_instance_ready(
-    ready: On<SceneInstanceReady>,
-    mut commands: Commands,
-) {
-    commands.entity(ready.entity).queue(disable_shadow_casting);
-}
-
-pub(crate) fn disable_shadow_casting(entity_world: EntityWorldMut) {
-    let entity = entity_world.id();
-    entity_world
-        .into_world_mut()
-        .run_system_cached_with(disable_shadow_casting_system, entity)
-        .unwrap();
-}
-
-fn disable_shadow_casting_system(
-    In(entity): In<Entity>,
-    children: Query<&Children>,
-    is_mesh: Query<&Mesh3d>,
-    mut commands: Commands,
-) {
-    for child in iter::once(entity).chain(children.iter_descendants(entity)) {
-        if is_mesh.get(child).is_ok() {
-            commands.entity(child).insert(NotShadowCaster);
-        }
-    }
-}

src/props/generic.rs

@@ -1,28 +1,11 @@
-use crate::{
-    asset_tracking::LoadResource, third_party::bevy_trenchbroom::GetTrenchbroomModelPath as _,
-};
+use crate::{asset_tracking::LoadResource, third_party::bevy_trenchbroom::GetTrenchbroomModelPath};
 
 use super::setup::*;
+use avian3d::prelude::{ColliderConstructor, RigidBody};
 use bevy::prelude::*;
 use bevy_trenchbroom::prelude::*;
 
 pub(super) fn plugin(app: &mut App) {
-    app.add_observer(setup_static_prop_with_convex_hull::<Grate>)
-        .add_observer(setup_static_prop_with_convex_decomposition::<Table>)
-        .add_observer(setup_static_prop_with_convex_hull::<Bookshelf>)
-        .add_observer(setup_static_prop_with_convex_hull::<Generator2>)
-        .add_observer(setup_static_prop_with_convex_hull::<BarrelLargeClosed>)
-        .add_observer(setup_static_prop_with_convex_hull::<Barrel01>)
-        .add_observer(setup_static_prop_with_convex_hull::<CrateSquare>)
-        .add_observer(setup_static_prop_with_convex_hull::<FenceBarsDecorativeSingle>)
-        .add_observer(setup_static_prop_with_convex_hull::<DoorStainedGlass>);
-
-    app.add_observer(setup_dynamic_prop_with_convex_hull::<PackageMedium>)
-        .add_observer(setup_dynamic_prop_with_convex_hull::<PackageSmall>);
-
-    app.add_observer(setup_nonphysical_prop::<IvyPart8>)
-        .add_observer(setup_nonphysical_prop::<SmallDoorSign1>);
-
     app.load_asset::<Gltf>(PackageMedium::model_path())
         .load_asset::<Gltf>(PackageSmall::model_path())
         .load_asset::<Gltf>(Grate::model_path())
@@ -44,67 +27,78 @@ pub(super) fn plugin(app: &mut App) {
     base(Transform, Visibility),
     model("models/darkmod/containers/package_medium.gltf")
 )]
+#[component(on_add = setup_prop::<PackageMedium>(RigidBody::Dynamic, ColliderConstructor::ConvexHullFromMesh))]
 pub(crate) struct PackageMedium;
 
 #[point_class(
     base(Transform, Visibility),
     model("models/darkmod/containers/package_small.gltf")
 )]
+#[component(on_add = setup_prop::<PackageSmall>(RigidBody::Dynamic, ColliderConstructor::ConvexHullFromMesh))]
 pub(crate) struct PackageSmall;
 
 // generic static props
 #[point_class(
     base(Transform, Visibility),
     model("models/darkmod/fireplace/grate.gltf")
 )]
+#[component(on_add = setup_prop::<Grate>(RigidBody::Static, ColliderConstructor::ConvexHullFromMesh))]
 pub(crate) struct Grate;
 
 #[point_class(
     base(Transform, Visibility),
     model("models/darkmod/furniture/tables/rtable1.gltf")
 )]
+#[component(on_add = setup_prop::<Table>(RigidBody::Static, ColliderConstructor::ConvexDecompositionFromMesh))]
 pub(crate) struct Table;
 
 #[point_class(
     base(Transform, Visibility),
     model("models/darkmod/furniture/shelves/bookshelf02.gltf")
 )]
+#[component(on_add = setup_prop::<Bookshelf>(RigidBody::Static, ColliderConstructor::ConvexHullFromMesh))]
 pub(crate) struct Bookshelf;
 
 #[point_class(
     base(Transform, Visibility),
     model("models/darkmod/mechanical/generator2/generator2.gltf")
 )]
+#[component(on_add = setup_prop::<Generator2>(RigidBody::Static, ColliderConstructor::ConvexHullFromMesh))]
 pub(crate) struct Generator2;
 
 #[point_class(
     base(Transform, Visibility),
     model("models/darkmod/containers/barrel_large_closed.gltf")
 )]
+#[component(on_add = setup_prop::<BarrelLargeClosed>(RigidBody::Static, ColliderConstructor::ConvexHullFromMesh))]
 pub(crate) struct BarrelLargeClosed;
 
 #[point_class(
     base(Transform, Visibility),
     model("models/darkmod/containers/barrel01.gltf")
 )]
+#[component(on_add = setup_prop::<Barrel01>(RigidBody::Static, ColliderConstructor::ConvexHullFromMesh))]
 pub(crate) struct Barrel01;
 
 #[point_class(
     base(Transform, Visibility),
     model("models/darkmod/containers/crate_square.gltf")
 )]
+#[component(on_add = setup_prop::<CrateSquare>(RigidBody::Static, ColliderConstructor::ConvexHullFromMesh))]
 pub(crate) struct CrateSquare;
 
 #[point_class(
     base(Transform, Visibility),
     model("models/darkmod/architecture/fencing/fence_bars_decorative01_single.gltf")
 )]
+#[component(on_add = setup_prop::<FenceBarsDecorativeSingle>(RigidBody::Static, ColliderConstructor::ConvexHullFromMesh))]
 pub(crate) struct FenceBarsDecorativeSingle;
 
 #[point_class(
     base(Transform, Visibility),
     model("models/darkmod/architecture/doors/door_stained_glass_118x52.gltf")
 )]
+#[component(on_add = setup_prop::<DoorStainedGlass>(RigidBody::Static, ColliderConstructor::ConvexHullFromMesh))]
 pub(crate) struct DoorStainedGlass;
 
 // Generic non-physical props
@@ -113,10 +107,12 @@ pub(crate) struct DoorStainedGlass;
     base(Transform, Visibility),
     model("models/darkmod/nature/ivy_part08.gltf")
 )]
+#[component(on_add = setup_nonphysical_prop::<IvyPart8>)]
 pub(crate) struct IvyPart8;
 
 #[point_class(
     base(Transform, Visibility),
     model("models/darkmod/decorative/signs/small_door_sign1.gltf")
 )]
+#[component(on_add = setup_nonphysical_prop::<SmallDoorSign1>)]
 pub(crate) struct SmallDoorSign1;

src/props/setup.rs

@@ -5,53 +5,49 @@
 use crate::third_party::avian3d::CollisionLayer;
 use crate::third_party::bevy_trenchbroom::LoadTrenchbroomModel as _;
 use avian3d::prelude::*;
+use bevy::asset::io::embedded::GetAssetServer;
+use bevy::ecs::lifecycle::HookContext;
+use bevy::ecs::world::DeferredWorld;
 use bevy::prelude::*;
 
 use bevy_trenchbroom::class::QuakeClass;
+use bevy_trenchbroom::util::IsSceneWorld as _;
 
 pub(super) fn plugin(_app: &mut App) {}
 
-pub(crate) fn setup_static_prop_with_convex_hull<T: QuakeClass>(
-    add: On<Add, T>,
-    asset_server: Res<AssetServer>,
-    mut commands: Commands,
-) {
-    let bundle = static_bundle::<T>(&asset_server, ColliderConstructor::ConvexHullFromMesh);
-    commands.entity(add.entity).insert(bundle);
+pub(crate) fn setup_prop<T: QuakeClass>(
+    rigid_body: RigidBody,
+    collider: ColliderConstructor,
+) -> impl FnOnce(DeferredWorld, HookContext) {
+    move |mut world, ctx| {
+        if world.is_scene_world() {
+            return;
+        }
+        world.commands().queue(move |world: &mut World| {
+            let asset_server = world.get_asset_server().clone();
+            world.entity_mut(ctx.entity).insert(quake_bundle::<T>(
+                asset_server,
+                rigid_body,
+                collider,
+            ));
+        });
+    }
 }
 
-pub(crate) fn setup_nonphysical_prop<T: QuakeClass>(
-    add: On<Add, T>,
-    asset_server: Res<AssetServer>,
-    mut commands: Commands,
-) {
-    let model = asset_server.load_trenchbroom_model::<T>();
-    commands.entity(add.entity).insert(SceneRoot(model));
-}
-
-pub(crate) fn setup_static_prop_with_convex_decomposition<T: QuakeClass>(
-    add: On<Add, T>,
-    asset_server: Res<AssetServer>,
-    mut commands: Commands,
-) {
-    let bundle = static_bundle::<T>(
-        &asset_server,
-        ColliderConstructor::ConvexDecompositionFromMesh,
-    );
-    commands.entity(add.entity).insert(bundle);
+pub(crate) fn setup_nonphysical_prop<T: QuakeClass>(mut world: DeferredWorld, ctx: HookContext) {
+    if world.is_scene_world() {
+        return;
+    }
+    world.commands().queue(move |world: &mut World| {
+        let asset_server = world.get_asset_server().clone();
+        let model = asset_server.load_trenchbroom_model::<T>();
+        world.entity_mut(ctx.entity).insert(SceneRoot(model));
+    });
 }
 
-pub(crate) fn setup_dynamic_prop_with_convex_hull<T: QuakeClass>(
-    add: On<Add, T>,
-    asset_server: Res<AssetServer>,
-    mut commands: Commands,
-) {
-    let bundle = dynamic_bundle::<T>(&asset_server, ColliderConstructor::ConvexHullFromMesh);
-    commands.entity(add.entity).insert(bundle);
-}
-
-pub(crate) fn dynamic_bundle<T: QuakeClass>(
-    asset_server: &AssetServer,
+pub(crate) fn quake_bundle<T: QuakeClass>(
+    asset_server: AssetServer,
+    rigid_body: RigidBody,
     constructor: ColliderConstructor,
 ) -> impl Bundle {
     let model = asset_server.load_trenchbroom_model::<T>();
@@ -60,22 +56,7 @@ pub(crate) fn dynamic_bundle<T: QuakeClass>(
             .with_default_layers(CollisionLayers::new(CollisionLayer::Prop, LayerMask::ALL))
             // About the density of oak wood (600-800 kg/m^3)
             .with_default_density(800.0),
-        RigidBody::Dynamic,
-        SceneRoot(model),
-    )
-}
-
-pub(crate) fn static_bundle<T: QuakeClass>(
-    asset_server: &AssetServer,
-    constructor: ColliderConstructor,
-) -> impl Bundle {
-    let model = asset_server.load_trenchbroom_model::<T>();
-    (
-        ColliderConstructorHierarchy::new(constructor).with_default_layers(CollisionLayers::new(
-            CollisionLayer::Default,
-            LayerMask::ALL,
-        )),
-        RigidBody::Static,
+        rigid_body,
         SceneRoot(model),
     )
 }