perf(webgpu): sync wgpu fork to upstream trunk; skip per-draw re-validation in finish

Cargo.toml

@@ -81,7 +81,7 @@ cpal = { path = "crates/vendor/cpal" }
 [workspace.dependencies.wgt]
 package = "wgpu-types"
 git = "https://github.com/triniwiz/wgpu"
-rev = "04e9fef72"
+rev = "87e00d492"
 
 
 
@@ -103,8 +103,8 @@ quick-xml = "0.34"
 skia-safe = { git = "https://github.com/triniwiz/rust-skia", rev = "ab0e73f003ad675277ce2e7fdc1c57fd276ed04c", features = ["textlayout"] }
 itertools = "0.14.0"
 ustr = "1.1.0"
-wgpu-core = { git = "https://github.com/triniwiz/wgpu", rev = "04e9fef72", features = ["wgsl"] }
-wgpu-hal = { git = "https://github.com/triniwiz/wgpu", rev = "04e9fef72" }
+wgpu-core = { git = "https://github.com/triniwiz/wgpu", rev = "87e00d492", features = ["wgsl"] }
+wgpu-hal = { git = "https://github.com/triniwiz/wgpu", rev = "87e00d492" }
 ureq = "2.10.1"
 jni = "0.21.1"
 regex-lite = "0.1.9"

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

