agg-rust 1.0.2

Pure Rust port of Anti-Grain Geometry (AGG) 2.6 - high quality 2D vector graphics rendering
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Raster text renderer for embedded bitmap fonts.
//!
//! Port of `agg_renderer_raster_text.h`.
//! Renders text using binary raster glyphs from `GlyphRasterBin`.

use crate::glyph_raster_bin::{GlyphRasterBin, GlyphRect};
use crate::pixfmt_rgba::PixelFormat;
use crate::renderer_base::RendererBase;

// ============================================================================
// render_raster_htext_solid — render horizontal text with solid color
// ============================================================================

/// Render a horizontal text string using a raster glyph generator and solid color.
///
/// Port of C++ `renderer_raster_htext_solid::render_text()`.
/// Renders each character's binary glyph as a sequence of `blend_solid_hspan` calls.
pub fn render_raster_htext_solid<PF: PixelFormat>(
    ren: &mut RendererBase<PF>,
    glyph: &mut GlyphRasterBin,
    x: f64,
    y: f64,
    text: &str,
    color: &PF::ColorType,
    flip: bool,
) {
    let mut x = x;
    let mut y = y;
    let mut r = GlyphRect::default();

    for ch in text.bytes() {
        glyph.prepare(&mut r, x, y, ch as u32, flip);
        if r.x2 >= r.x1 {
            if flip {
                for i in r.y1..=r.y2 {
                    let span = glyph.span((r.y2 - i) as u32);
                    ren.blend_solid_hspan(r.x1, i, r.x2 - r.x1 + 1, color, span);
                }
            } else {
                for i in r.y1..=r.y2 {
                    let span = glyph.span((i - r.y1) as u32);
                    ren.blend_solid_hspan(r.x1, i, r.x2 - r.x1 + 1, color, span);
                }
            }
        }
        x += r.dx;
        y += r.dy;
    }
}

/// Render a vertical text string using a raster glyph generator and solid color.
///
/// Port of C++ `renderer_raster_vtext_solid::render_text()`.
pub fn render_raster_vtext_solid<PF: PixelFormat>(
    ren: &mut RendererBase<PF>,
    glyph: &mut GlyphRasterBin,
    x: f64,
    y: f64,
    text: &str,
    color: &PF::ColorType,
    flip: bool,
) {
    let mut x = x;
    let mut y = y;
    let mut r = GlyphRect::default();

    for ch in text.bytes() {
        glyph.prepare(&mut r, x, y, ch as u32, !flip);
        if r.x2 >= r.x1 {
            if flip {
                for i in r.y1..=r.y2 {
                    let span = glyph.span((i - r.y1) as u32);
                    ren.blend_solid_vspan(i, r.x1, r.x2 - r.x1 + 1, color, span);
                }
            } else {
                for i in r.y1..=r.y2 {
                    let span = glyph.span((r.y2 - i) as u32);
                    ren.blend_solid_vspan(i, r.x1, r.x2 - r.x1 + 1, color, span);
                }
            }
        }
        x += r.dx;
        y += r.dy;
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::color::Rgba8;
    use crate::pixfmt_rgba::PixfmtRgba32;
    use crate::rendering_buffer::RowAccessor;

    // Minimal test font: height=2, baseline=0, start_char=65('A'), num_chars=1
    fn make_test_font() -> Vec<u8> {
        let mut font = Vec::new();
        font.push(2); // height
        font.push(0); // baseline
        font.push(65); // start_char = 'A'
        font.push(1); // num_chars = 1
        font.push(0); // glyph offset lo
        font.push(0); // glyph offset hi
        font.push(2); // glyph_width = 2
        font.push(0b1100_0000); // row 0
        font.push(0b1100_0000); // row 1
        font
    }

    fn make_buffer(w: u32, h: u32) -> (Vec<u8>, RowAccessor) {
        let stride = (w * 4) as i32;
        let buf = vec![0u8; (h * w * 4) as usize];
        let mut ra = RowAccessor::new();
        unsafe {
            ra.attach(buf.as_ptr() as *mut u8, w, h, stride);
        }
        (buf, ra)
    }

    #[test]
    fn test_render_htext() {
        let font_data = make_test_font();
        let mut glyph = GlyphRasterBin::new(&font_data);
        let (_buf, mut ra) = make_buffer(20, 20);
        let pixf = PixfmtRgba32::new(&mut ra);
        let mut ren = RendererBase::new(pixf);

        let red = Rgba8::new(255, 0, 0, 255);
        render_raster_htext_solid(&mut ren, &mut glyph, 5.0, 5.0, "A", &red, false);

        // Check that some pixels were rendered.
        // With baseline=0, height=2, non-flipped: y1 = 5 - 0 + 1 = 6, y2 = 7
        let p = ren.ren().pixel(5, 6);
        assert!(p.r > 0 || p.a > 0, "Expected rendered pixel at (5,6)");
    }

    #[test]
    fn test_render_empty_string() {
        let font_data = make_test_font();
        let mut glyph = GlyphRasterBin::new(&font_data);
        let (_buf, mut ra) = make_buffer(20, 20);
        let pixf = PixfmtRgba32::new(&mut ra);
        let mut ren = RendererBase::new(pixf);

        let red = Rgba8::new(255, 0, 0, 255);
        render_raster_htext_solid(&mut ren, &mut glyph, 5.0, 5.0, "", &red, false);
        // Should not panic or crash
    }
}