app_surface/
app_surface_use_winit.rs

1use std::sync::Arc;
2use winit::window::Window;
3
4pub struct AppSurface {
5    pub view: Option<Arc<Window>>,
6    pub scale_factor: f32,
7    pub maximum_frames: i32,
8    pub ctx: crate::IASDQContext,
9    pub callback_to_app: Option<extern "C" fn(arg: i32)>,
10    pub temporary_directory: &'static str,
11    pub library_directory: &'static str,
12}
13
14#[derive(Default)]
15struct ViewSetting {
16    view: Option<Arc<Window>>,
17    scale_factor: f32,
18    physical_size: (u32, u32),
19}
20
21impl AppSurface {
22    #[allow(clippy::needless_update)]
23    pub async fn new(view: Arc<Window>) -> Self {
24        let scale_factor = view.scale_factor() as f32;
25        let mut physical_size = view.inner_size();
26        physical_size.width = physical_size.width.max(1);
27        physical_size.height = physical_size.height.max(1);
28        let view_setting = ViewSetting {
29            scale_factor,
30            physical_size: (physical_size.width, physical_size.height),
31            view: Some(view),
32            ..Default::default()
33        };
34
35        Self::create(view_setting).await
36    }
37
38    pub fn get_view(&self) -> &Window {
39        self.view.as_ref().unwrap()
40    }
41
42    #[allow(unused_variables)]
43    async fn create(view_setting: ViewSetting) -> Self {
44        let view = view_setting.view.unwrap();
45
46        let scale_factor = view_setting.scale_factor;
47        let default_backends = if cfg!(feature = "webgl") {
48            wgpu::Backends::GL
49        } else {
50            wgpu::Backends::PRIMARY
51        };
52        log::info!("{:?}", default_backends);
53        let backends = wgpu::Backends::from_env().unwrap_or(default_backends);
54        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
55            backends,
56            ..Default::default()
57        });
58
59        cfg_if::cfg_if! {
60            if #[cfg(target_arch = "wasm32")] {
61                let surface = instance.create_surface(view.clone());
62            } else {
63                let surface = instance.create_surface(view.clone());
64            }
65        }
66        let surface = match surface {
67            Ok(surface) => surface,
68            Err(e) => {
69                panic!("Failed to create surface: {e:?}");
70            }
71        };
72
73        let ctx = crate::create_iasdq_context(instance, surface, view_setting.physical_size).await;
74
75        AppSurface {
76            view: Some(view),
77            scale_factor,
78            maximum_frames: 60,
79            ctx,
80            callback_to_app: None,
81            temporary_directory: "",
82            library_directory: "",
83        }
84    }
85
86    pub fn get_view_size(&self) -> (u32, u32) {
87        let physical = self.get_view().inner_size();
88        (physical.width.max(1), physical.height.max(1))
89    }
90
91    pub fn request_redraw(&self) {
92        self.view.as_ref().unwrap().request_redraw();
93    }
94
95    pub fn pre_present_notify(&self) {
96        self.view.as_ref().unwrap().pre_present_notify();
97    }
98}