vello_gpu: Fix methods for bilinear and bicubic image sampling

vello_gpu_shaders/shaders/helpers/extend.wesl

@@ -13,14 +13,22 @@ fn extend_mode(t: f32, mode: u32, max: f32) -> f32 {
             return clamp(t, 0.0, max - 1.0);
         }
         case EXTEND_REPEAT: {
-            return extend_mode_normalized(t / max, mode) * max;
+            return euclid_mod(floor(t), max);
         }
         case EXTEND_REFLECT, default: {
-            return extend_mode_normalized(t / max, mode) * max;
+            let period = max + max;
+            let r = euclid_mod(floor(t), period);
+            return select(r, period - 1.0 - r, r >= max);
         }
     }
 }
 
+fn euclid_mod(t: f32, m: f32) -> f32 {
+    let q = round(t / m);
+    let r = fma(q, -m, t);
+    return select(r, r + m, r < 0.0);
+}
+
 fn extend_mode_normalized(t: f32, mode: u32) -> f32 {
     switch mode {
         case EXTEND_PAD: {

vello_gpu_shaders/shaders/helpers/external_texture.wesl

@@ -3,7 +3,7 @@
 
 //! Sampling helpers for externally bound image textures.
 
-import package::helpers::extend::extend_mode;
+import package::helpers::extend::{EXTEND_PAD, extend_mode};
 import package::helpers::image::{
     IMAGE_QUALITY_HIGH,
     IMAGE_QUALITY_MEDIUM,
@@ -38,21 +38,16 @@ fn sample_image_paint(
     let packed_tint = image_texel2.y;
     let image_tint = unpack4x8unorm(packed_tint);
     let is_multiply = image_texel2.z == TINT_MODE_MULTIPLY;
-    let extended_xy = vec2<f32>(
-        extend_mode(sample_xy.x, image_extend_modes.x, image_size.x),
-        extend_mode(sample_xy.y, image_extend_modes.y, image_size.y)
-    );
-
     // TODO: add a fast path for images where we are using bilinear sampling and want transparent pixels,
     // using GPU-native bilinear sampling
 
-    let final_xy = image_offset + extended_xy;
     let sample_color = sample_external_image(
         external_texture,
         image_quality,
-        final_xy,
+        sample_xy,
         image_offset,
         image_size,
+        image_extend_modes,
     );
 
     return select(
@@ -62,58 +57,113 @@ fn sample_image_paint(
     );
 }
 
-// This is the same as `helpers::image::bilinear_sample`, but for a 2D texture
-// instead of an atlas texture array.
+fn external_axis_index(coord: f32, extend_mode_id: u32, size: f32) -> i32 {
+    return i32(min(extend_mode(coord, extend_mode_id, size), size - 1.0));
+}
+
+// Bilinear sampling with each tap extended within the source region.
 fn external_bilinear_sample(
     external_texture: texture_2d<f32>,
     coords: vec2<f32>,
     image_offset: vec2<f32>,
     image_size: vec2<f32>,
+    image_extend_modes: vec2<u32>,
 ) -> vec4<f32> {
-    let image_max = image_offset + image_size - vec2(1.0);
-    let clamped_coords = clamp(coords, image_offset, image_max);
-    let coord_quad = vec4(floor(clamped_coords), ceil(clamped_coords));
-    let coord_frac = fract(coords);
-    let a = textureLoad(external_texture, vec2<i32>(coord_quad.xy), 0);
-    let b = textureLoad(external_texture, vec2<i32>(coord_quad.xw), 0);
-    let c = textureLoad(external_texture, vec2<i32>(coord_quad.zy), 0);
-    let d = textureLoad(external_texture, vec2<i32>(coord_quad.zw), 0);
+    let shifted_coords = coords + vec2(0.5);
+    let base_coords = floor(shifted_coords);
+    let coord_frac = shifted_coords - base_coords;
+    var x: vec2<i32>;
+    var y: vec2<i32>;
+
+    if all(image_extend_modes == vec2<u32>(EXTEND_PAD)) {
+        x = vec2<i32>(clamp(
+            base_coords.xx + vec2<f32>(-1.0, 0.0),
+            vec2<f32>(0.0), vec2<f32>(image_size.x - 1.0),
+        ));
+        y = vec2<i32>(clamp(
+            base_coords.yy + vec2<f32>(-1.0, 0.0),
+            vec2<f32>(0.0), vec2<f32>(image_size.y - 1.0),
+        ));
+    } else {
+        x = vec2<i32>(
+            external_axis_index(base_coords.x - 1.0, image_extend_modes.x, image_size.x),
+            external_axis_index(base_coords.x, image_extend_modes.x, image_size.x),
+        );
+        y = vec2<i32>(
+            external_axis_index(base_coords.y - 1.0, image_extend_modes.y, image_size.y),
+            external_axis_index(base_coords.y, image_extend_modes.y, image_size.y),
+        );
+    }
+    let offset = vec2<i32>(image_offset);
+    let a = textureLoad(external_texture, offset + vec2<i32>(x.x, y.x), 0);
+    let b = textureLoad(external_texture, offset + vec2<i32>(x.x, y.y), 0);
+    let c = textureLoad(external_texture, offset + vec2<i32>(x.y, y.x), 0);
+    let d = textureLoad(external_texture, offset + vec2<i32>(x.y, y.y), 0);
     return mix(mix(a, b, coord_frac.y), mix(c, d, coord_frac.y), coord_frac.x);
 }
 
-// This is the same as `helpers::image::bicubic_sample`, but for a 2D texture
-// instead of an atlas texture array.
+// Bicubic sampling with each tap extended within the source region.
 @if(image_bicubic)
 fn external_bicubic_sample(
     external_texture: texture_2d<f32>,
     coords: vec2<f32>,
     image_offset: vec2<f32>,
     image_size: vec2<f32>,
+    image_extend_modes: vec2<u32>,
 ) -> vec4<f32> {
-    let image_max = image_offset + image_size - vec2(1.0);
-    let frac_coords = fract(coords + 0.5);
+    let shifted_coords = coords + vec2(0.5);
+    let base_coords = floor(shifted_coords);
+    let frac_coords = shifted_coords - base_coords;
     let cx = cubic_weights(frac_coords.x);
     let cy = cubic_weights(frac_coords.y);
 
-    let s00 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(-1.5, -1.5), image_offset, image_max)), 0);
-    let s10 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(-0.5, -1.5), image_offset, image_max)), 0);
-    let s20 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(0.5, -1.5), image_offset, image_max)), 0);
-    let s30 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(1.5, -1.5), image_offset, image_max)), 0);
+    var x: vec4<i32>;
+    var y: vec4<i32>;
 
