Ported example 5

lib/ui/src/runtime.rs

@@ -186,6 +186,7 @@ mod tests {
         KeyboardEvent, KeyboardEventKind, KeyboardKey, KeyboardModifiers, PointerEvent,
         PointerEventKind,
     };
+    use ruin_reactivity::cell;
     use ruin_runtime::{current_thread_handle, queue_future, run};
     use std::future::Future;
 
@@ -387,4 +388,71 @@ mod tests {
             ui.shutdown().expect("shutdown should queue");
         });
     }
+
+    #[test]
+    fn async_signal_updates_represent_scene_without_external_events() {
+        run_async_test(async move {
+            let mut ui = UiRuntime::headless();
+            let window = ui
+                .create_window(WindowSpec::new("async-scene-effect").visible(true))
+                .expect("window should be created");
+            let scene_version = std::rc::Rc::new(std::cell::Cell::new(0_u64));
+            let value = cell(0_u32);
+            let _scene_effect = window.attach_scene_effect({
+                let scene_version = std::rc::Rc::clone(&scene_version);
+                let value = value.clone();
+                move || {
+                    let next_version = scene_version.get() + 1;
+                    scene_version.set(next_version);
+                    let mut scene = SceneSnapshot::new(next_version, UiSize::new(320.0, 180.0));
+                    scene.push_text(PreparedText::monospace(
+                        format!("value={}", value.get()),
+                        Point::new(16.0, 28.0),
+                        16.0,
+                        8.0,
+                        Color::rgb(0xFF, 0xFF, 0xFF),
+                    ));
+                    scene
+                }
+            });
+
+            let _ = ui
+                .wait_for_event_matching(|event| {
+                    matches!(
+                        event,
+                        PlatformEvent::FramePresented {
+                            window_id,
+                            scene_version: 1,
+                            ..
+                        } if *window_id == window.id()
+                    )
+                })
+                .await
+                .expect("initial scene should present");
+
+            queue_future({
+                let value = value.clone();
+                async move {
+                    ruin_runtime::yield_now().await;
+                    let _ = value.set(1);
+                }
+            });
+
+            let _ = ui
+                .wait_for_event_matching(|event| {
+                    matches!(
+                        event,
+                        PlatformEvent::FramePresented {
+                            window_id,
+                            scene_version: 2,
+                            ..
+                        } if *window_id == window.id()
+                    )
+                })
+                .await
+                .expect("async signal update should re-present the scene");
+
+            ui.shutdown().expect("shutdown should queue");
+        });
+    }
 }