Skip to content

Commit abff83f

Browse files
aosoftaosoft
authored
Merge pull request #22 from aosoft/taniuchi/#21
Upgrade winit to 0.30 in unity-native-plugin-tester
2 parents 1c9e767 + 8335a82 commit abff83f

5 files changed

Lines changed: 144 additions & 58 deletions

File tree

‎unity-native-plugin-tester/Cargo.toml‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -27,10 +27,10 @@ d3d12 = []
2727
[dependencies]
2828
unity-native-plugin-sys = { version = "0.9.0", path = "../unity-native-plugin-sys" }
2929
unity-native-plugin = { version = "0.9.0", path = "../unity-native-plugin", features = ["d3d11", "d3d12"] }
30+
winit = "0.30"
31+
raw-window-handle = "0.6"
3032

3133
[target.'cfg(windows)'.dependencies]
32-
winapi = { version = "0.3.9", features = ["winuser", "dxgi", "d3d11", "dxgiformat", "dxgitype", "d3dcommon"] }
33-
winit = "0.23.0"
34+
winapi = { version = "0.3.9", features = ["winuser", "dxgi", "d3d11", "dxgiformat", "dxgitype", "d3dcommon", "winerror", "combaseapi", "objbase"] }
3435
wio = "0.2.2"
35-
raw-window-handle = "0.3.3"
3636

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

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use raw_window_handle::HasRawWindowHandle;
1+
use raw_window_handle::HasWindowHandle;
22
use unity_native_plugin::interface::UnityInterface;
33
use unity_native_plugin_sys::*;
44
use winapi::shared::{dxgi, dxgiformat, dxgitype, minwindef, winerror};
@@ -45,10 +45,10 @@ impl TesterContextGraphicsD3D11 {
4545
},
4646
BufferUsage: dxgitype::DXGI_USAGE_RENDER_TARGET_OUTPUT,
4747
BufferCount: 2,
48-
OutputWindow: match window.raw_window_handle() {
49-
raw_window_handle::RawWindowHandle::Windows(h) => h.hwnd,
48+
OutputWindow: match window.window_handle().unwrap().as_raw() {
49+
raw_window_handle::RawWindowHandle::Win32(h) => h.hwnd.get() as _,
5050
_ => std::ptr::null_mut(),
51-
} as _,
51+
},
5252
Windowed: minwindef::TRUE,
5353
SwapEffect: dxgi::DXGI_SWAP_EFFECT_DISCARD,
5454
Flags: dxgi::DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH,

‎unity-native-plugin-tester/src/lib.rs‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,6 @@
22

33
pub mod graphics;
44
pub mod interface;
5-
#[cfg(windows)]
65
pub mod window;
76

87
#[cfg(all(windows, feature = "d3d11"))]

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

Lines changed: 131 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
1-
use winit::event::{Event, WindowEvent};
2-
use winit::event_loop::{ControlFlow, EventLoop};
3-
use winit::window::{Window, WindowBuilder};
4-
51
use std::ops::Deref;
6-
use winit::platform::desktop::EventLoopExtDesktop;
2+
use winit::application::ApplicationHandler;
3+
use winit::event::WindowEvent;
4+
use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
5+
use winit::window::{Window, WindowId};
6+
77
#[cfg(target_os = "windows")]
8-
use winit::platform::windows::EventLoopExtWindows;
8+
use winit::platform::windows::EventLoopBuilderExtWindows;
99

