chore: use webgpu-core

Cargo.toml

@@ -22,3 +22,8 @@ opt-level = 3
 debug = false
 incremental = false
 strip = true
+
+
+[workspace.dependencies.wgt]
+package = "wgpu-types"
+version = "0.20.0"

crates/canvas-c/Cargo.toml

@@ -16,7 +16,8 @@ parking_lot = "0.12.0"
 ureq = { version = "2.9.6", features = ["gzip"] }
 bytes = "1.5.0"
 log = { version = "0.4.20"}
-wgpu = "0.20.1"
+wgpu-core = {version = "0.21.0", features = ["wgsl", "metal"]}
+wgpu-types = "0.20.0"
 futures = "0.3"
 
 [target.'cfg(target_vendor="apple")'.dependencies]

crates/canvas-c/src/lib.rs

@@ -3,14 +3,13 @@
 use std::borrow::Cow;
 use std::ffi::{CStr, CString};
 use std::io::{Read, Write};
-use std::os::raw::{c_char, c_int, c_uint};
 use std::os::raw::c_ulong;
 use std::os::raw::c_void;
+use std::os::raw::{c_char, c_int, c_uint};
 use std::sync::Arc;
 
 use parking_lot::{MappedRwLockReadGuard, MappedRwLockWriteGuard, RwLock};
 
-use canvas_2d::context::{Context, ContextWrapper};
 use canvas_2d::context::compositing::composite_operation_type::CompositeOperationType;
 use canvas_2d::context::drawing_paths::fill_rule::FillRule;
 use canvas_2d::context::fill_and_stroke_styles::paint::paint_style_set_color_with_string;
@@ -20,6 +19,7 @@ use canvas_2d::context::line_styles::line_cap::LineCap;
 use canvas_2d::context::line_styles::line_join::LineJoin;
 pub use canvas_2d::context::text_styles::text_align::TextAlign;
 use canvas_2d::context::text_styles::text_direction::TextDirection;
