Add on_client_insert to add_visiblity_filter

Author: malfuu

src/server/visibility.rs

@@ -104,6 +104,7 @@ impl AppVisibilityExt for App {
 
         self.add_observer(update_for_new_clients::<F>)
             .add_observer(on_insert::<F>)
+            .add_observer(on_client_insert::<F>)
             .add_observer(on_remove::<F>)
             .add_observer(on_client_remove::<F>)
     }
@@ -158,6 +159,28 @@ fn on_insert<F: VisibilityFilter>(
     }
 }
 
+fn on_client_insert<F: VisibilityFilter>(
+    insert: On<Insert, F::ClientComponent>,
+    registry: Res<FilterRegistry>,
+    mut clients: Query<(&F::ClientComponent, &mut ClientVisibility)>,
+    entities: Query<(Entity, &F), Without<ClientVisibility>>,
+) {
+    let Ok((client_component, mut visibility)) = clients.get_mut(insert.entity) else {
+        return;
+    };
+
+    let bit = registry.bit::<F>();
+    for (entity, component) in &entities {
+        let visible = component.is_visible(insert.entity, Some(client_component));
+        debug!(
+            "evaluating inserted `{}` to client `{}` for entity `{entity}` to `{visible}`",
+            ShortName::of::<F>(),
+            insert.entity
+        );
+        visibility.set(entity, bit, visible);
+    }
+}
+
 fn on_remove<F: VisibilityFilter>(
     remove: On<Remove, F>,
     registry: Res<FilterRegistry>,

tests/spawn.rs

@@ -558,6 +558,47 @@ fn visibility_gain() {
     assert_eq!(components.iter(client_app.world()).len(), 1);
 }
 
+#[test]
+fn visibility_gain_late_client() {
+    let mut server_app = App::new();
+    let mut client_app = App::new();
+    for app in [&mut server_app, &mut client_app] {
+        app.add_plugins((
+            MinimalPlugins,
+            StatesPlugin,
+            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
+        ))
+        .replicate::<A>()
+        .add_visibility_filter::<DeferredVisibility>()
+        .finish();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    server_app
+        .world_mut()
+        .spawn((Replicated, DeferredVisibility, A));
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+
+    let mut components = client_app.world_mut().query::<&A>();
+    assert_eq!(components.iter(client_app.world()).len(), 0);
+
+    let client = **client_app.world().resource::<TestClientEntity>();
+    server_app
+        .world_mut()
+        .entity_mut(client)
+        .insert(CanSeeDeferred);
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+
+    assert_eq!(components.iter(client_app.world()).len(), 1);
+}
+
 #[test]
 fn visibility_gain_with_signature() {
     let mut server_app = App::new();
@@ -616,3 +657,20 @@ impl VisibilityFilter for EntityVisibility {
         component.is_some()
     }
 }
+
+#[derive(Component)]
+#[component(immutable)]
+struct DeferredVisibility;
+
+#[derive(Component)]
+#[component(immutable)]
+struct CanSeeDeferred;
+
+impl VisibilityFilter for DeferredVisibility {
+    type ClientComponent = CanSeeDeferred;
+    type Scope = Entity;
+
+    fn is_visible(&self, _client: Entity, component: Option<&Self::ClientComponent>) -> bool {
+        component.is_some()
+    }
+}