1010
#[derive(PartialEq, Eq)]
1111
pub enum LoopResult {
@@ -21,64 +21,147 @@ pub enum LoopResult {
2121
Exit,
2222
}
2323

24-
pub fn run_window_app<
24+
struct App<Context, FnInit, FnMain, FnFinalize>
25+
where
2526
Context: 'static + crate::interface::UnityInterfaceBase + crate::interface::UnityInterfaceID,
2627
FnInit: FnOnce(&Window) -> Context,
2728
FnMain: FnMut(&Window, &Context) -> LoopResult,
2829
FnFinalize: FnOnce(&Window, &Context),
29-
>(
30+
{
3031
client_size: (u32, u32),
31-
fn_initialize: FnInit,
32-
mut fn_main: FnMain,
33-
fn_finalize: FnFinalize,
32+
fn_initialize: Option<FnInit>,
33+
fn_main: FnMain,
34+
fn_finalize: Option<FnFinalize>,
3435
fn_unity_plugin_load: fn(interfaces: &unity_native_plugin::interface::UnityInterfaces),
35-
fn_unity_plugin_unload: fn(),
36-
) {
37-
let mut event_loop = EventLoop::<u32>::new_any_thread();
38-
let window = WindowBuilder::new()
39-
.with_inner_size(winit::dpi::Size::from(
40-
winit::dpi::PhysicalSize::<u32>::from(client_size),
41-
))
42-
.build(&event_loop)
43-
.unwrap();
36+
window: Option<Window>,
37+
context: Option<std::rc::Rc<Context>>,
38+
last_result: LoopResult,
39+
}
4440

45-
let context = std::rc::Rc::new(fn_initialize(&window));
46-
unsafe {
47-
crate::interface::get_unity_interfaces()
48-
.register_interface::<Context>(Some(context.clone()));
41+
impl<Context, FnInit, FnMain, FnFinalize> App<Context, FnInit, FnMain, FnFinalize>
42+
where
43+
Context: 'static + crate::interface::UnityInterfaceBase + crate::interface::UnityInterfaceID,
44+
FnInit: FnOnce(&Window) -> Context,
45+
FnMain: FnMut(&Window, &Context) -> LoopResult,
46+
FnFinalize: FnOnce(&Window, &Context),
47+
{
48+
fn update_control_flow(&self, event_loop: &ActiveEventLoop) {
49+
match self.last_result {
50+
LoopResult::Continue => {
51+
event_loop.set_control_flow(ControlFlow::WaitUntil(
52+
std::time::Instant::now() + std::time::Duration::from_millis(50),
53+
));
54+
}
55+
LoopResult::ContinueOnWindowEvent => {
56+
event_loop.set_control_flow(ControlFlow::Wait);
57+
}
58+
LoopResult::Exit => {
59+
event_loop.exit();
60+
}
61+
}
4962
}
63+
}
5064

51-
fn_unity_plugin_load(unity_native_plugin::interface::UnityInterfaces::get());
65+
impl<Context, FnInit, FnMain, FnFinalize> ApplicationHandler<u32>
66+
for App<Context, FnInit, FnMain, FnFinalize>
67+
where
68+
Context: 'static + crate::interface::UnityInterfaceBase + crate::interface::UnityInterfaceID,
69+
FnInit: FnOnce(&Window) -> Context,
70+
FnMain: FnMut(&Window, &Context) -> LoopResult,
71+
FnFinalize: FnOnce(&Window, &Context),
72+
{
73+
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
74+
if self.window.is_some() {
75+
return;
76+
}
77+
let attrs = Window::default_attributes()
78+
.with_inner_size(winit::dpi::PhysicalSize::<u32>::from(self.client_size));
79+
let window = event_loop.create_window(attrs).unwrap();
5280

53-
let mut last_result = LoopResult::Continue;
54-
event_loop.run_return(|event, _, control_flow| {
55-
let instant = std::time::Instant::now();
81+
let fn_init = self.fn_initialize.take().unwrap();
82+
let context = std::rc::Rc::new(fn_init(&window));
83+
unsafe {
84+
crate::interface::get_unity_interfaces()
85+
.register_interface::<Context>(Some(context.clone()));
86+
}
87+
(self.fn_unity_plugin_load)(unity_native_plugin::interface::UnityInterfaces::get());
88+
89+
self.window = Some(window);
90+
self.context = Some(context);
91+
}
92+
93+
fn window_event(
94+
&mut self,
95+
event_loop: &ActiveEventLoop,
96+
window_id: WindowId,
97+
event: WindowEvent,
98+
) {
99+
let Some(window) = self.window.as_ref() else {
100+
return;
101+
};
102+
if window_id != window.id() {
103+
return;
104+
}
105+
let context = self.context.as_ref().unwrap();
56106
match event {
57-
Event::WindowEvent { window_id, event } => {
58-
if window_id == window.id() {
59-
match event {
60-
WindowEvent::CloseRequested => last_result = LoopResult::Exit,
61-
_ => {
62-
last_result = fn_main(&window, context.deref());
63-
}
64-
}
65-
}
107+
WindowEvent::CloseRequested => {
108+
self.last_result = LoopResult::Exit;
66109
}
67110
_ => {
68-
if last_result == LoopResult::Continue {
69-
last_result = fn_main(&window, context.deref());
70-
}
111+
self.last_result = (self.fn_main)(window, context.deref());
71112
}
72113
}
73-
*control_flow = match last_result {
74-
LoopResult::Continue => {
75-
ControlFlow::WaitUntil(instant + std::time::Duration::from_millis(50))
76-
}
77-
LoopResult::ContinueOnWindowEvent => ControlFlow::Wait,
78-
_ => ControlFlow::Exit,
114+
self.update_control_flow(event_loop);
115+
}
116+
117+
fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
118+
let (Some(window), Some(context)) = (self.window.as_ref(), self.context.as_ref()) else {
119+
return;
79120
};
80-
});
121+
if self.last_result == LoopResult::Continue {
122+
self.last_result = (self.fn_main)(window, context.deref());
123+
}
124+
self.update_control_flow(event_loop);
125+
}
126+
}
127+
128+
pub fn run_window_app<
129+
Context: 'static + crate::interface::UnityInterfaceBase + crate::interface::UnityInterfaceID,
130+
FnInit: FnOnce(&Window) -> Context,
131+
FnMain: FnMut(&Window, &Context) -> LoopResult,
132+
FnFinalize: FnOnce(&Window, &Context),
133+
>(
134+
client_size: (u32, u32),
135+
fn_initialize: FnInit,
136+
fn_main: FnMain,
137+
fn_finalize: FnFinalize,
138+
fn_unity_plugin_load: fn(interfaces: &unity_native_plugin::interface::UnityInterfaces),
139+
fn_unity_plugin_unload: fn(),
140+
) {
141+
let mut builder = EventLoop::<u32>::with_user_event();
142+
#[cfg(target_os = "windows")]
143+
builder.with_any_thread(true);
144+
let event_loop = builder.build().unwrap();
145+
146+
let mut app = App {
147+
client_size,
148+
fn_initialize: Some(fn_initialize),
149+
fn_main,
150+
fn_finalize: Some(fn_finalize),
151+
fn_unity_plugin_load,
152+
window: None,
153+
context: None,
154+
last_result: LoopResult::Continue,
155+
};
156+
157+
event_loop.run_app(&mut app).unwrap();
81158

82159
fn_unity_plugin_unload();
83-
fn_finalize(&window, context.deref());
160+
if let (Some(fn_finalize), Some(window), Some(context)) = (
161+
app.fn_finalize.take(),
162+
app.window.as_ref(),
163+
app.context.as_ref(),
164+
) {
165+
fn_finalize(window, context.deref());
166+
}
84167
}

‎unity-native-plugin/src/graphics.rs‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
1-
use std::os::raw::c_int;
21
use crate::define_unity_interface;
32
use crate::interface::UnityInterface;
3+
use std::os::raw::c_int;
44
use unity_native_plugin_sys::*;
55

66
pub type RenderBuffer = unity_native_plugin_sys::UnityRenderBuffer;
@@ -81,6 +81,10 @@ impl UnityGraphics {
8181
}
8282

8383
pub fn reserve_event_id_range(&self, count: c_int) -> c_int {
84-
unsafe { self.interface().ReserveEventIDRange.expect("ReserveEventIDRange is missing")(count) }
84+
unsafe {
85+
self.interface()
86+
.ReserveEventIDRange
87+
.expect("ReserveEventIDRange is missing")(count)
88+
}
8589
}
8690
}

0 commit comments

Comments
 (0)