fix(windows): cache compiled WebGL programs; WebGPU canvases no longer freeze on resize (#184)

* fix(windows): keep compiled WebGL programs across contexts and launches

ANGLE only reuses linked programs when the app installs EGL_ANDROID_blob_cache
callbacks; its own cache size defaults to 0. Without them every new context
recompiled every shader through the HLSL compiler, which blocked large scenes
for about a second on each visit.

Programs are now kept in memory and under %LOCALAPPDATA%\<exe>\canvas\program-cache
(CANVAS_PROGRAM_CACHE_DIR overrides it; empty keeps it in memory only).

* fix(windows): WebGPU canvases no longer freeze the app when resized

Configuring the surface from the layout pass waited for the GPU without a
limit, while the last presented frame waited on the compositor, which waits
on the UI thread. The resize is now applied from the next getCurrentTexture,
once that frame is done, drawing offscreen until then.

Resizing gets a fresh swapchain, since ResizeBuffers fails while the page
still holds a texture of the old one ("window is in use"). getCurrentTexture
falls back to the offscreen texture instead of returning null.

* chore(windows): rebuild canvasnative.node

* fix(webgl): don't wait for a program's link inside linkProgram

linkProgram queried ACTIVE_UNIFORM_BLOCKS straight after glLinkProgram, which
waits for the link to finish, so ANGLE could never link in the background. The
count is now queried (and cached) the first time uniformBlockBinding needs it.

* feat(webgl): KHR_parallel_shader_compile on Windows

ANGLE compiles and links on worker threads once a context enables it, and
COMPLETION_STATUS_KHR lets the page poll without waiting (three.js's
compileAsync, for example).

* chore(windows): rebuild canvasnative.node

* feat(webgl): KHR_parallel_shader_compile on Android

Exposed when the driver reports GL_KHR_parallel_shader_compile. The GL default
for MAX_SHADER_COMPILER_THREADS_KHR already lets the driver use its own maximum,
so nothing else has to be set. COMPLETION_STATUS_KHR reads back as a boolean.

* chore(ios,android): rebuild CanvasNative.xcframework and canvas-release.aar

* chore: 3.0.0-beta.5

Author: triniwiz

crates/canvas-c/src/webgl/gl.rs

@@ -48,6 +48,7 @@ pub enum WebGLExtensionType {
     WebGLExtensionTypeWEBGL_draw_buffers,
     WebGLExtensionTypeOES_fbo_render_mipmap,
     WebGLExtensionTypeNone,
+    WebGLExtensionTypeKHR_parallel_shader_compile,
 }
 
 impl Into<WebGLExtensionType> for canvas_webgl::prelude::WebGLExtensionType {
@@ -68,6 +69,9 @@ impl Into<WebGLExtensionType> for canvas_webgl::prelude::WebGLExtensionType {
             canvas_webgl::prelude::WebGLExtensionType::EXT_shader_texture_lod => {
                 WebGLExtensionType::WebGLExtensionTypeEXT_shader_texture_lod
             }
+            canvas_webgl::prelude::WebGLExtensionType::KHR_parallel_shader_compile => {
+                WebGLExtensionType::WebGLExtensionTypeKHR_parallel_shader_compile
+            }
             canvas_webgl::prelude::WebGLExtensionType::EXT_texture_filter_anisotropic => {
                 WebGLExtensionType::WebGLExtensionTypeEXT_texture_filter_anisotropic
             }

crates/canvas-c/src/webgpu/gpu_canvas_context.rs

@@ -34,6 +34,11 @@ pub struct SurfaceData {
     pub(crate) error_sink: ErrorSink,
     pub texture_data: TextureData,
     pub(crate) previous_configuration: wgt::SurfaceConfiguration<Vec<wgt::TextureFormat>>,
+    /// Not applied yet; frames go offscreen until it is.
+    pub(crate) pending_configuration: Option<wgt::SurfaceConfiguration<Vec<wgt::TextureFormat>>>,
+    pending_failed: bool,
+    /// The last presented frame's submission, until the GPU finishes it.
+    presented_submission: Option<wgpu_core::SubmissionIndex>,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -91,6 +96,97 @@ fn discard_current_texture(context: &CanvasGPUCanvasContext, operation: &'static
     }
 }
 
+/// Configuring waits for the GPU, and the last presented frame can wait on the compositor, which
+/// waits on this (the UI) thread: so only once that frame is done. Never blocks.
+fn presented_frame_done(surface_data: &mut SurfaceData) -> bool {
+    let Some(index) = surface_data.presented_submission else {
+        return true;
+    };
+    let done = surface_data
+        .device
+        .device
+        .poll(wgt::PollType::Wait {
+            submission_index: Some(index),
+            timeout: Some(std::time::Duration::ZERO),
+        })
+        .is_ok();
+    if done {
+        surface_data.presented_submission = None;
+    }
+    done
+}
+
+/// A resize gets a new swapchain: `ResizeBuffers` fails while the page still holds a texture of the
+/// old one, until it is garbage collected.
+fn configure_surface(
+    surface: &Arc<wgpu_core::instance::Surface>,
+    device: &Arc<wgpu_core::device::Device>,
+    previous: Option<&wgt::SurfaceConfiguration<Vec<wgt::TextureFormat>>>,
+    config: &wgt::SurfaceConfiguration<Vec<wgt::TextureFormat>>,
+) -> Option<wgpu_core::present::ConfigureSurfaceError> {
+    #[cfg(all(target_os = "windows", feature = "d3d"))]
+    if let Some(previous) = previous {
+        let mut resized = previous.clone();
+        resized.width = config.width;
+        resized.height = config.height;
+        if &resized == config {
+            let raw = surface
+                .raw(wgt::Backend::Dx12)
+                .and_then(|raw| raw.as_any().downcast_ref::<wgpu_hal::dx12::Surface>());
+            if let (Some(raw), Some(hal_device)) = (raw, unsafe { Arc::clone(device).as_hal::<wgpu_hal::api::Dx12>() }) {
+                unsafe { wgpu_hal::Surface::unconfigure(raw, &*hal_device) };
+            }
+        }
+    }
+    #[cfg(not(all(target_os = "windows", feature = "d3d")))]
+    let _ = previous;
+    surface.configure(device, config)
+}
+
+/// `false` while pending: not safe to configure yet, or it failed (retried, reported once).
+fn apply_pending_configuration(
+    context: &CanvasGPUCanvasContext,
+    surface: &Arc<wgpu_core::instance::Surface>,
+    operation: &'static str,
+) -> bool {
+    let mut data = context.data.lock();
+    let Some(surface_data) = data.as_mut() else {
+        return true;
+    };
+    if surface_data.pending_configuration.is_none() {
+        return true;
+    }
+    if !presented_frame_done(surface_data) {
+        return false;
+    }
+    let Some(config) = surface_data.pending_configuration.take() else {
+        return true;
+    };
+    match configure_surface(
+        surface,
+        &surface_data.device.device,
+        Some(&surface_data.previous_configuration),
+        &config,
+    ) {
+        None => {
+            surface_data.previous_configuration = config;
+            surface_data.pending_failed = false;
+            context
+                .has_surface_presented
+                .store(false, std::sync::atomic::Ordering::SeqCst);
+            true
+        }
+        Some(cause) => {
+            if !surface_data.pending_failed {
+                surface_data.pending_failed = true;
+                handle_error_fatal(cause, operation);
+            }
+            surface_data.pending_configuration = Some(config);
+            false
+        }
+    }
+}
+
 fn copy_capabilities(capabilities: &SurfaceCapabilities) -> SurfaceCapabilities {
     SurfaceCapabilities {
         formats: capabilities.formats.clone(),
@@ -960,7 +1056,10 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_resize_swap_chain_panel(
     };
     surface_data.texture_data.size.width = width;
     surface_data.texture_data.size.height = height;
-    let mut new_config = surface_data.previous_configuration.clone();
+    let mut new_config = surface_data
+        .pending_configuration
+        .take()
+        .unwrap_or_else(|| surface_data.previous_configuration.clone());
     new_config.width = width;
     new_config.height = height;
 
@@ -992,17 +1091,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_resize_swap_chain_panel(
         data: texture_data,
     });
 
-    let error = surface
-        .as_ref()
-        .and_then(|surface| surface.configure(&surface_data.device.device, &new_config));
-    if let Some(cause) = error {
-        handle_error_fatal(cause, "canvas_native_webgpu_context_resize_swap_chain_panel");
-    } else {
-        context
-            .has_surface_presented
-            .store(false, std::sync::atomic::Ordering::SeqCst);
-        surface_data.previous_configuration = new_config;
-    }
+    surface_data.pending_configuration = Some(new_config);
 }
 
 #[cfg(any(target_os = "ios", target_os = "visionos", target_os = "tvos"))]
@@ -1660,9 +1749,23 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_configure(
         });
     }
 
-    let error = surface_id
-        .as_ref()
-        .and_then(|surface| surface.configure(&device_id, &config));
+    let (presented_submission, previous) = context
+        .data
+        .lock()
+        .as_mut()
+        .filter(|data| Arc::ptr_eq(&data.device.device, &device_id))
+        .map(|data| {
+            let busy = !presented_frame_done(data);
+            (data.presented_submission.filter(|_| busy), Some(data.previous_configuration.clone()))
+        })
+        .unwrap_or_default();
+    let error = match (presented_submission, surface_id.as_ref()) {
+        (None, Some(surface)) => {
+            discard_current_texture(&context, "canvas_native_webgpu_context_configure");
+            configure_surface(surface, &device_id, previous.as_ref(), &config)
+        }
+        _ => None,
+    };
     if let Some(cause) = error {
         handle_error_fatal(cause, "canvas_native_webgpu_context_configure");
         let mut lock = context.data.lock();
@@ -1688,6 +1791,9 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_configure(
                 mip_level_count: 1,
                 sample_count: 1,
             },
+            pending_configuration: presented_submission.map(|_| config.clone()),
+            pending_failed: false,
+            presented_submission,
             previous_configuration: config,
         });
         {
@@ -1766,14 +1872,26 @@ pub extern "C" fn canvas_native_webgpu_context_get_current_texture(
         return offscreen_current_texture(context);
     };
 
+    if !apply_pending_configuration(context, surface_id, "canvas_native_webgpu_context_get_current_texture") {
+        return offscreen_current_texture(context);
+    }
+
     let result = surface_id.get_current_texture();
 
     match result {
         Ok(texture) => {
             match texture.status {
                 SurfaceStatus::Good | SurfaceStatus::Suboptimal | SurfaceStatus::Outdated => {}
-                _ => {
-                    return std::ptr::null_mut();
+                // No image this frame: draw offscreen rather than hand the page nothing.
+                status => {
+                    if matches!(status, SurfaceStatus::Lost) {
+                        if let Some(data) = context.data.lock().as_mut() {
+                            if data.pending_configuration.is_none() {
+                                data.pending_configuration = Some(data.previous_configuration.clone());
+                            }
+                        }
+                    }
+                    return offscreen_current_texture(context);
                 }
             }
 
@@ -1834,7 +1952,7 @@ pub extern "C" fn canvas_native_webgpu_context_get_current_texture(
             handle_error_fatal(cause,
                 "canvas_native_webgpu_context_get_current_texture",
             );
-            std::ptr::null_mut()
+            offscreen_current_texture(context)
         }
     }
 }
@@ -1855,8 +1973,8 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_present_surface(
 
     {
         let lock = context.read_back_texture.lock();
-        let surface_lock = context.data.lock();
-        if let (Some(dst_texture), Some(data)) = (lock.as_ref(), surface_lock.as_ref()) {
+        let mut surface_lock = context.data.lock();
+        if let (Some(dst_texture), Some(data)) = (lock.as_ref(), surface_lock.as_mut()) {
             unsafe {
                 let texture_extent = wgt::Extent3d {
                     width: dst_texture.data.size.width,
@@ -1901,7 +2019,10 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_present_surface(
 
                             let id = encoder.finish(&desc);
 
-                            data.device.queue.queue.id.submit(&[id]);
+                            let index = data.device.queue.queue.id.submit(&[id]);
+                            if texture.surface_id.is_some() {
+                                data.presented_submission = Some(index);
+                            }
                         }
                     }
                 }

crates/canvas-core/src/gpu/gl/egl.rs

@@ -161,6 +161,10 @@ fn load() -> Option<Egl> {
         extensions,
         _gles: gles,
     };
+    if egl.has_extension("EGL_ANDROID_blob_cache") {
+        let set_funcs = egl.instance.get_proc_address("eglSetBlobCacheFuncsANDROID");
+        super::program_cache::install(set_funcs.map_or(std::ptr::null(), |f| f as *const c_void), display.as_ptr());
+    }
     #[cfg(target_os = "windows")]
     protect_immediate_context(&egl);
     Some(egl)

crates/canvas-core/src/gpu/gl/mod.rs

@@ -18,6 +18,9 @@ pub use android::*;
 #[cfg(target_os = "windows")]
 mod egl;
 
+#[cfg(target_os = "windows")]
+mod program_cache;
+
 #[cfg(target_os = "windows")]
 pub use egl::*;