egui-wgpu: lazily initialize render + surface state

Enable the renderer and surface state initialization to be deferred
until we know that any winit window we created has a valid native window
and enable the surface state to be updated in case the native window
changes.

In particular these changes help with running on Android where winit
windows will only have a valid native window associated with them
between Resumed and Paused lifecycle events, and so surface creation
(and render state initialization) needs to wait until the first
Resumed event, and the surface needs to be dropped/recreated based on
Paused/Resumed events.

eframe/Cargo.toml

@@ -52,7 +52,7 @@ screen_reader = [
 ]
 
 # Use WGPU as the backend instead of glow
-wgpu = ["egui-wgpu"]
+wgpu = ["dep:wgpu", "egui-wgpu"]
 
 
 [dependencies]
@@ -68,6 +68,7 @@ egui-wgpu = { version = "0.18.0", path = "../egui-wgpu", optional = true, featur
 glow = { version = "0.11", optional = true }
 ron = { version = "0.7", optional = true }
 serde = { version = "1", optional = true, features = ["derive"] }
+wgpu = { version = "0.12", optional = true }
 
 # -------------------------------------------
 # native:

eframe/src/native/run.rs

@@ -214,11 +214,25 @@ pub fn run_wgpu(
     // SAFETY: `window` must outlive `painter`.
     #[allow(unsafe_code)]
     let mut painter = unsafe {
-        egui_wgpu::winit::Painter::new(&window, native_options.multisampling.max(1) as _)
+        let mut painter = egui_wgpu::winit::Painter::new(
+            wgpu::Backends::PRIMARY | wgpu::Backends::GL,
+            wgpu::PowerPreference::HighPerformance,
+            wgpu::DeviceDescriptor {
+                label: None,
+                features: wgpu::Features::default(),
+                limits: wgpu::Limits::default(),
+            },
+            wgpu::PresentMode::Fifo,
+            native_options.multisampling.max(1) as _,
+        );
+        #[cfg(not(target_os = "android"))]
+        painter.set_window(Some(&window));
+        painter
     };
 
     let mut integration = epi_integration::EpiIntegration::new(
-        painter.max_texture_side(),
+        &event_loop,
+        painter.max_texture_side().unwrap_or(2048),
         &window,
         storage,
         #[cfg(feature = "glow")]
@@ -304,6 +318,15 @@ pub fn run_wgpu(
             winit::event::Event::RedrawEventsCleared if cfg!(windows) => redraw(),
             winit::event::Event::RedrawRequested(_) if !cfg!(windows) => redraw(),
 
+            #[cfg(target_os = "android")]
+            winit::event::Event::Resumed => unsafe {
+                painter.set_window(Some(&window));
+            },
+            #[cfg(target_os = "android")]
+            winit::event::Event::Paused => unsafe {
+                painter.set_window(None);
+            },
+
             winit::event::Event::WindowEvent { event, .. } => {
                 match &event {
                     winit::event::WindowEvent::Focused(new_focused) => {

egui-wgpu/CHANGELOG.md

@@ -3,7 +3,7 @@ All notable changes to the `egui-wgpu` integration will be noted in this file.
 
 
 ## Unreleased
-
+Enables deferred render + surface state initialization for Android ([#1634](https://github.com/emilk/egui/pull/1634))
 
 ## 0.18.0 - 2022-05-15
 First published version since moving the code into the `egui` repository from <https://github.com/LU15W1R7H/eww>.