-    let s01 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(-1.5, -0.5), image_offset, image_max)), 0);
-    let s11 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(-0.5, -0.5), image_offset, image_max)), 0);
-    let s21 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(0.5, -0.5), image_offset, image_max)), 0);
-    let s31 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(1.5, -0.5), image_offset, image_max)), 0);
+    if all(image_extend_modes == vec2<u32>(EXTEND_PAD)) {
+        x = vec4<i32>(clamp(
+            base_coords.xxxx + vec4<f32>(-2.0, -1.0, 0.0, 1.0),
+            vec4<f32>(0.0), vec4<f32>(image_size.x - 1.0),
+        ));
+        y = vec4<i32>(clamp(
+            base_coords.yyyy + vec4<f32>(-2.0, -1.0, 0.0, 1.0),
+            vec4<f32>(0.0), vec4<f32>(image_size.y - 1.0),
+        ));
+    } else {
+        x = vec4<i32>(
+            external_axis_index(base_coords.x - 2.0, image_extend_modes.x, image_size.x),
+            external_axis_index(base_coords.x - 1.0, image_extend_modes.x, image_size.x),
+            external_axis_index(base_coords.x, image_extend_modes.x, image_size.x),
+            external_axis_index(base_coords.x + 1.0, image_extend_modes.x, image_size.x),
+        );
+        y = vec4<i32>(
+            external_axis_index(base_coords.y - 2.0, image_extend_modes.y, image_size.y),
+            external_axis_index(base_coords.y - 1.0, image_extend_modes.y, image_size.y),
+            external_axis_index(base_coords.y, image_extend_modes.y, image_size.y),
+            external_axis_index(base_coords.y + 1.0, image_extend_modes.y, image_size.y),
+        );
+    }
+    let offset = vec2<i32>(image_offset);
+
+    let s00 = textureLoad(external_texture, offset + vec2<i32>(x.x, y.x), 0);
+    let s10 = textureLoad(external_texture, offset + vec2<i32>(x.y, y.x), 0);
+    let s20 = textureLoad(external_texture, offset + vec2<i32>(x.z, y.x), 0);
+    let s30 = textureLoad(external_texture, offset + vec2<i32>(x.w, y.x), 0);
+
+    let s01 = textureLoad(external_texture, offset + vec2<i32>(x.x, y.y), 0);
+    let s11 = textureLoad(external_texture, offset + vec2<i32>(x.y, y.y), 0);
+    let s21 = textureLoad(external_texture, offset + vec2<i32>(x.z, y.y), 0);
+    let s31 = textureLoad(external_texture, offset + vec2<i32>(x.w, y.y), 0);
 
-    let s02 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(-1.5, 0.5), image_offset, image_max)), 0);
-    let s12 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(-0.5, 0.5), image_offset, image_max)), 0);
-    let s22 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(0.5, 0.5), image_offset, image_max)), 0);
-    let s32 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(1.5, 0.5), image_offset, image_max)), 0);
+    let s02 = textureLoad(external_texture, offset + vec2<i32>(x.x, y.z), 0);
+    let s12 = textureLoad(external_texture, offset + vec2<i32>(x.y, y.z), 0);
+    let s22 = textureLoad(external_texture, offset + vec2<i32>(x.z, y.z), 0);
+    let s32 = textureLoad(external_texture, offset + vec2<i32>(x.w, y.z), 0);
 
