halley-wl 0.1.0

Wayland backend and rendering implementation for the Halley Wayland compositor.
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

use std::f32::consts::TAU;

use smithay::{
    backend::renderer::{Color32F, Frame},
    utils::{Physical, Rectangle},
};

/// Draw an elliptical ring at a fixed screen-space position and radius.
///
/// All coordinates are in physical screen pixels. This stays decoupled from
/// world-space so HUD elements do not scale with the camera zoom.
pub(crate) fn draw_ring<F: Frame>(
    frame: &mut F,
    center_sx: f32,
    center_sy: f32,
    rx: f32,
    ry: f32,
    color: Color32F,
    damage: Rectangle<i32, Physical>,
) -> Result<(), F::Error> {
    let samples = 224;
    let thickness = 2.0f32;
    let mut prev: Option<(f32, f32)> = None;
    for i in 0..=samples {
        let t = (i as f32 / samples as f32) * TAU;
        let x = center_sx + t.cos() * rx;
        let y = center_sy + t.sin() * ry;
        if let Some((px, py)) = prev {
            let dx = x - px;
            let dy = y - py;
            let steps = dx.abs().max(dy.abs()).ceil().max(1.0) as i32;
            for step in 0..=steps {
                let frac = step as f32 / steps as f32;
                let sx = px + dx * frac;
                let sy = py + dy * frac;
                draw_rect(
                    frame,
                    (sx - thickness * 0.5).round() as i32,
                    (sy - thickness * 0.5).round() as i32,
                    thickness.round().max(1.0) as i32,
                    thickness.round().max(1.0) as i32,
                    color,
                    damage,
                )?;
            }
        }
        prev = Some((x, y));
    }
    Ok(())
}

pub(crate) fn draw_rect<F: Frame>(
    frame: &mut F,
    x: i32,
    y: i32,
    w: i32,
    h: i32,
    color: Color32F,
    damage: Rectangle<i32, Physical>,
) -> Result<(), F::Error> {
    if w <= 0 || h <= 0 {
        return Ok(());
    }
    let dst = Rectangle::new((x, y).into(), (w, h).into());
    frame.draw_solid(dst, &[damage], color)
}

pub(crate) fn draw_outline_rect<F: Frame>(
    frame: &mut F,
    x: i32,
    y: i32,
    w: i32,
    h: i32,
    color: Color32F,
    damage: Rectangle<i32, Physical>,
) -> Result<(), F::Error> {
    if w <= 1 || h <= 1 {
        return Ok(());
    }
    draw_rect(frame, x, y, w, 2, color, damage)?;
    draw_rect(frame, x, y + h - 2, w, 2, color, damage)?;
    draw_rect(frame, x, y, 2, h, color, damage)?;
    draw_rect(frame, x + w - 2, y, 2, h, color, damage)
}