Skip to main content

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            flags: wgpu::InstanceFlags::default(),
57            backend_options: wgpu::BackendOptions::default(),
58            ..wgpu::InstanceDescriptor::new_without_display_handle()
59        });
60
61        cfg_if::cfg_if! {
62            if #[cfg(target_arch = "wasm32")] {
63                let surface = instance.create_surface(view.clone());
64            } else {
65                let surface = instance.create_surface(view.clone());
66            }
67        }
68        let surface = match surface {
69            Ok(surface) => surface,
70            Err(e) => {
71                panic!("Failed to create surface: {e:?}");
72            }
73        };
74
75        let ctx = crate::create_iasdq_context(instance, surface, view_setting.physical_size).await;
76
77        AppSurface {
78            view: Some(view),
79            scale_factor,
80            maximum_frames: 60,
81            ctx,
82            callback_to_app: None,
83            temporary_directory: "",
84            library_directory: "",
85        }
86    }
87
88    pub fn get_view_size(&self) -> (u32, u32) {
89        let physical = self.get_view().inner_size();
90        (physical.width.max(1), physical.height.max(1))
91    }
92
93    pub fn request_redraw(&self) {
94        self.view.as_ref().unwrap().request_redraw();
95    }
96
97    pub fn pre_present_notify(&self) {
98        self.view.as_ref().unwrap().pre_present_notify();
99    }
100}