Improve tester

* Add LoopResult::ContinueOnWindowEvent
* Added a client_size argument to run_window_app

Author: aosoft

unity-native-plugin-sample/src/lib.rs

@@ -57,6 +57,7 @@ extern "system" fn FillTexture(unity_texture: *mut IUnknown, x: f32, y: f32, z:
 fn test() {
     let instant = std::time::Instant::now();
     unity_native_plugin_tester::d3d11::test_plugin_d3d11(
+        (256, 256),
         |window, context| {},
         |window, context| {
             let n = (instant.elapsed().as_millis() % 1000) as f32 / 1000.0;

unity-native-plugin-tester/src/d3d11.rs

@@ -164,6 +164,7 @@ pub fn test_plugin_d3d11<
     FnMain: FnMut(&Window, &TesterContextGraphicsD3D11) -> crate::window::LoopResult,
     FnFinalize: FnOnce(&Window, &TesterContextGraphicsD3D11),
 >(
+    client_size: (u32, u32),
     fn_init: FnInit,
     mut fn_main: FnMain,
     fn_finalize: FnFinalize,
@@ -178,6 +179,7 @@ pub fn test_plugin_d3d11<
     crate::graphics::initialize_interface(unity_native_plugin::graphics::GfxRenderer::D3D11);
 
     crate::window::run_window_app(
+        client_size,
         |window| {
             let ret = TesterContextGraphicsD3D11::new(window).unwrap();
             fn_init(window, &ret);

unity-native-plugin-tester/src/window.rs

@@ -7,8 +7,17 @@ use winit::platform::desktop::EventLoopExtDesktop;
 #[cfg(target_os = "windows")]
 use winit::platform::windows::EventLoopExtWindows;
 
+#[derive(PartialEq, Eq)]
 pub enum LoopResult {
+    /// Continue the loop. The next process is executed immediately.
     Continue,
+
+    /// Continue the loop. The next process is executed when a window event occurs.
+    /// (e.g., moving the mouse over a window)
+    /// Use when the process to be implemented is high load.
+    ContinueOnWindowEvent,
+
+    /// End the loop.
     Exit,
 }
 
@@ -18,14 +27,20 @@ pub fn run_window_app<
     FnMain: FnMut(&Window, &Context) -> LoopResult,
     FnFinalize: FnOnce(&Window, &Context),
 >(
+    client_size: (u32, u32),
     fn_initialize: FnInit,
     mut fn_main: FnMain,
     fn_finalize: FnFinalize,
     fn_unity_plugin_load: fn(interfaces: &unity_native_plugin::interface::UnityInterfaces),
     fn_unity_plugin_unload: fn(),
 ) {
     let mut event_loop = EventLoop::<u32>::new_any_thread();
-    let window = WindowBuilder::new().build(&event_loop).unwrap();
+    let window = WindowBuilder::new()
+        .with_inner_size(winit::dpi::Size::from(
+            winit::dpi::PhysicalSize::<u32>::from(client_size),
+        ))
+        .build(&event_loop)
+        .unwrap();
 
     let context = std::rc::Rc::new(fn_initialize(&window));
     unsafe {
@@ -35,23 +50,31 @@ pub fn run_window_app<
 
     fn_unity_plugin_load(unity_native_plugin::interface::UnityInterfaces::get());
 
+    let mut last_result = LoopResult::Continue;
     event_loop.run_return(|event, _, control_flow| {
+        let instant = std::time::Instant::now();
         match event {
-            Event::WindowEvent { window_id, event} => {
+            Event::WindowEvent { window_id, event } => {
                 if window_id == window.id() {
                     match event {
-                        WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                        WindowEvent::CloseRequested => last_result = LoopResult::Exit,
                         _ => {
-                            *control_flow = match fn_main(&window, context.deref()) {
-                                LoopResult::Continue => ControlFlow::Wait,
-                                _ => ControlFlow::Exit,
-                            };
+                            last_result = fn_main(&window, context.deref());
                         }
                     }
                 }
             }
-            _ => (),
+            _ => {
+                if last_result == LoopResult::Continue {
+                    last_result = fn_main(&window, context.deref());
+                }
+            },
         }
+        *control_flow = match last_result {
+            LoopResult::Continue => ControlFlow::WaitUntil(instant + std::time::Duration::from_millis(50)),
+            LoopResult::ContinueOnWindowEvent => ControlFlow::Wait,
+            _ => ControlFlow::Exit,
+        };
     });
 
     fn_unity_plugin_unload();