chore: fixes & performance updates

Author: triniwiz

Cargo.toml

@@ -29,7 +29,7 @@ strip = true
 [workspace.dependencies.wgt]
 package = "wgpu-types"
 git = "https://github.com/triniwiz/wgpu"
-rev = "56a46b75f1b400446d0b1139b2435aa95a0d5ab5"
+rev = "9616414f16e5688192f6127f8104d8a07a3b1de6"
 
 
 
@@ -45,9 +45,9 @@ canvas-webgl = { path = "./crates/canvas-webgl" }
 canvas-svg = { path = "./crates/canvas-svg" }
 gl-bindings = { path = "./crates/gl-bindings" }
 canvas-c = { path = "./crates/canvas-c" }
-skia-safe = { version = "0.87.0", features = ["textlayout"] }
+skia-safe = { version = "0.93.1", features = ["textlayout"] }
 itertools = "0.14.0"
-wgpu-core = { git = "https://github.com/triniwiz/wgpu", rev = "56a46b75f1b400446d0b1139b2435aa95a0d5ab5", features = ["wgsl", "vulkan", "metal", "raw-window-handle"] }
-wgpu-hal = { git = "https://github.com/triniwiz/wgpu", rev = "56a46b75f1b400446d0b1139b2435aa95a0d5ab5", features = ["metal", "vulkan"] }
+wgpu-core = { git = "https://github.com/triniwiz/wgpu", rev = "9616414f16e5688192f6127f8104d8a07a3b1de6", features = ["wgsl", "vulkan", "metal"] }
+wgpu-hal = { git = "https://github.com/triniwiz/wgpu", rev = "9616414f16e5688192f6127f8104d8a07a3b1de6", features = ["metal", "vulkan"] }
 ureq = "2.10.1"
 jni = "0.21.1"

Makefile

@@ -21,9 +21,8 @@ GENERATE_HEADERS:
 # --- iOS builds ---
 .PHONY: $(ARCHS_IOS)
 $(ARCHS_IOS): %:
-	RUSTFLAGS="-Zlocation-detail=none -C panic=abort" \
+	RUSTFLAGS="-Zlocation-detail=none -Zunstable-options -Cpanic=immediate-abort" \
 	cargo +nightly build -Z build-std='std,panic_abort' \
-	    -Z build-std-features=panic_immediate_abort \
 	    --target $@ --release -p canvas-ios
 
 $(XCFRAMEWORK): $(ARCHS_IOS)
@@ -39,9 +38,8 @@ GENERATE_ANDROID: $(ARCHS_ANDROID)
 # --- iOS SVG builds ---
 .PHONY: $(addsuffix _svg,$(ARCHS_IOS))
 $(addsuffix _svg,$(ARCHS_IOS)): %_svg:
-	RUSTFLAGS="-Zlocation-detail=none -C panic=abort" \
+	RUSTFLAGS="-Zlocation-detail=none -Zunstable-options -Cpanic=immediate-abort" \
 	cargo +nightly build -Z build-std='std,panic_abort' \
-	    -Z build-std-features=panic_immediate_abort \
 	    --target $* --release -p canvas-svg-ios
 
 .PHONY: GENERATE_IOS_SVG

apps/demo/src/app.ts

@@ -4,6 +4,7 @@ require('@nativescript/canvas-polyfill');
 */
 import '@nativescript/canvas-polyfill';
 import { Canvas } from '@nativescript/canvas';
