agent/avatar/
mod.rs

1//! The blob avatar: one silhouette, two eyes and a little life.
2//!
3//! The shape is a radial profile rather than a pick from a roster, so a preset,
4//! a name and [`Shape::random`] are the same kind of value and there is no
5//! vocabulary to outgrow. Colour comes from the theme.
6//!
7//! [`mascot`] draws the same face as cells — one identity at two resolutions,
8//! since a rail and a chat header showing one name should show one being.
9//!
10//! ```ignore
11//! agent::avatar(Face::from("Sara").pose(t)).w(px(48.)).h(px(48.))
12//! ```
13
14mod eyes;
15mod motion;
16mod pixels;
17mod shape;
18
19pub use eyes::{Eye, Eyes};
20pub use motion::{Beat, Motion};
21pub use pixels::{GRID, mascot};
22pub use shape::{Lobe, SAMPLES, Shape, seed};
23
24use gpui::{
25    AnyElement, Bounds, Hsla, IntoElement, PathBuilder, Pixels, Point, Styled, Window, canvas,
26    hsla, point, px,
27};
28use theme::{Theme, contrast_ratio, flatten};
29
30/// The share of the box the body fills at rest.
31const FILL: f32 = 0.4;
32
33/// A face: what to draw, and what to draw it in.
34#[derive(Clone, Copy, Debug, PartialEq)]
35pub struct Face {
36    pub shape: Shape,
37    pub eyes: Eyes,
38    pub motion: Motion,
39    /// `None` follows `theme.accent`.
40    pub color: Option<Hsla>,
41}
42
43impl Face {
44    pub fn new(shape: Shape) -> Self {
45        Self {
46            shape,
47            eyes: Eyes::default(),
48            motion: Motion::default(),
49            color: None,
50        }
51    }
52
53    pub fn eyes(mut self, eyes: Eyes) -> Self {
54        self.eyes = eyes;
55        self
56    }
57
58    pub fn motion(mut self, motion: Motion) -> Self {
59        self.motion = motion;
60        self
61    }
62
63    pub fn color(mut self, color: Hsla) -> Self {
64        self.color = Some(color);
65        self
66    }
67}
68
69impl From<u64> for Face {
70    fn from(seed: u64) -> Self {
71        Self::new(Shape::from(seed)).eyes(Eyes::from(seed))
72    }
73}
74
75impl From<&str> for Face {
76    fn from(name: &str) -> Self {
77        Self::from(seed(name))
78    }
79}
80
81impl Face {
82    /// The face at `t`, motion already spent — everything the painter needs and
83    /// the only form two faces can meet in.
84    pub fn pose(&self, t: f32) -> Pose {
85        let beat = self.motion.beat(t);
86        let shape = self.motion.shape(self.shape, t);
87        let breath = |(x, y): (f32, f32)| (x * beat.scale, y * beat.scale);
88        Pose {
89            outline: shape.outline().map(breath),
90            eyes: self.eyes.place(&shape, self.motion.drift).map(|e| {
91                let (cx, cy) = breath((e.cx + beat.gaze.0, e.cy + beat.gaze.1));
92                Eye {
93                    cx,
94                    cy,
95                    rx: e.rx * beat.scale,
96                    ry: e.ry * beat.scale * (1.0 - beat.lid * 0.92),
97                    ..e
98                }
99            }),
100            color: self.color,
101        }
102    }
103}
104
105/// One face at one instant. A [`Shape`]'s harmonics are not interpolable — a
106/// count of lobes has no half — so blending happens here, where the outline is
107/// already sampled.
108#[derive(Clone, Copy, Debug, PartialEq)]
109pub struct Pose {
110    pub outline: [(f32, f32); SAMPLES],
111    pub eyes: [Eye; 2],
112    pub color: Option<Hsla>,
113}
114
115impl Pose {
116    /// Point for point, which is only sound because every outline is sampled at
117    /// the same angles — the property the whole representation is chosen for.
118    pub fn lerp(a: &Self, b: &Self, k: f32) -> Self {
119        let k = k.clamp(0.0, 1.0);
120        let f = |x: f32, y: f32| x + (y - x) * k;
121        Self {
122            outline: std::array::from_fn(|i| {
123                (
124                    f(a.outline[i].0, b.outline[i].0),
125                    f(a.outline[i].1, b.outline[i].1),
126                )
127            }),
128            eyes: std::array::from_fn(|i| Eye {
129                cx: f(a.eyes[i].cx, b.eyes[i].cx),
130                cy: f(a.eyes[i].cy, b.eyes[i].cy),
131                rx: f(a.eyes[i].rx, b.eyes[i].rx),
132                ry: f(a.eyes[i].ry, b.eyes[i].ry),
133                rot: f(a.eyes[i].rot, b.eyes[i].rot),
134                n: f(a.eyes[i].n, b.eyes[i].n),
135            }),
136            // Through sRGB rather than around the hue wheel, which would sweep
137            // a whole rainbow between two palette entries.
138            color: match (a.color, b.color) {
139                (Some(x), Some(y)) => Some(flatten(hsla(y.h, y.s, y.l, k), x)),
140                (x, y) => {
141                    if k < 0.5 {
142                        x
143                    } else {
144                        y
145                    }
146                }
147            },
148        }
149    }
150}
151
152/// The element, filling its layout bounds.
153pub fn avatar(pose: Pose) -> AnyElement {
154    canvas(
155        move |_: Bounds<Pixels>, _, _| (),
156        move |bounds, (), window, cx| {
157            let theme = Theme::of(cx);
158            let head = pose.color.unwrap_or(theme.accent);
159            // Whichever end of the theme reads as a hole in this body.
160            let ink = if contrast_ratio(head, theme.bg) >= contrast_ratio(head, theme.text) {
161                theme.bg
162            } else {
163                theme.text
164            };
165            paint(window, bounds, &pose, head, ink);
166        },
167    )
168    .size_full()
169    .into_any_element()
170}
171
172fn paint(window: &mut Window, bounds: Bounds<Pixels>, pose: &Pose, head: Hsla, ink: Hsla) {
173    let span = bounds.size.width.min(bounds.size.height).to_f64() as f32;
174    let unit = span * FILL;
175    let mid = bounds.center();
176    let map = |x: f32, y: f32| point(mid.x + px(x * unit), mid.y + px(y * unit));
177
178    window.paint_layer(bounds, |window| {
179        fill(
180            window,
181            map(pose.outline[0].0, pose.outline[0].1),
182            spline(&pose.outline, &map),
183            head,
184        );
185        for eye in &pose.eyes {
186            let (start, segs) = superellipse(eye, &map);
187            fill(window, start, segs, ink);
188        }
189    });
190}
191
192type Cubic = (Point<Pixels>, Point<Pixels>, Point<Pixels>);
193
194fn fill(window: &mut Window, start: Point<Pixels>, segs: Vec<Cubic>, color: Hsla) {
195    let mut b = PathBuilder::fill();
196    b.move_to(start);
197    for (end, c1, c2) in segs {
198        b.cubic_bezier_to(end, c1, c2);
199    }
200    b.close();
201    if let Ok(path) = b.build() {
202        window.paint_path(path, color);
203    }
204}
205
206/// A closed Catmull-Rom through the sampled outline, as cubic Béziers — which
207/// is what rounds the corners a polygon profile lands between samples.
208fn spline(pts: &[(f32, f32); SAMPLES], map: &impl Fn(f32, f32) -> Point<Pixels>) -> Vec<Cubic> {
209    let at = |i: isize| pts[i.rem_euclid(SAMPLES as isize) as usize];
210    (0..SAMPLES as isize)
211        .map(|i| {
212            let ((x0, y0), (x1, y1), (x2, y2), (x3, y3)) = (at(i - 1), at(i), at(i + 1), at(i + 2));
213            (
214                map(x2, y2),
215                map(x1 + (x2 - x0) / 6.0, y1 + (y2 - y0) / 6.0),
216                map(x2 - (x3 - x1) / 6.0, y2 - (y3 - y1) / 6.0),
217            )
218        })
219        .collect()
220}
221
222/// `|x/rx|^n + |y/ry|^n = 1`, each quadrant one cubic whose control offset puts
223/// the curve through the 45° point.
224fn superellipse(e: &Eye, map: &impl Fn(f32, f32) -> Point<Pixels>) -> (Point<Pixels>, Vec<Cubic>) {
225    // Past n ≈ 5.55 the offset exceeds the radius and the curve bulges outside
226    // its own bounding box.
227    let k = ((8.0 * 2f32.powf(-1.0 / e.n) - 4.0) / 3.0).min(1.0);
228    let (ak, bk) = (e.rx * k, e.ry * k);
229    let (rx, ry) = (e.rx, e.ry);
230    let pts = [
231        (rx, 0.0),
232        (rx, bk),
233        (ak, ry),
234        (0.0, ry),
235        (-ak, ry),
236        (-rx, bk),
237        (-rx, 0.0),
238        (-rx, -bk),
239        (-ak, -ry),
240        (0.0, -ry),
241        (ak, -ry),
242        (rx, -bk),
243        (rx, 0.0),
244    ];
245    let (sin, cos) = e.rot.to_radians().sin_cos();
246    let at = |(x, y): (f32, f32)| map(e.cx + x * cos - y * sin, e.cy + x * sin + y * cos);
247    (
248        at(pts[0]),
249        (1..13)
250            .step_by(3)
251            .map(|i| (at(pts[i + 2]), at(pts[i]), at(pts[i + 1])))
252            .collect(),
253    )
254}
agent/avatar/mod.rs

agent/avatar/
mod.rs