-    let s03 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(-1.5, 1.5), image_offset, image_max)), 0);
-    let s13 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(-0.5, 1.5), image_offset, image_max)), 0);
-    let s23 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(0.5, 1.5), image_offset, image_max)), 0);
-    let s33 = textureLoad(external_texture, vec2<i32>(clamp(coords + vec2(1.5, 1.5), image_offset, image_max)), 0);
+    let s03 = textureLoad(external_texture, offset + vec2<i32>(x.x, y.w), 0);
+    let s13 = textureLoad(external_texture, offset + vec2<i32>(x.y, y.w), 0);
+    let s23 = textureLoad(external_texture, offset + vec2<i32>(x.z, y.w), 0);
+    let s33 = textureLoad(external_texture, offset + vec2<i32>(x.w, y.w), 0);
 
     let row0 = cx.x * s00 + cx.y * s10 + cx.z * s20 + cx.w * s30;
     let row1 = cx.x * s01 + cx.y * s11 + cx.z * s21 + cx.w * s31;
@@ -132,18 +182,33 @@ fn sample_external_image(
     coords: vec2<f32>,
     image_offset: vec2<f32>,
     image_size: vec2<f32>,
+    image_extend_modes: vec2<u32>,
 ) -> vec4<f32> {
     @if(image_bicubic)
     if quality == IMAGE_QUALITY_HIGH {
-        return external_bicubic_sample(external_texture, coords, image_offset, image_size);
+        return external_bicubic_sample(
+            external_texture,
+            coords,
+            image_offset,
+            image_size,
+            image_extend_modes,
+        );
     }
     if quality == IMAGE_QUALITY_MEDIUM {
         return external_bilinear_sample(
             external_texture,
-            coords - vec2(0.5),
+            coords,
             image_offset,
             image_size,
+            image_extend_modes,
         );
     }
-    return textureLoad(external_texture, vec2<u32>(coords), 0);
+    return textureLoad(
+        external_texture,
+        vec2<i32>(image_offset) + vec2<i32>(
+            external_axis_index(coords.x, image_extend_modes.x, image_size.x),
+            external_axis_index(coords.y, image_extend_modes.y, image_size.y),
+        ),
+        0,
+    );
 }

vello_tests/src/renderer.rs

@@ -1,7 +1,6 @@
 // Copyright 2025 the Vello Authors
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-#[cfg(not(all(target_arch = "wasm32", feature = "webgl")))]
 use std::collections::HashMap;
 use std::sync::Arc;
 
@@ -100,6 +99,8 @@ pub trait Renderer: Sized {
 pub struct CpuRenderer {
     ctx: RenderContext,
     resources: Resources,
+    external_textures: HashMap<TextureId, Arc<Pixmap>>,
+    next_external_texture_id: u64,
     render_mode: RenderMode,
     target: Pixmap,
     target_init: GpuTargetInit<'static>,
@@ -119,6 +120,8 @@ impl Renderer for CpuRenderer {
         Self {
             ctx: RenderContext::new_with(width, height, settings),
             resources: Resources::new(),
+            external_textures: HashMap::new(),
+            next_external_texture_id: 1,
             render_mode,
             target: Pixmap::new(width, height),
             target_init: GpuTargetInit::Clear(ClearSettings::default()),
@@ -214,6 +217,35 @@ impl Renderer for CpuRenderer {
     }
 
     fn set_paint(&mut self, paint: impl Into<PaintType>) {
+        let mut paint = paint.into();
+        if let PaintType::Image(image) = &mut paint
+            && let ImageSource::ExternalTexture {
+                id, source_region, ..
+            } = &image.image
+        {
+            let pixmap = self
+                .external_textures
+                .get(id)
+                .unwrap_or_else(|| panic!("External texture {id:?} not found in test registry"));
+
+            if *source_region == RectU16::new(0, 0, pixmap.width(), pixmap.height()) {
+                image.image = ImageSource::Pixmap(Arc::clone(pixmap));
+            } else {
+                let mut cropped = Pixmap::new(source_region.width(), source_region.height());
+                let width = usize::from(source_region.width());
+                for (row, y) in cropped
+                    .data_mut()
+                    .chunks_exact_mut(width)
+                    .zip(source_region.y0..source_region.y1)
+                {
+                    let start = usize::from(y) * usize::from(pixmap.width())
+                        + usize::from(source_region.x0);
+                    row.copy_from_slice(&pixmap.data()[start..start + width]);
+                }
+                cropped.set_may_have_transparency(pixmap.may_have_transparency());
+                image.image = ImageSource::Pixmap(Arc::new(cropped));
+            }
+        }
         self.ctx.set_paint(paint);
     }
 
@@ -283,8 +315,11 @@ impl Renderer for CpuRenderer {
         self.target.clone()
     }
 
-    fn register_external_texture(&mut self, _: Arc<Pixmap>) -> TextureId {
-        unimplemented!("external textures are only supported by GPU renderer tests")
+    fn register_external_texture(&mut self, pixmap: Arc<Pixmap>) -> TextureId {
+        let texture_id = TextureId(self.next_external_texture_id);
+        self.next_external_texture_id += 1;
+        self.external_textures.insert(texture_id, pixmap);
+        texture_id
     }
 
     fn get_image_source(&mut self, pixmap: Arc<Pixmap>) -> ImageSource {