swamp_wgpu_window/
lib.rs

1/*
2 * Copyright (c) Peter Bjorklund. All rights reserved. https://github.com/swamp/swamp
3 * Licensed under the MIT License. See LICENSE in the project root for license information.
4 */
5use std::default::Default;
6use std::sync::Arc;
7use swamp_app::prelude::{App, Msg, Plugin, ReM, Resource, UpdatePhase};
8use swamp_screen::WindowMessage;
9use tracing::{debug, trace};
10use wgpu::{
11    Adapter, Backends, Device, DeviceDescriptor, Features, Instance, InstanceDescriptor,
12    InstanceFlags, Limits, MemoryHints, Queue, RenderPass, RequestAdapterOptions,
13    RequestDeviceError, Surface, SurfaceConfiguration, SurfaceError,
14};
15use winit::dpi::PhysicalSize;
16use winit::window::Window;
17
18#[derive(Debug, Resource)]
19pub struct WgpuWindow {
20    surface: Arc<Surface<'static>>,
21    device: Arc<Device>,
22    queue: Arc<Queue>,
23
24    config: SurfaceConfiguration,
25}
26
27impl WgpuWindow {
28    pub const fn queue(&self) -> &Arc<Queue> {
29        &self.queue
30    }
31}
32
33pub struct ReceiveAnnoyingAsync {
34    pub device_info: Option<BasicDeviceInfo>,
35}
36
37#[derive(Debug, Resource)]
38pub struct BasicDeviceInfo {
39    pub adapter: Adapter,
40    pub device: Arc<Device>,
41    pub queue: Arc<Queue>,
42    pub surface: Arc<Surface<'static>>,
43    pub physical_surface_size: PhysicalSize<u32>,
44}
45
46pub async fn annoying_async_device_creation(
47    window: Arc<Window>,
48) -> Result<BasicDeviceInfo, RequestDeviceError> {
49    let instance = Instance::new(InstanceDescriptor {
50        flags: InstanceFlags::advanced_debugging(),
51        dx12_shader_compiler: Default::default(),
52        #[cfg(not(target_arch = "wasm32"))]
53        backends: Backends::PRIMARY,
54        #[cfg(target_arch = "wasm32")]
55        backends: Backends::GL,
56
57        gles_minor_version: Default::default(),
58    });
59
60    let surface = instance.create_surface(Arc::clone(&window)).unwrap();
61
62    let adapter = instance
63        .request_adapter(&RequestAdapterOptions {
64            power_preference: Default::default(),
65            compatible_surface: Some(&surface),
66            force_fallback_adapter: false,
67        })
68        .await
69        .unwrap();
70
71    let device_descriptor = DeviceDescriptor {
72        label: None,
73        required_features: Features::empty(), // Specify features as needed
74        required_limits: if cfg!(target_arch = "wasm32") {
75            Limits::downlevel_webgl2_defaults()
76        } else {
77            Limits::default()
78        },
79        memory_hints: MemoryHints::default(), // Use default memory hints
80    };
81
82    let (device, queue) = adapter
83        .request_device(&device_descriptor, None)
84        .await
85        .expect("Failed to request device");
86    trace!("got a device {:?}", device);
87
88    let inner_size = window.inner_size();
89
90    Ok(BasicDeviceInfo {
91        adapter,
92        device: device.into(),
93        queue: queue.into(),
94        surface: surface.into(),
95        physical_surface_size: inner_size,
96    })
97}
98
99fn tick(mut wgpu_window: ReM<WgpuWindow>, window_messages: Msg<WindowMessage>) {
100    for msg in window_messages.iter_previous() {
101        if let WindowMessage::Resized(size) = msg {
102            debug!("resized to {:?}", size);
103            wgpu_window.resize((size.x, size.y))
104        }
105    }
106}
107
108pub struct WgpuWindowPlugin;
109impl Plugin for WgpuWindowPlugin {
110    fn build(&self, _app: &mut App) {}
111
112    fn post_initialization(&self, app: &mut App) {
113        app.insert_resource(WgpuWindow::new(app.resource::<BasicDeviceInfo>()));
114        app.add_system(UpdatePhase::First, tick);
115    }
116}
117
118impl WgpuWindow {
119    pub fn new(info: &BasicDeviceInfo) -> Self {
120        let config = Self::configure_render_surface(info);
121
122        Self {
123            device: Arc::clone(&info.device),
124            config,
125            queue: Arc::clone(&info.queue),
126            surface: Arc::clone(&info.surface),
127        }
128    }
129
130    pub const fn device(&self) -> &Arc<Device> {
131        &self.device
132    }
133
134    fn configure_render_surface(info: &BasicDeviceInfo) -> SurfaceConfiguration {
135        let surface_caps = info.surface.get_capabilities(&info.adapter);
136        let surface_format = surface_caps
137            .formats
138            .iter()
139            .copied()
140            .find(|f| f.is_srgb())
141            .unwrap_or(surface_caps.formats[0]);
142
143        let config = wgpu::SurfaceConfiguration {
144            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
145            format: surface_format,
146            width: info.physical_surface_size.width,
147            height: info.physical_surface_size.height,
148            present_mode: surface_caps.present_modes[0],
149            alpha_mode: surface_caps.alpha_modes[0],
150            desired_maximum_frame_latency: 2,
151            view_formats: vec![],
152        };
153
154        info.surface.configure(&info.device, &config);
155
156        let present_mode = surface_caps.present_modes[0];
157        let alpha_mode = surface_caps.alpha_modes[0];
158        trace!(
159            "found surface format {:?} {:?} {:?}",
160            surface_format,
161            present_mode,
162            alpha_mode
163        );
164
165        config
166    }
167
168    pub fn texture_format(&self) -> wgpu::TextureFormat {
169        self.config.format
170    }
171
172    pub fn resize(&mut self, new_size: (u16, u16)) {
173        let width = new_size.0 as usize;
174        let height = new_size.1 as usize;
175
176        if width == 0 || height == 0 {
177            return;
178        }
179
180        self.config.width = width as u32;
181        self.config.height = height as u32;
182        self.surface.configure(&self.device, &self.config);
183    }
184
185    pub fn render(
186        &self,
187        clear_color: wgpu::Color,
188        mut render_fn: impl FnMut(&mut RenderPass),
189    ) -> Result<(), SurfaceError> {
190        // Gets a new texture from the swap chain
191        let surface_texture = self.surface.get_current_texture()?;
192        let texture_view = surface_texture
193            .texture
194            .create_view(&wgpu::TextureViewDescriptor::default());
195
196        let mut encoder = self
197            .device
198            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
199                label: Some("Render Encoder"),
200            });
201
202        // THIS SCOPE IS ABSOLUTELY NEEDED FOR THE RENDER PASS - DO NOT REMOVE
203        {
204            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
205                label: Some("Render Pass"),
206                color_attachments: &[
207                    // This is what @location(0) in the fragment shader targets
208                    Some(wgpu::RenderPassColorAttachment {
209                        view: &texture_view,
210                        resolve_target: None,
211                        ops: wgpu::Operations {
212                            load: wgpu::LoadOp::Clear(clear_color),
213                            store: wgpu::StoreOp::Store,
214                        },
215                    }),
216                ],
217                depth_stencil_attachment: None,
218                timestamp_writes: None,
219                occlusion_query_set: None,
220            });
221
222            render_fn(&mut render_pass);
223        }
224
225        self.queue.submit(std::iter::once(encoder.finish()));
226
227        surface_texture.present();
228
229        Ok(())
230    }
231}
swamp_wgpu_window/lib.rs

swamp_wgpu_window/
lib.rs