+use canvas_2d::context::{Context, ContextWrapper};
 use canvas_2d::utils::color::{parse_color, to_parsed_color};
 use canvas_2d::utils::image::{
     from_backend_texture, from_bitmap_slice, from_image_slice, from_image_slice_encoded,
@@ -360,13 +360,12 @@ impl CanvasRenderingContext2D {
 
     pub fn render(&self) {
         self.gl_context.make_current();
-        
+
         #[cfg(target_os = "ios")]
         {
             self.gl_context.swap_buffers();
         }
 
-
         #[cfg(not(target_os = "ios"))]
         {
             {
@@ -2411,7 +2410,7 @@ pub extern "C" fn canvas_native_context_draw_image_context(
     source.make_current();
     // gl context is shared so snapshots should work
     let mut source_ctx = source.get_context_mut();
-    
+
     #[cfg(any(target_os = "ios", target_os = "macos"))]
     {
         let snapshot = source_ctx.snapshot();
@@ -2422,15 +2421,7 @@ pub extern "C" fn canvas_native_context_draw_image_context(
 
             if let Some(image) = from_backend_texture(&mut ctx, &image, origin, info) {
                 ctx.draw_image_src_xywh_dst_xywh(
-                    &image,
-                    sx,
-                    sy,
-                    s_width,
-                    s_height,
-                    dx,
-                    dy,
-                    d_width,
-                    d_height,
+                    &image, sx, sy, s_width, s_height, dx, dy, d_width, d_height,
                 );
             }
         }
@@ -2451,15 +2442,7 @@ pub extern "C" fn canvas_native_context_draw_image_context(
             let context = unsafe { &mut *context };
             context.make_current();
             context.get_context_mut().draw_image_src_xywh_dst_xywh(
-                &image,
-                sx,
-                sy,
-                s_width,
-                s_height,
-                dx,
-                dy,
-                d_width,
-                d_height,
+                &image, sx, sy, s_width, s_height, dx, dy, d_width, d_height,
             );
         }
     }
@@ -2590,21 +2573,9 @@ pub extern "C" fn canvas_native_context_draw_image_webgl(
 
     let ptr = pixels.2.as_ptr();
     let size = pixels.2.len();
-    
+
     canvas_native_context_draw_image(
-        context,
-        ptr,
-        size,
-        width,
-        height,
-        sx,
-        sy,
-        s_width,
-        s_height,
-        dx,
-        dy,
-        d_width,
-        d_height,
+        context, ptr, size, width, height, sx, sy, s_width, s_height, dx, dy, d_width, d_height,
     );
 }
 

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

@@ -1,5 +1,7 @@
+use crate::webgpu::gpu_supported_limits::CanvasGPUSupportedLimits;
+
 use super::gpu_adapter::CanvasGPUAdapter;
-use std::os::raw::c_void;
+use std::{os::raw::c_void, sync::Arc};
 
 #[repr(C)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -9,12 +11,14 @@ pub enum CanvasGPUPowerPreference {
     HighPerformance,
 }
 
-impl Into<wgpu::PowerPreference> for CanvasGPUPowerPreference {
-    fn into(self) -> wgpu::PowerPreference {
+impl Into<wgpu_types::PowerPreference> for CanvasGPUPowerPreference {
+    fn into(self) -> wgpu_types::PowerPreference {
         match self {
-            CanvasGPUPowerPreference::LowPower => wgpu::PowerPreference::LowPower,
-            CanvasGPUPowerPreference::HighPerformance => wgpu::PowerPreference::HighPerformance,
-            CanvasGPUPowerPreference::None => wgpu::PowerPreference::None,
+            CanvasGPUPowerPreference::LowPower => wgpu_types::PowerPreference::LowPower,
+            CanvasGPUPowerPreference::HighPerformance => {
+                wgpu_types::PowerPreference::HighPerformance
+            }
+            CanvasGPUPowerPreference::None => wgpu_types::PowerPreference::None,
         }
     }
 }
@@ -35,110 +39,114 @@ impl Default for CanvasGPURequestAdapterOptions {
     }
 }
 
-#[cfg(not(target_os = "android"))]
-#[no_mangle]
-pub extern "C" fn canvas_native_webgpu_request_adapter(
-    options: *const CanvasGPURequestAdapterOptions,
-    callback: extern "C" fn(*mut CanvasGPUAdapter, *mut c_void),
-    callback_data: *mut c_void,
-) {
-    use super::prelude::build_features;
+#[derive(Clone)]
+pub struct CanvasWebGPUInstance(pub(crate) Arc<wgpu_core::global::Global>);
 
- 
+unsafe impl Send for CanvasWebGPUInstance {}
 
-    let backends = wgpu::Backends::METAL;
-    let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
-        backends,
-        ..Default::default()
-    });
+#[no_mangle]
+pub extern "C" fn canvas_native_webgpu_instance_create() -> *mut CanvasWebGPUInstance {
+    #[cfg(not(target_os = "android"))]
+    let backends = wgpu_types::Backends::METAL;
 
-    let options = if options.is_null() {
-        CanvasGPURequestAdapterOptions::default()
-    } else {
-        unsafe { *options }
-    };
+    #[cfg(target_os = "android")]
+    let backends = wgpu_types::Backends::VULKAN | wgpu_types::Backends::GL;
 
-    let opts = wgpu::RequestAdapterOptions {
-        power_preference: options.power_preference.into(),
-        force_fallback_adapter: options.force_fallback_adapter,
-        compatible_surface: None,
-    };
+    #[cfg(target_os = "windows")]
+    let backends = wgpu_types::Backends::DX12;
 
-    let request = instance.request_adapter(&opts);
-    let callback = callback as i64;
-    let callback_data = callback_data as i64;
-    std::thread::spawn(move || {
-        let adapter = futures::executor::block_on(request);
-        let adapter = adapter.map(|adapter| {
-            let features = build_features(adapter.features());
-            let limits = adapter.limits();
-            let ret = CanvasGPUAdapter {
-                adapter,
-                is_fallback_adapter: options.force_fallback_adapter,
-                features: features,
-                limits: limits,
-            };
+    let instance = wgpu_core::global::Global::new(
+        "webgpu",
+        wgpu_types::InstanceDescriptor {
+            backends,
+            ..Default::default()
+        },
+    );
 
-            Box::into_raw(Box::new(ret))
-        });
-        let callback = unsafe {
-            std::mem::transmute::<*const i64, fn(*mut CanvasGPUAdapter, *mut c_void)>(callback as _)
-        };
-        let callback_data = callback_data as *mut c_void;
-        callback(adapter.unwrap_or(std::ptr::null_mut()), callback_data);
-    });
+    Box::into_raw(Box::new(CanvasWebGPUInstance(Arc::new(instance))))
+}
+
+#[no_mangle]
+pub extern "C" fn canvas_native_webgpu_instance_destroy(instance: *mut CanvasWebGPUInstance) {
+    if instance.is_null() {
+        return;
+    }
+    let _ = unsafe { Box::from_raw(instance) };
 }
 
-#[cfg(target_os = "android")]
 #[no_mangle]
-pub extern "C" fn canvas_native_webgpu_request_adapter(
+pub unsafe extern "C" fn canvas_native_webgpu_request_adapter(
+    instance: *const CanvasWebGPUInstance,
     options: *const CanvasGPURequestAdapterOptions,
     callback: extern "C" fn(*mut CanvasGPUAdapter, *mut c_void),
     callback_data: *mut c_void,
 ) {
-    let backends = wgpu::Backends::VULKAN | wgpu::Backends::GL;
-    let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
-        backends,
-        ..Default::default()
-    });
+    use super::prelude::build_features;
 
+    let instance = (&*instance).clone();
     let options = if options.is_null() {
         CanvasGPURequestAdapterOptions::default()
     } else {
-        unsafe { *options }
+        *options
     };
 
-    let opts = wgpu::RequestAdapterOptions {
+    let opts = wgpu_types::RequestAdapterOptions {
         power_preference: options.power_preference.into(),
         force_fallback_adapter: options.force_fallback_adapter,
         compatible_surface: None,
     };
 
-    let request = instance.request_adapter(&opts);
-
     let callback = callback as i64;
     let callback_data = callback_data as i64;
-
     std::thread::spawn(move || {
-        let adapter = futures::executor::block_on(request);
-        let adapter = adapter.map(|adapter| {
-            let features = build_features(adapter.features());
-            let limits = adapter.limits();
+        #[cfg(not(target_os = "android"))]
+        let backends = wgpu_types::Backends::METAL;
+
+        #[cfg(target_os = "android")]
+        let backends = wgpu_types::Backends::VULKAN | wgpu_types::Backends::GL;
+
+        #[cfg(target_os = "windows")]
+        let backends = wgpu_types::Backends::DX12;
+
+        println!("spawn");
+
+        let instance = instance;
+
+        let global = &instance.0;
+
+        let adapter = global.request_adapter(
+            &opts,
+            wgpu_core::instance::AdapterInputs::Mask(backends, |_| None),
+        );
+
+        println!("adapter {:?}", &adapter);
+
+        let adapter = adapter.map(|adapter_id| {
+            let features = gfx_select!(adapter_id => global.adapter_features(adapter_id))
+                .map(build_features)
+                .unwrap_or_default();
+
+                println!("features {:?}", &features);
+
+            let limits =
+                gfx_select!(adapter_id => global.adapter_limits(adapter_id)).unwrap_or_default();
+
+                println!("limits {:?}", &limits);
+
             let ret = CanvasGPUAdapter {
-                adapter,
+                instance: instance.clone(),
+                adapter: adapter_id,
                 is_fallback_adapter: options.force_fallback_adapter,
                 features: features,
                 limits: limits,
             };
 
             Box::into_raw(Box::new(ret))
         });
-
         let callback = unsafe {
             std::mem::transmute::<*const i64, fn(*mut CanvasGPUAdapter, *mut c_void)>(callback as _)
         };
         let callback_data = callback_data as *mut c_void;
-
         callback(adapter.unwrap_or(std::ptr::null_mut()), callback_data);
     });
 }