+
 /*
 
 

crates/canvas-2d/src/context/drawing_paths/fill_rule.rs

@@ -1,4 +1,4 @@
-use skia_safe::path::FillType;
+use skia_safe::PathFillType;
 
 #[derive(Copy, Clone, Debug)]
 pub enum FillRule {
@@ -63,10 +63,10 @@ impl FillRule {
             _ => None,
         }
     }
-    pub fn to_fill_type(&self) -> FillType {
+    pub fn to_fill_type(&self) -> PathFillType {
         match self {
-            FillRule::EvenOdd => FillType::EvenOdd,
-            FillRule::NonZero => FillType::Winding,
+            FillRule::EvenOdd => PathFillType::EvenOdd,
+            FillRule::NonZero => PathFillType::Winding,
         }
     }
 }

crates/canvas-2d/src/context/drawing_paths/mod.rs

@@ -1,10 +1,7 @@
-use std::borrow::BorrowMut;
-
-use skia_safe::{ClipOp, Matrix, Point};
-
 use crate::context::drawing_paths::fill_rule::FillRule;
 use crate::context::paths::path::Path;
 use crate::context::Context;
+use skia_safe::{ClipOp, Color, Matrix, Point};
 
 pub mod fill_rule;
 
@@ -15,55 +12,133 @@ impl Context {
         path: Option<&mut Path>,
         fill_rule: Option<FillRule>,
     ) {
+        #[cfg(any(target_os = "macos", target_os = "ios"))]
+        let _ = unsafe { objc2_foundation::NSAutoreleasePool::new() };
+
         #[cfg(feature = "gl")]
         {
             if let Some(ref context) = self.gl_context {
                 context.make_current();
             }
         }
 
+        let current_rule = match path {
+            None => self.path.fill_type(),
+            Some(ref path) => path.fill_type(),
+        };
+
+        let fill_rule = fill_rule.unwrap_or(FillRule::default());
+
+        let has_shadow = self.state.shadow_color != Color::TRANSPARENT
+            && self.state.shadow_blur > 0.0;
+
+        if has_shadow {
+            // Slow path: need to save/modify/restore image filter + clone paint
+            self.fill_or_stroke_with_shadow(is_fill, path, fill_rule, current_rule);
+        } else {
+            // Fast path: no shadow — skip all shadow overhead.
+            let paint = if is_fill {
+                self.state.paint.fill_paint.clone()
+            } else {
+                self.state.paint.stroke_paint.clone()
+            };
+
+            let target_rule = fill_rule.to_fill_type();
+            let needs_rule_change = current_rule != target_rule;
+
+            match path {
+                Some(path) => {
+                    if needs_rule_change {
+                        path.set_fill_type_raw(target_rule);
+                    }
+                    self.render_to_canvas(&paint, |canvas, paint| {
+                        canvas.draw_path(path.path(), paint);
+                    });
+                    if needs_rule_change {
+                        path.set_fill_type_raw(current_rule);
+                    }
+                }
+                None => {
+                    if needs_rule_change {
+                        self.path.set_fill_type_raw(target_rule);
+                    }
+                    self.render_to_canvas_with_path(&paint, |canvas, paint, path| {
+                        canvas.draw_path(path.path(), paint);
+                    });
+                    if needs_rule_change {
+                        self.path.set_fill_type_raw(current_rule);
+                    }
+                }
+            };
+        }
+    }
+
+    #[cold]
+    fn fill_or_stroke_with_shadow(
+        &mut self,
+        is_fill: bool,
+        path: Option<&mut Path>,
+        fill_rule: FillRule,
+        current_rule: skia_safe::PathFillType,
+    ) {
+        let saved_image_filter = if is_fill {
+            self.state.paint.fill_paint.image_filter()
+        } else {
+            self.state.paint.stroke_paint.image_filter()
+        };
+
+        let current_image_filter = if is_fill {
+            self.state.paint.fill_paint.image_filter()
+        } else {
+            self.state.paint.stroke_paint.image_filter()
+        };
+
+        let sigma = self.state.shadow_blur / 2.;
+
+        if let Some(shadow) = skia_safe::image_filters::drop_shadow_only(
+            self.state.shadow_offset,
+            (sigma, sigma),
+            self.state.shadow_color,
+            None,
+            current_image_filter,
+            None,
+        ) {
+            if is_fill {
+                self.state.paint.fill_paint.set_image_filter(shadow);
+            } else {
+                self.state.paint.stroke_paint.set_image_filter(shadow);
+            };
+        }
+
         let paint = if is_fill {
             self.state.paint.fill_paint.clone()
         } else {
             self.state.paint.stroke_paint.clone()
         };
 
-        let fill_rule = fill_rule.unwrap_or(FillRule::default());
-
-        let path = match path {
+        match path {
             Some(path) => {
-                path.0.set_fill_type(fill_rule.to_fill_type());
-                path.0.clone()
+                path.set_fill_type_raw(fill_rule.to_fill_type());
+                self.render_to_canvas(&paint, |canvas, paint| {
+                    canvas.draw_path(path.path(), paint);
+                });
+                path.set_fill_type_raw(current_rule);
             }
             None => {
-                self.path.0.set_fill_type(fill_rule.to_fill_type());
-                self.path.0.clone()
+                self.path.set_fill_type_raw(fill_rule.to_fill_type());
+                self.render_to_canvas_with_path(&paint, |canvas, paint, path| {
+                    canvas.draw_path(path.path(), paint);
+                });
+                self.path.set_fill_type_raw(current_rule);
             }
         };
 
-        let shadow_paint = if is_fill {
-            self.state.paint.fill_shadow_paint(
-                self.state.shadow_offset,
-                self.state.shadow_color,
-                self.state.shadow_blur,
-            )
+        // Restore the saved image filter
+        if is_fill {
+            self.state.paint.fill_paint.set_image_filter(saved_image_filter);
         } else {
-            self.state.paint.stroke_shadow_paint(
-                self.state.shadow_offset,
-                self.state.shadow_color,
-                self.state.shadow_blur,
-            )
+            self.state.paint.stroke_paint.set_image_filter(saved_image_filter);
         };
-
-        #[cfg(any(target_os = "macos", target_os = "ios"))]
-        let pool = unsafe { objc2_foundation::NSAutoreleasePool::new() };
-
-        self.render_to_canvas(&paint, |canvas, paint| {
-            if let Some(paint) = &shadow_paint {
-                canvas.draw_path(&path, paint);
-            }
-            canvas.draw_path(&path, paint);
-        });
     }
 
     pub fn fill(&mut self, path: Option<&mut Path>) {
@@ -79,52 +154,62 @@ impl Context {
     }
 
     pub fn clip(&mut self, path: Option<&mut Path>, fill_rule: Option<FillRule>) {
-        let mut path = path
-            .map(|path| path.clone())
-            .unwrap_or_else(|| self.path.clone());
-
-        path.set_fill_type(fill_rule.unwrap_or(FillRule::NonZero));
-
-        self.surface
-            .canvas()
-            .clip_path(path.path(), Some(ClipOp::Intersect), Some(true));
+        let fill_rule = fill_rule.unwrap_or(FillRule::NonZero);
+        match path {
+            Some(path) => {
+                let current = path.fill_type();
+                path.set_fill_type(fill_rule);
+                self.surface
+                    .canvas()
+                    .clip_path(path.path(), Some(ClipOp::Intersect), Some(true));
+                path.set_fill_type_raw(current);
+            }
+            None => {
+                let current = self.path.fill_type();
+                self.path.set_fill_type(fill_rule);
+                self.surface
+                    .canvas()
+                    .clip_path(self.path.path(), Some(ClipOp::Intersect), Some(true));
+                self.path.set_fill_type_raw(current);
+            }
+        }
     }
 
     pub fn point_in_path(&self, path: Option<&Path>, x: f32, y: f32, rule: FillRule) -> bool {
         let path = path.unwrap_or(&self.path);
 
         let total_matrix = self.state.matrix;
-        let invertible = is_invertible(&total_matrix);
-        if !invertible {
+        if !is_invertible(&total_matrix) {
             return false;
         }
         if !x.is_finite() || !y.is_finite() {
             return false;
         }
-        let matrix = total_matrix.clone();
-        let inverse = matrix.invert().unwrap();
-        let point: Point = (x, y).into();
-        let transformed_point = inverse.map_point(point);
-        let mut path_to_compare = path.path().clone();
-        path_to_compare.set_fill_type(rule.to_fill_type());
-        path_to_compare.contains(transformed_point)
+        let inverse = total_matrix.invert().unwrap();
+        let transformed_point = inverse.map_point(Point::new(x, y));
+        let target_fill = rule.to_fill_type();
+        let current_fill = path.path().fill_type();
+        if current_fill == target_fill {
+            path.path().contains(transformed_point)
+        } else {
+            let mut path_to_compare = path.path().clone();
+            path_to_compare.set_fill_type(target_fill);
+            path_to_compare.contains(transformed_point)
+        }
     }
 
     pub fn point_in_stroke(&self, path: Option<&Path>, x: f32, y: f32) -> bool {
         let path = path.unwrap_or(&self.path);
         let matrix = self.state.matrix;
-        let invertible = is_invertible(&matrix);
-        if !invertible {
+        if !is_invertible(&matrix) {
             return false;
         }
         if !x.is_finite() || !y.is_finite() {
             return false;
         }
         let inverse = matrix.invert().unwrap();
-        let point: Point = (x, y).into();
-        let transformed_point = inverse.map_point(point);
-        let path_to_compare = path.path();
-        path_to_compare.contains(transformed_point)
+        let transformed_point = inverse.map_point(Point::new(x, y));
+        path.path().contains(transformed_point)
     }
 }
 
@@ -134,5 +219,5 @@ fn det(matrix: &Matrix) -> f32 {
 }
 
 fn is_invertible(matrix: &Matrix) -> bool {
-    return det(matrix) != 0.0;
+    det(matrix) != 0.0
 }