Feature request: more control about the pixel alignment (?) of draw_image()

[yutannihilation]

(I'm not very familiar with graphics things, so excuse me if I'm missing some point)

Currently, drawing these 4 pixels by draw_image() gives the following result.
I'm not familiar with graphics things, so I'm not sure what's the correct behavior, but, in my usage, I prefer

1. sharp edge
2. the color is drawn at the center of each pixel instead of the top left corner

(cf. yutannihilation/vellogd-r#14 (comment) is the expected result)

Regarding the first request, I think this is what I should handle by adding extra pixels at the left edge and at the bottom edge and then cut.

For the second one, does it make sense to introduce some option to Scene::draw_image()? Probably, adding kurbo::Affine::translate((0.5, 0.5)) to brush_transform of Scene::fill().

    let mut blob: Vec<u8> = Vec::new();
    [Color::RED, Color::BLUE, Color::BLUE, Color::BLUE]
        .iter()
        .for_each(|c| {
            let b = c.to_premul_u32().to_ne_bytes();
            blob.push(b[3]);
            blob.push(b[2]);
            blob.push(b[1]);
            blob.push(b[0]);
        });

    let data = vello::peniko::Blob::new(Arc::new(blob));
    let image = vello::peniko::Image::new(data, vello::peniko::Format::Rgba8, 2, 2);
    scene.draw_image(
        &image,
        Affine::scale(300.0).then_translate((100.0, 100.0).into()),
    );

[DJMcNab]

cc @dfrg.

The relevant code is here:

vello/vello_shaders/shader/fine.wgsl

Lines 1165 to 1177 in f7e3cee

	let my_xy = vec2(xy.x + f32(i), xy.y);
	let atlas_uv = image.matrx.xy * my_xy.x + image.matrx.zw * my_xy.y + image.xlat + image.atlas_offset;
	// This currently clips to the image bounds. TODO: extend modes
	if all(atlas_uv < atlas_extents) && area[i] != 0.0 {
	let uv_quad = vec4(max(floor(atlas_uv), image.atlas_offset), min(ceil(atlas_uv), atlas_extents));
	let uv_frac = fract(atlas_uv);
	let a = premul_alpha(textureLoad(image_atlas, vec2<i32>(uv_quad.xy), 0));
	let b = premul_alpha(textureLoad(image_atlas, vec2<i32>(uv_quad.xw), 0));
	let c = premul_alpha(textureLoad(image_atlas, vec2<i32>(uv_quad.zy), 0));
	let d = premul_alpha(textureLoad(image_atlas, vec2<i32>(uv_quad.zw), 0));
	let fg_rgba = mix(mix(a, b, uv_frac.y), mix(c, d, uv_frac.y), uv_frac.x);
	let fg_i = fg_rgba * area[i];
	rgba[i] = rgba[i] * (1.0 - fg_i.a) + fg_i;

Your provided image suggests that the calculations are incorrect; the alpha bleed on the bottom right is really concerning. One thing to try would be subtracting (1, 1) from atlas_extents; I think that would probably fix the transparency section.

I'm not sure what the expected behaviour for pixel position is.

[yutannihilation]

Thanks for investigating!

I'm not sure what the expected behaviour for pixel position is.

I too am not sure. I guess this matters less when the number of pixels is large, so this might not be very important.

[dfrg]

Thanks for this test case that perfectly identifies deficiencies in the current code. Both clamping the extents and sampling at pixel center seem reasonable to me.

I’m not sure when I’ll have time to work on this but I’ve added it to my list.

[dfrg]

Needed a bit of a break from other things so I took a swing at this. Please test out #722 and see if this provides the expected rendering.

[yutannihilation]

Wow, thanks for the fix! I confirmed it gives the expected result perfectly (yutannihilation/vellogd-r#18).

[yutannihilation]

Thanks for fixing!