diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index ceac39e7a9..8f5e65d628 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -17,8 +17,6 @@ jobs:
run: cargo build --package tour --target wasm32-unknown-unknown
- name: Check compilation of `todos` example
run: cargo build --package todos --target wasm32-unknown-unknown
- - name: Check compilation of `integration` example
- run: cargo build --package integration --target wasm32-unknown-unknown
widget:
runs-on: ubuntu-latest
diff --git a/Cargo.toml b/Cargo.toml
index 60773da01d..06f7d19858 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -172,11 +172,11 @@ unicode-segmentation = "1.0"
wasm-bindgen-futures = "0.4"
wasm-timer = "0.2"
web-sys = "=0.3.67"
-web-time = "0.2"
+web-time = "1.1"
wgpu = "0.19"
winapi = "0.3"
window_clipboard = "0.4.1"
-winit = { git = "https://github.com/iced-rs/winit.git", rev = "592bd152f6d5786fae7d918532d7db752c0d164f" }
+winit = { git = "https://github.com/iced-rs/winit.git", rev = "8affa522bc6dcc497d332a28c03491d22a22f5a7" }
[workspace.lints.rust]
rust_2018_idioms = "forbid"
diff --git a/examples/integration/README.md b/examples/integration/README.md
index aa3a6e94ad..bac0640cd5 100644
--- a/examples/integration/README.md
+++ b/examples/integration/README.md
@@ -10,25 +10,8 @@ The __[`main`]__ file contains all the code of the example.
You can run it with `cargo run`:
```
-cargo run --package integration_wgpu
+cargo run --package integration
```
-### How to run this example with WebGL backend
-NOTE: Currently, WebGL backend is still experimental, so expect bugs.
-
-```sh
-# 0. Install prerequisites
-cargo install wasm-bindgen-cli https
-# 1. cd to the current folder
-# 2. Compile wasm module
-cargo build -p integration_wgpu --target wasm32-unknown-unknown
-# 3. Invoke wasm-bindgen
-wasm-bindgen ../../target/wasm32-unknown-unknown/debug/integration_wgpu.wasm --out-dir . --target web --no-typescript
-# 4. run http server
-http
-# 5. Open 127.0.0.1:8000 in browser
-```
-
-
[`main`]: src/main.rs
[`wgpu`]: https://github.com/gfx-rs/wgpu
diff --git a/examples/integration/index.html b/examples/integration/index.html
deleted file mode 100644
index 920bc4a063..0000000000
--- a/examples/integration/index.html
+++ /dev/null
@@ -1,21 +0,0 @@
-
-
-
-
- Iced - wgpu + WebGL integration
-
-
- integration_wgpu
-
-
-
-
-
diff --git a/examples/integration/src/main.rs b/examples/integration/src/main.rs
index c28332100d..e1c7d62fbc 100644
--- a/examples/integration/src/main.rs
+++ b/examples/integration/src/main.rs
@@ -18,305 +18,342 @@ use iced_winit::winit;
use iced_winit::Clipboard;
use winit::{
- event::{Event, WindowEvent},
+ event::WindowEvent,
event_loop::{ControlFlow, EventLoop},
keyboard::ModifiersState,
};
use std::sync::Arc;
-#[cfg(target_arch = "wasm32")]
-use wasm_bindgen::JsCast;
-#[cfg(target_arch = "wasm32")]
-use web_sys::HtmlCanvasElement;
-#[cfg(target_arch = "wasm32")]
-use winit::platform::web::WindowBuilderExtWebSys;
-
-pub fn main() -> Result<(), Box> {
- #[cfg(target_arch = "wasm32")]
- let canvas_element = {
- console_log::init().expect("Initialize logger");
-
- std::panic::set_hook(Box::new(console_error_panic_hook::hook));
-
- web_sys::window()
- .and_then(|win| win.document())
- .and_then(|doc| doc.get_element_by_id("iced_canvas"))
- .and_then(|element| element.dyn_into::().ok())
- .expect("Get canvas element")
- };
-
- #[cfg(not(target_arch = "wasm32"))]
+pub fn main() -> Result<(), winit::error::EventLoopError> {
tracing_subscriber::fmt::init();
// Initialize winit
let event_loop = EventLoop::new()?;
- #[cfg(target_arch = "wasm32")]
- let window = winit::window::WindowBuilder::new()
- .with_canvas(Some(canvas_element))
- .build(&event_loop)?;
-
- #[cfg(not(target_arch = "wasm32"))]
- let window = winit::window::Window::new(&event_loop)?;
-
- let window = Arc::new(window);
-
- let physical_size = window.inner_size();
- let mut viewport = Viewport::with_physical_size(
- Size::new(physical_size.width, physical_size.height),
- window.scale_factor(),
- );
- let mut cursor_position = None;
- let mut modifiers = ModifiersState::default();
- let mut clipboard = Clipboard::connect(&window);
-
- // Initialize wgpu
- #[cfg(target_arch = "wasm32")]
- let default_backend = wgpu::Backends::GL;
- #[cfg(not(target_arch = "wasm32"))]
- let default_backend = wgpu::Backends::PRIMARY;
-
- let backend =
- wgpu::util::backend_bits_from_env().unwrap_or(default_backend);
-
- let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
- backends: backend,
- ..Default::default()
- });
- let surface = instance.create_surface(window.clone())?;
-
- let (format, adapter, device, queue) =
- futures::futures::executor::block_on(async {
- let adapter = wgpu::util::initialize_adapter_from_env_or_default(
- &instance,
- Some(&surface),
- )
- .await
- .expect("Create adapter");
-
- let adapter_features = adapter.features();
-
- #[cfg(target_arch = "wasm32")]
- let needed_limits = wgpu::Limits::downlevel_webgl2_defaults()
- .using_resolution(adapter.limits());
-
- #[cfg(not(target_arch = "wasm32"))]
- let needed_limits = wgpu::Limits::default();
-
- let capabilities = surface.get_capabilities(&adapter);
-
- let (device, queue) = adapter
- .request_device(
- &wgpu::DeviceDescriptor {
- label: None,
- required_features: adapter_features
- & wgpu::Features::default(),
- required_limits: needed_limits,
+ #[allow(clippy::large_enum_variant)]
+ enum Runner {
+ Loading,
+ Ready {
+ window: Arc,
+ device: wgpu::Device,
+ queue: wgpu::Queue,
+ surface: wgpu::Surface<'static>,
+ format: wgpu::TextureFormat,
+ engine: Engine,
+ renderer: Renderer,
+ scene: Scene,
+ state: program::State,
+ cursor_position: Option>,
+ clipboard: Clipboard,
+ viewport: Viewport,
+ modifiers: ModifiersState,
+ resized: bool,
+ debug: Debug,
+ },
+ }
+
+ impl winit::application::ApplicationHandler for Runner {
+ fn resumed(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
+ if let Self::Loading = self {
+ let window = Arc::new(
+ event_loop
+ .create_window(
+ winit::window::WindowAttributes::default(),
+ )
+ .expect("Create window"),
+ );
+
+ let physical_size = window.inner_size();
+ let viewport = Viewport::with_physical_size(
+ Size::new(physical_size.width, physical_size.height),
+ window.scale_factor(),
+ );
+ let clipboard = Clipboard::connect(&window);
+
+ let backend =
+ wgpu::util::backend_bits_from_env().unwrap_or_default();
+
+ let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
+ backends: backend,
+ ..Default::default()
+ });
+ let surface = instance
+ .create_surface(window.clone())
+ .expect("Create window surface");
+
+ let (format, adapter, device, queue) =
+ futures::futures::executor::block_on(async {
+ let adapter =
+ wgpu::util::initialize_adapter_from_env_or_default(
+ &instance,
+ Some(&surface),
+ )
+ .await
+ .expect("Create adapter");
+
+ let adapter_features = adapter.features();
+
+ let capabilities = surface.get_capabilities(&adapter);
+
+ let (device, queue) = adapter
+ .request_device(
+ &wgpu::DeviceDescriptor {
+ label: None,
+ required_features: adapter_features
+ & wgpu::Features::default(),
+ required_limits: wgpu::Limits::default(),
+ },
+ None,
+ )
+ .await
+ .expect("Request device");
+
+ (
+ capabilities
+ .formats
+ .iter()
+ .copied()
+ .find(wgpu::TextureFormat::is_srgb)
+ .or_else(|| {
+ capabilities.formats.first().copied()
+ })
+ .expect("Get preferred format"),
+ adapter,
+ device,
+ queue,
+ )
+ });
+
+ surface.configure(
+ &device,
+ &wgpu::SurfaceConfiguration {
+ usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+ format,
+ width: physical_size.width,
+ height: physical_size.height,
+ present_mode: wgpu::PresentMode::AutoVsync,
+ alpha_mode: wgpu::CompositeAlphaMode::Auto,
+ view_formats: vec![],
+ desired_maximum_frame_latency: 2,
},
- None,
- )
- .await
- .expect("Request device");
-
- (
- capabilities
- .formats
- .iter()
- .copied()
- .find(wgpu::TextureFormat::is_srgb)
- .or_else(|| capabilities.formats.first().copied())
- .expect("Get preferred format"),
- adapter,
+ );
+
+ // Initialize scene and GUI controls
+ let scene = Scene::new(&device, format);
+ let controls = Controls::new();
+
+ // Initialize iced
+ let mut debug = Debug::new();
+ let engine =
+ Engine::new(&adapter, &device, &queue, format, None);
+ let mut renderer = Renderer::new(
+ &device,
+ &engine,
+ Font::default(),
+ Pixels::from(16),
+ );
+
+ let state = program::State::new(
+ controls,
+ viewport.logical_size(),
+ &mut renderer,
+ &mut debug,
+ );
+
+ // You should change this if you want to render continuously
+ event_loop.set_control_flow(ControlFlow::Wait);
+
+ *self = Self::Ready {
+ window,
+ device,
+ queue,
+ surface,
+ format,
+ engine,
+ renderer,
+ scene,
+ state,
+ cursor_position: None,
+ modifiers: ModifiersState::default(),
+ clipboard,
+ viewport,
+ resized: false,
+ debug,
+ };
+ }
+ }
+
+ fn window_event(
+ &mut self,
+ event_loop: &winit::event_loop::ActiveEventLoop,
+ _window_id: winit::window::WindowId,
+ event: WindowEvent,
+ ) {
+ let Self::Ready {
+ window,
device,
queue,
- )
- });
-
- surface.configure(
- &device,
- &wgpu::SurfaceConfiguration {
- usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
- format,
- width: physical_size.width,
- height: physical_size.height,
- present_mode: wgpu::PresentMode::AutoVsync,
- alpha_mode: wgpu::CompositeAlphaMode::Auto,
- view_formats: vec![],
- desired_maximum_frame_latency: 2,
- },
- );
-
- let mut resized = false;
-
- // Initialize scene and GUI controls
- let scene = Scene::new(&device, format);
- let controls = Controls::new();
-
- // Initialize iced
- let mut debug = Debug::new();
- let mut engine = Engine::new(&adapter, &device, &queue, format, None);
- let mut renderer =
- Renderer::new(&device, &engine, Font::default(), Pixels::from(16));
-
- let mut state = program::State::new(
- controls,
- viewport.logical_size(),
- &mut renderer,
- &mut debug,
- );
-
- // Run event loop
- event_loop.run(move |event, window_target| {
- // You should change this if you want to render continuously
- window_target.set_control_flow(ControlFlow::Wait);
-
- match event {
- Event::WindowEvent {
- event: WindowEvent::RedrawRequested,
- ..
- } => {
- if resized {
- let size = window.inner_size();
-
- viewport = Viewport::with_physical_size(
- Size::new(size.width, size.height),
- window.scale_factor(),
- );
-
- surface.configure(
- &device,
- &wgpu::SurfaceConfiguration {
- format,
- usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
- width: size.width,
- height: size.height,
- present_mode: wgpu::PresentMode::AutoVsync,
- alpha_mode: wgpu::CompositeAlphaMode::Auto,
- view_formats: vec![],
- desired_maximum_frame_latency: 2,
- },
- );
-
- resized = false;
- }
-
- match surface.get_current_texture() {
- Ok(frame) => {
- let mut encoder = device.create_command_encoder(
- &wgpu::CommandEncoderDescriptor { label: None },
+ surface,
+ format,
+ engine,
+ renderer,
+ scene,
+ state,
+ viewport,
+ cursor_position,
+ modifiers,
+ clipboard,
+ resized,
+ debug,
+ } = self
+ else {
+ return;
+ };
+
+ match event {
+ WindowEvent::RedrawRequested => {
+ if *resized {
+ let size = window.inner_size();
+
+ *viewport = Viewport::with_physical_size(
+ Size::new(size.width, size.height),
+ window.scale_factor(),
);
- let program = state.program();
-
- let view = frame.texture.create_view(
- &wgpu::TextureViewDescriptor::default(),
+ surface.configure(
+ device,
+ &wgpu::SurfaceConfiguration {
+ format: *format,
+ usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+ width: size.width,
+ height: size.height,
+ present_mode: wgpu::PresentMode::AutoVsync,
+ alpha_mode: wgpu::CompositeAlphaMode::Auto,
+ view_formats: vec![],
+ desired_maximum_frame_latency: 2,
+ },
);
- {
- // We clear the frame
- let mut render_pass = Scene::clear(
- &view,
- &mut encoder,
- program.background_color(),
+ *resized = false;
+ }
+
+ match surface.get_current_texture() {
+ Ok(frame) => {
+ let mut encoder = device.create_command_encoder(
+ &wgpu::CommandEncoderDescriptor { label: None },
);
- // Draw the scene
- scene.draw(&mut render_pass);
- }
+ let program = state.program();
- // And then iced on top
- renderer.present(
- &mut engine,
- &device,
- &queue,
- &mut encoder,
- None,
- frame.texture.format(),
- &view,
- &viewport,
- &debug.overlay(),
- );
+ let view = frame.texture.create_view(
+ &wgpu::TextureViewDescriptor::default(),
+ );
+
+ {
+ // We clear the frame
+ let mut render_pass = Scene::clear(
+ &view,
+ &mut encoder,
+ program.background_color(),
+ );
+
+ // Draw the scene
+ scene.draw(&mut render_pass);
+ }
+
+ // And then iced on top
+ renderer.present(
+ engine,
+ device,
+ queue,
+ &mut encoder,
+ None,
+ frame.texture.format(),
+ &view,
+ viewport,
+ &debug.overlay(),
+ );
- // Then we submit the work
- queue.submit(Some(encoder.finish()));
- frame.present();
+ // Then we submit the work
+ engine.submit(queue, encoder);
+ frame.present();
- // Update the mouse cursor
- window.set_cursor_icon(
- iced_winit::conversion::mouse_interaction(
- state.mouse_interaction(),
- ),
- );
- }
- Err(error) => match error {
- wgpu::SurfaceError::OutOfMemory => {
- panic!(
- "Swapchain error: {error}. \
- Rendering cannot continue."
- )
- }
- _ => {
- // Try rendering again next frame.
- window.request_redraw();
+ // Update the mouse cursor
+ window.set_cursor(
+ iced_winit::conversion::mouse_interaction(
+ state.mouse_interaction(),
+ ),
+ );
}
- },
- }
- }
- Event::WindowEvent { event, .. } => {
- match event {
- WindowEvent::CursorMoved { position, .. } => {
- cursor_position = Some(position);
- }
- WindowEvent::ModifiersChanged(new_modifiers) => {
- modifiers = new_modifiers.state();
- }
- WindowEvent::Resized(_) => {
- resized = true;
- }
- WindowEvent::CloseRequested => {
- window_target.exit();
+ Err(error) => match error {
+ wgpu::SurfaceError::OutOfMemory => {
+ panic!(
+ "Swapchain error: {error}. \
+ Rendering cannot continue."
+ )
+ }
+ _ => {
+ // Try rendering again next frame.
+ window.request_redraw();
+ }
+ },
}
- _ => {}
}
-
- // Map window event to iced event
- if let Some(event) = iced_winit::conversion::window_event(
- window::Id::MAIN,
- event,
- window.scale_factor(),
- modifiers,
- ) {
- state.queue_event(event);
+ WindowEvent::CursorMoved { position, .. } => {
+ *cursor_position = Some(position);
+ }
+ WindowEvent::ModifiersChanged(new_modifiers) => {
+ *modifiers = new_modifiers.state();
}
+ WindowEvent::Resized(_) => {
+ *resized = true;
+ }
+ WindowEvent::CloseRequested => {
+ event_loop.exit();
+ }
+ _ => {}
}
- _ => {}
- }
- // If there are events pending
- if !state.is_queue_empty() {
- // We update iced
- let _ = state.update(
- viewport.logical_size(),
- cursor_position
- .map(|p| {
- conversion::cursor_position(p, viewport.scale_factor())
- })
- .map(mouse::Cursor::Available)
- .unwrap_or(mouse::Cursor::Unavailable),
- &mut renderer,
- &Theme::Dark,
- &renderer::Style {
- text_color: Color::WHITE,
- },
- &mut clipboard,
- &mut debug,
- );
-
- // and request a redraw
- window.request_redraw();
+ // Map window event to iced event
+ if let Some(event) = iced_winit::conversion::window_event(
+ window::Id::MAIN,
+ event,
+ window.scale_factor(),
+ *modifiers,
+ ) {
+ state.queue_event(event);
+ }
+
+ // If there are events pending
+ if !state.is_queue_empty() {
+ // We update iced
+ let _ = state.update(
+ viewport.logical_size(),
+ cursor_position
+ .map(|p| {
+ conversion::cursor_position(
+ p,
+ viewport.scale_factor(),
+ )
+ })
+ .map(mouse::Cursor::Available)
+ .unwrap_or(mouse::Cursor::Unavailable),
+ renderer,
+ &Theme::Dark,
+ &renderer::Style {
+ text_color: Color::WHITE,
+ },
+ clipboard,
+ debug,
+ );
+
+ // and request a redraw
+ window.request_redraw();
+ }
}
- })?;
+ }
- Ok(())
+ let mut runner = Runner::Loading;
+ event_loop.run_app(&mut runner)
}
diff --git a/src/application.rs b/src/application.rs
index 9197834b23..d12ba73dcc 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -212,26 +212,11 @@ where
..crate::graphics::Settings::default()
};
- let run = crate::shell::application::run::<
+ Ok(crate::shell::application::run::<
Instance,
Self::Executor,
::Compositor,
- >(settings.into(), renderer_settings);
-
- #[cfg(target_arch = "wasm32")]
- {
- use crate::futures::FutureExt;
- use iced_futures::backend::wasm::wasm_bindgen::Executor;
-
- Executor::new()
- .expect("Create Wasm executor")
- .spawn(run.map(|_| ()));
-
- Ok(())
- }
-
- #[cfg(not(target_arch = "wasm32"))]
- Ok(crate::futures::executor::block_on(run)?)
+ >(settings.into(), renderer_settings)?)
}
}
diff --git a/wgpu/src/lib.rs b/wgpu/src/lib.rs
index ad8ac59195..1fbdbe9a3d 100644
--- a/wgpu/src/lib.rs
+++ b/wgpu/src/lib.rs
@@ -67,8 +67,6 @@ use crate::core::{
use crate::graphics::text::{Editor, Paragraph};
use crate::graphics::Viewport;
-use std::cell::RefCell;
-
/// A [`wgpu`] graphics renderer for [`iced`].
///
/// [`wgpu`]: https://github.com/gfx-rs/wgpu-rs
@@ -84,7 +82,7 @@ pub struct Renderer {
// TODO: Centralize all the image feature handling
#[cfg(any(feature = "svg", feature = "image"))]
- image_cache: RefCell,
+ image_cache: std::cell::RefCell,
}
impl Renderer {
@@ -103,7 +101,9 @@ impl Renderer {
text_storage: text::Storage::new(),
#[cfg(any(feature = "svg", feature = "image"))]
- image_cache: RefCell::new(_engine.create_image_cache(_device)),
+ image_cache: std::cell::RefCell::new(
+ _engine.create_image_cache(_device),
+ ),
}
}
diff --git a/winit/Cargo.toml b/winit/Cargo.toml
index dccb7c07f0..6d3dddde8e 100644
--- a/winit/Cargo.toml
+++ b/winit/Cargo.toml
@@ -25,6 +25,7 @@ wayland-csd-adwaita = ["winit/wayland-csd-adwaita"]
multi-window = ["iced_runtime/multi-window"]
[dependencies]
+iced_futures.workspace = true
iced_graphics.workspace = true
iced_runtime.workspace = true
@@ -32,6 +33,7 @@ log.workspace = true
rustc-hash.workspace = true
thiserror.workspace = true
tracing.workspace = true
+wasm-bindgen-futures.workspace = true
window_clipboard.workspace = true
winit.workspace = true
diff --git a/winit/src/application.rs b/winit/src/application.rs
index a447c9da05..3e8c8f4ec1 100644
--- a/winit/src/application.rs
+++ b/winit/src/application.rs
@@ -22,7 +22,9 @@ use crate::runtime::{Command, Debug};
use crate::{Clipboard, Error, Proxy, Settings};
use futures::channel::mpsc;
+use futures::channel::oneshot;
+use std::borrow::Cow;
use std::mem::ManuallyDrop;
use std::sync::Arc;
@@ -129,7 +131,7 @@ pub fn default(theme: &Theme) -> Appearance {
/// Runs an [`Application`] with an executor, compositor, and the provided
/// settings.
-pub async fn run(
+pub fn run(
settings: Settings,
graphics_settings: graphics::Settings,
) -> Result<(), Error>
@@ -141,12 +143,12 @@ where
{
use futures::task;
use futures::Future;
- use winit::event_loop::EventLoopBuilder;
+ use winit::event_loop::EventLoop;
let mut debug = Debug::new();
debug.startup_started();
- let event_loop = EventLoopBuilder::with_user_event()
+ let event_loop = EventLoop::with_user_event()
.build()
.expect("Create event loop");
@@ -165,102 +167,267 @@ where
runtime.enter(|| A::new(flags))
};
- #[cfg(target_arch = "wasm32")]
- let target = settings.window.platform_specific.target.clone();
+ let id = settings.id;
+ let title = application.title();
- let should_be_visible = settings.window.visible;
- let exit_on_close_request = settings.window.exit_on_close_request;
+ let (boot_sender, boot_receiver) = oneshot::channel();
+ let (event_sender, event_receiver) = mpsc::unbounded();
+ let (control_sender, control_receiver) = mpsc::unbounded();
- let builder = conversion::window_settings(
- settings.window,
- &application.title(),
- event_loop.primary_monitor(),
- settings.id,
- )
- .with_visible(false);
+ let instance = Box::pin(run_instance::(
+ application,
+ runtime,
+ proxy,
+ debug,
+ boot_receiver,
+ event_receiver,
+ control_sender,
+ init_command,
+ settings.fonts,
+ ));
- log::debug!("Window builder: {builder:#?}");
+ let context = task::Context::from_waker(task::noop_waker_ref());
+
+ struct Runner {
+ instance: std::pin::Pin>,
+ context: task::Context<'static>,
+ boot: Option>,
+ sender: mpsc::UnboundedSender>,
+ receiver: mpsc::UnboundedReceiver,
+ error: Option,
+ #[cfg(target_arch = "wasm32")]
+ is_booted: std::rc::Rc>,
+ #[cfg(target_arch = "wasm32")]
+ queued_events: Vec>,
+ }
- let window = Arc::new(
- builder
- .build(&event_loop)
- .map_err(Error::WindowCreationFailed)?,
- );
+ struct BootConfig {
+ sender: oneshot::Sender>,
+ id: Option,
+ title: String,
+ window_settings: window::Settings,
+ graphics_settings: graphics::Settings,
+ }
- #[cfg(target_arch = "wasm32")]
+ let runner = Runner {
+ instance,
+ context,
+ boot: Some(BootConfig {
+ sender: boot_sender,
+ id,
+ title,
+ window_settings: settings.window,
+ graphics_settings,
+ }),
+ sender: event_sender,
+ receiver: control_receiver,
+ error: None,
+ #[cfg(target_arch = "wasm32")]
+ is_booted: std::rc::Rc::new(std::cell::RefCell::new(false)),
+ #[cfg(target_arch = "wasm32")]
+ queued_events: Vec::new(),
+ };
+
+ impl winit::application::ApplicationHandler
+ for Runner
+ where
+ F: Future