agg-gui 0.4.0

Immediate-mode Rust GUI library with AGG rendering, Y-up layout, widgets, text, SVG, and native/WASM adapters
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Gradient fill helpers for `LcdGfxCtx`.
//!
//! This module keeps gradient-specific mask construction out of
//! `lcd_gfx_ctx.rs` while still routing fills through the same LCD coverage
//! mask and per-channel compositing pipeline as solid fills.

use agg_rust::path_storage::PathStorage;
use agg_rust::trans_affine::TransAffine;

use crate::color::Color;
use crate::draw_ctx::{FillRule, LinearGradientPaint, PatternPaint, RadialGradientPaint};
use crate::lcd_coverage::{build_bounded_mask, rect_to_pixel_clip, LcdBuffer};

pub(super) fn fill_linear_gradient(
    buffer: &mut LcdBuffer,
    path: &mut PathStorage,
    gradient: &LinearGradientPaint,
    global_alpha: f32,
    transform: &TransAffine,
    clip: Option<(f64, f64, f64, f64)>,
    fill_rule: FillRule,
) {
    fill_sampled_gradient(
        buffer,
        path,
        |x, y| gradient.sample(x, y),
        global_alpha,
        transform,
        clip,
        fill_rule,
    );
}

pub(super) fn fill_radial_gradient(
    buffer: &mut LcdBuffer,
    path: &mut PathStorage,
    gradient: &RadialGradientPaint,
    global_alpha: f32,
    transform: &TransAffine,
    clip: Option<(f64, f64, f64, f64)>,
    fill_rule: FillRule,
) {
    fill_sampled_gradient(
        buffer,
        path,
        |x, y| gradient.sample(x, y),
        global_alpha,
        transform,
        clip,
        fill_rule,
    );
}

pub(super) fn fill_pattern(
    buffer: &mut LcdBuffer,
    path: &mut PathStorage,
    pattern: &PatternPaint,
    global_alpha: f32,
    transform: &TransAffine,
    clip: Option<(f64, f64, f64, f64)>,
    fill_rule: FillRule,
) {
    fill_sampled_gradient(
        buffer,
        path,
        |x, y| pattern.sample(x, y),
        global_alpha,
        transform,
        clip,
        fill_rule,
    );
}

fn fill_sampled_gradient<F>(
    buffer: &mut LcdBuffer,
    path: &mut PathStorage,
    mut sample: F,
    global_alpha: f32,
    transform: &TransAffine,
    clip: Option<(f64, f64, f64, f64)>,
    fill_rule: FillRule,
) where
    F: FnMut(f64, f64) -> Color,
{
    // Bound the coverage mask to the transformed path's bbox instead of the
    // whole buffer — same O(bbox) win and pixel-identical output as the
    // solid `fill_path` (see `build_bounded_mask`).  The colour callback
    // receives buffer-space `(dx, dy)`, so the gradient sampling below is
    // unchanged; only the mask's size and composite origin move.
    let Some((mask, bbox_x, bbox_y)) =
        build_bounded_mask(buffer.width(), buffer.height(), path, transform, clip, fill_rule)
    else {
        return;
    };
    let clip_i = clip.map(rect_to_pixel_clip);

    buffer.composite_mask_with_color(&mask, bbox_x, bbox_y, clip_i, |dx, dy| {
        let mut lx = dx as f64 + 0.5;
        let mut ly = dy as f64 + 0.5;
        transform.inverse_transform(&mut lx, &mut ly);
        let mut color = sample(lx, ly);
        color.a *= global_alpha;
        color
    });
}