Function draw_good_rounded_rectangle

src/renderer.rs:591–685

Draws a rounded rectangle as a single triangle-fan mesh. This avoids the visual artifacts of multi-shape rendering and handles alpha correctly.

(x: f32, y: f32, w: f32, h: f32, cr: &CornerRadii, color: Color)

/// Draws a rounded rectangle as a single triangle-fan mesh.
/// This avoids the visual artifacts of multi-shape rendering and handles alpha correctly.
fn draw_good_rounded_rectangle(x: f32, y: f32, w: f32, h: f32, cr: &CornerRadii, color: Color) {
    use std::f32::consts::{FRAC_PI_2, PI};

    if cr.top_left == 0.0 && cr.top_right == 0.0 && cr.bottom_left == 0.0 && cr.bottom_right == 0.0 {
        draw_rectangle(x, y, w, h, color);
        return;
    }

    // Generate outline vertices for the rounded rectangle
    // Pre-allocate: each corner produces ~(FRAC_PI_2 * radius / PIXELS_PER_POINT).max(6) + 1 vertices
    let est_verts = [cr.top_left, cr.top_right, cr.bottom_left, cr.bottom_right]
        .iter()
        .map(|&r| if r <= 0.0 { 1 } else { ((FRAC_PI_2 * r) / PIXELS_PER_POINT).max(6.0) as usize + 1 })
        .sum::<usize>();
    let mut outline: Vec<Vec2> = Vec::with_capacity(est_verts);

    let add_arc = |outline: &mut Vec<Vec2>, cx: f32, cy: f32, radius: f32, start_angle: f32, end_angle: f32| {
        if radius <= 0.0 {
            outline.push(Vec2::new(cx, cy));
            return;
        }
        let sides = ((FRAC_PI_2 * radius) / PIXELS_PER_POINT).max(6.0) as usize;
        // Use incremental rotation to avoid per-point cos/sin
        let step = (end_angle - start_angle) / sides as f32;
        let step_cos = step.cos();
        let step_sin = step.sin();
        let mut dx = start_angle.cos() * radius;
        let mut dy = start_angle.sin() * radius;
        for _ in 0..=sides {
            outline.push(Vec2::new(cx + dx, cy + dy));
            let new_dx = dx * step_cos - dy * step_sin;
            let new_dy = dx * step_sin + dy * step_cos;
            dx = new_dx;
            dy = new_dy;
        }
    };

    // Top-left corner: arc from π to 3π/2
    add_arc(&mut outline, x + cr.top_left, y + cr.top_left, cr.top_left,
            PI, 3.0 * FRAC_PI_2);
    // Top-right corner: arc from 3π/2 to 2π
    add_arc(&mut outline, x + w - cr.top_right, y + cr.top_right, cr.top_right,
            3.0 * FRAC_PI_2, 2.0 * PI);
    // Bottom-right corner: arc from 0 to π/2
    add_arc(&mut outline, x + w - cr.bottom_right, y + h - cr.bottom_right, cr.bottom_right,
            0.0, FRAC_PI_2);
    // Bottom-left corner: arc from π/2 to π
    add_arc(&mut outline, x + cr.bottom_left, y + h - cr.bottom_left, cr.bottom_left,
            FRAC_PI_2, PI);

    let n = outline.len();
    if n < 3 { return; }

    let color_bytes = [
        (color.r * 255.0) as u8,
        (color.g * 255.0) as u8,
        (color.b * 255.0) as u8,
        (color.a * 255.0) as u8,