@@ -1439,6 +1439,7 @@ pub enum CanvasVertexFormat {
     Float64x4 = 42,
     Unorm10_10_10_2 = 43,
     Unorm8x4Bgra = 44,
+    Snorm10_10_10_2 = 45,
 }
 
 impl CanvasVertexFormat {
@@ -1467,6 +1468,7 @@ impl CanvasVertexFormat {
             | Self::Uint32
             | Self::Sint32
             | Self::Unorm10_10_10_2
+            | Self::Snorm10_10_10_2
             | Self::Unorm8x4Bgra => 4,
             Self::Uint16x4
             | Self::Sint16x4
@@ -1523,6 +1525,7 @@ impl From<wgt::VertexFormat> for CanvasVertexFormat {
             wgt::VertexFormat::Float64x3 => Self::Float64x3,
             wgt::VertexFormat::Float64x4 => Self::Float64x4,
             wgt::VertexFormat::Unorm10_10_10_2 => Self::Unorm10_10_10_2,
+            wgt::VertexFormat::Snorm10_10_10_2 => Self::Snorm10_10_10_2,
             VertexFormat::Uint8 => Self::Uint8,
             VertexFormat::Sint8 => Self::Sint8,
             VertexFormat::Unorm8 => Self::Unorm8,
@@ -1575,6 +1578,7 @@ impl Into<wgt::VertexFormat> for CanvasVertexFormat {
             Self::Float64x3 => wgt::VertexFormat::Float64x3,
             Self::Float64x4 => wgt::VertexFormat::Float64x4,
             Self::Unorm10_10_10_2 => wgt::VertexFormat::Unorm10_10_10_2,
+            Self::Snorm10_10_10_2 => wgt::VertexFormat::Snorm10_10_10_2,
             Self::Uint8 => VertexFormat::Uint8,
             Self::Sint8 => VertexFormat::Sint8,
             Self::Unorm8 => VertexFormat::Unorm8,
@@ -2262,7 +2266,9 @@ impl Into<BindGroupLayoutEntry> for CanvasBindGroupLayoutEntry {
         use std::num::NonZeroU64;
         BindGroupLayoutEntry {
             binding: self.binding,
-            visibility: wgt::ShaderStages::from_bits(self.visibility).unwrap(),
+            visibility: wgt::ShaderStages::from(
+                wgt::ShaderStagesWebGPU::from_bits(self.visibility).unwrap(),
+            ),
             ty: match self.binding_type {
                 CanvasBindingType::Buffer(buffer) => wgt::BindingType::Buffer {
                     ty: buffer.type_.into(),

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

@@ -177,10 +177,10 @@ impl From<wgpu_core::device::DeviceError> for CanvasGPUError {
     }
 }
 
-impl From<wgpu_core::pipeline::CreateRenderPipelineError> for CanvasGPUError {
-    fn from(value: wgpu_core::pipeline::CreateRenderPipelineError) -> Self {
+impl From<wgpu_core::pipeline::CreatePipelineError> for CanvasGPUError {
+    fn from(value: wgpu_core::pipeline::CreatePipelineError) -> Self {
         match value {
-            wgpu_core::pipeline::CreateRenderPipelineError::Device(err) => err.into(),
+            wgpu_core::pipeline::CreatePipelineError::Device(err) => err.into(),
             err => CanvasGPUError::Validation(fmt_err(&err)),
         }
     }
@@ -254,15 +254,6 @@ impl From<wgpu_core::command::ComputePassError> for CanvasGPUError {
     }
 }
 
-impl From<wgpu_core::pipeline::CreateComputePipelineError> for CanvasGPUError {
-    fn from(err: wgpu_core::pipeline::CreateComputePipelineError) -> Self {
-        match err {
-            wgpu_core::pipeline::CreateComputePipelineError::Device(err) => err.into(),
-            err => CanvasGPUError::Validation(fmt_err(&err)),
-        }
-    }
-}
-
 impl From<wgpu_core::binding_model::GetBindGroupLayoutError> for CanvasGPUError {
     fn from(err: wgpu_core::binding_model::GetBindGroupLayoutError) -> Self {
         CanvasGPUError::Validation(fmt_err(&err))

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

@@ -37,20 +37,20 @@ pub enum GPUMapMode {
     Write,
 }
 
-impl Into<wgpu_core::device::HostMap> for GPUMapMode {
-    fn into(self) -> wgpu_core::device::HostMap {
+impl Into<wgt::MapMode> for GPUMapMode {
+    fn into(self) -> wgt::MapMode {
         match self {
-            Self::Read => wgpu_core::device::HostMap::Read,
-            Self::Write => wgpu_core::device::HostMap::Write,
+            Self::Read => wgt::MapMode::Read,
+            Self::Write => wgt::MapMode::Write,
         }
     }
 }
 
-impl From<wgpu_core::device::HostMap> for GPUMapMode {
-    fn from(value: wgpu_core::device::HostMap) -> Self {
+impl From<wgt::MapMode> for GPUMapMode {
+    fn from(value: wgt::MapMode) -> Self {
         match value {
-            wgpu_core::device::HostMap::Read => Self::Read,
-            wgpu_core::device::HostMap::Write => Self::Write,
+            wgt::MapMode::Read => Self::Read,
+            wgt::MapMode::Write => Self::Write,
         }
     }
 }
@@ -151,7 +151,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_buffer_get_mapped_range(
     let range = buffer.buffer.get_mapped_range(offset, size);
 
     match range {
-        Ok((buf, _)) => buf.as_ptr() as *mut c_void,
+        Ok(mapping) => mapping.ptr().as_ptr() as *mut c_void,
         Err(err) => {
             handle_error_fatal(err, "canvas_native_webgpu_buffer_get_mapped_range");
             std::ptr::null_mut()
@@ -174,7 +174,7 @@ pub unsafe fn canvas_native_webgpu_buffer_get_mapped_range_size(
     let range = buffer.buffer.get_mapped_range(offset, size);
 
     match range {
-        Ok((buf, size)) => (buf.as_ptr() as *mut c_void, size),
+        Ok(mapping) => (mapping.ptr().as_ptr() as *mut c_void, mapping.len()),
         Err(err) => {
             handle_error_fatal(err, "canvas_native_webgpu_buffer_get_mapped_range");
             (std::ptr::null_mut(), 0)
@@ -221,47 +221,46 @@ pub extern "C" fn canvas_native_webgpu_buffer_map_async(
     let callback = callback as i64;
     let callback_data = callback_data as i64;
 
-    let op = wgpu_core::resource::BufferMapOperation {
-        host: mode.into(),
-        callback: Some(
-            (Box::new(move |result| {
-                let callback = unsafe {
-                    std::mem::transmute::<
-                        *const i64,
-                        fn(CanvasGPUErrorType, *mut c_char, *mut c_void),
-                    >(callback as _)
-                };
-                let callback_data = callback_data as *mut c_void;
-                if let Err(error) = result {
-                    let error: CanvasGPUError = error.into();
-                    let (typ, msg) = match error {
-                        CanvasGPUError::None => (CanvasGPUErrorType::None, None),
-                        CanvasGPUError::Lost => (CanvasGPUErrorType::Lost, None),
-                        CanvasGPUError::OutOfMemory => (CanvasGPUErrorType::OutOfMemory, None),
-                        CanvasGPUError::Validation(value) => (
-                            CanvasGPUErrorType::Validation,
-                            Some(CString::new(value).unwrap()),
-                        ),
-                        CanvasGPUError::Internal => (CanvasGPUErrorType::Internal, None),
-                    };
-
-                    let msg = msg
-                        .map(|value| value.into_raw())
-                        .unwrap_or(std::ptr::null_mut());
-
-                    callback(typ, msg, callback_data);
-                } else {
-                    callback(
-                        CanvasGPUErrorType::None,
-                        std::ptr::null_mut(),
-                        callback_data,
-                    );
-                }
-            })),
-        ),
-    };
+    let mode: wgt::MapMode = mode.into();
+    let callback: wgpu_core::resource::BufferMapCallback = Box::new(move |result| {
+        let callback = unsafe {
+            std::mem::transmute::<*const i64, fn(CanvasGPUErrorType, *mut c_char, *mut c_void)>(
+                callback as _,
+            )
+        };
+        let callback_data = callback_data as *mut c_void;
+        if let Err(error) = result {
+            let error: CanvasGPUError = error.into();
+            let (typ, msg) = match error {
+                CanvasGPUError::None => (CanvasGPUErrorType::None, None),
+                CanvasGPUError::Lost => (CanvasGPUErrorType::Lost, None),
+                CanvasGPUError::OutOfMemory => (CanvasGPUErrorType::OutOfMemory, None),
+                CanvasGPUError::Validation(value) => (
+                    CanvasGPUErrorType::Validation,
+                    Some(CString::new(value).unwrap()),
+                ),
+                CanvasGPUError::Internal => (CanvasGPUErrorType::Internal, None),
+            };
+
+            let msg = msg
+                .map(|value| value.into_raw())
+                .unwrap_or(std::ptr::null_mut());
+
+            callback(typ, msg, callback_data);
+        } else {
+            callback(
+                CanvasGPUErrorType::None,
+                std::ptr::null_mut(),
+                callback_data,
+            );
+        }
+    });
 
-    if buffer.buffer.map_async(offset, size, op).is_some() {
+    if buffer
+        .buffer
+        .map_async(mode, offset, size, Some(callback))
+        .is_some()
+    {
         poll_mappings(Arc::clone(&buffer.instance));
     }
 }