use crate::colour::Colour;
use crate::overlay::*;
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum OverlayShape {
Rect {
corner_radius: f32,
},
RoundedRect {
radii: [f32; 4],
},
Circle,
Ellipse,
Capsule,
Ring {
inner_radius_frac: f32,
},
Arc {
inner_radius_frac: f32,
start_angle: f32,
end_angle: f32,
},
Triangle {
direction: TriangleDirection,
},
Line {
thickness: f32,
cap: LineCap,
},
Star {
points: u32,
inner_radius_frac: f32,
},
RegularPolygon {
sides: u32,
},
Cross {
arm_width_frac: f32,
},
Vector {
subpaths: Vec<SubPath>,
fill_rule: FillRule,
},
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub struct ShadowLayer {
pub colour: crate::colour::Colour,
pub blur: f32,
pub offset: [f32; 2],
pub spread: f32,
pub falloff: f32,
}
impl Default for ShadowLayer {
fn default() -> Self {
Self {
colour: Colour::linear(0.0, 0.0, 0.0, 0.0),
blur: 0.0,
offset: [0.0, 0.0],
spread: 0.0,
falloff: 1.0,
}
}
}
impl ShadowLayer {
pub fn new(colour: impl Into<crate::colour::Colour>, blur: f32, offset: [f32; 2]) -> Self {
Self {
colour: colour.into(),
blur,
offset,
..Default::default()
}
}
pub fn outline(colour: impl Into<crate::colour::Colour>, width: f32) -> Self {
Self {
colour: colour.into(),
spread: width,
..Default::default()
}
}
pub fn with_colour(mut self, colour: impl Into<crate::colour::Colour>) -> Self {
self.colour = colour.into();
self
}
pub fn with_blur(mut self, blur: f32) -> Self {
self.blur = blur;
self
}
pub fn with_offset(mut self, offset: [f32; 2]) -> Self {
self.offset = offset;
self
}
pub fn with_spread(mut self, spread: f32) -> Self {
self.spread = spread;
self
}
pub fn with_falloff(mut self, falloff: f32) -> Self {
self.falloff = falloff;
self
}
pub fn extent(&self) -> f32 {
let reach = self.spread + self.blur;
reach + self.offset[0].abs().max(self.offset[1].abs())
}
pub fn is_visible(&self) -> bool {
let shaped = self.blur > 0.0 || self.spread > 0.0;
let displaced = self.offset[0] != 0.0 || self.offset[1] != 0.0;
self.colour.to_linear_rgba()[3] > 0.0 && (shaped || displaced)
}
}
pub const OVERLAY_MAX_SHADOW_LAYERS: usize = 4;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum TriangleDirection {
#[default]
Up,
Down,
Left,
Right,
}
impl Default for OverlayShape {
fn default() -> Self {
OverlayShape::Rect { corner_radius: 0.0 }
}
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct OverlayShapeItem {
pub shape: OverlayShape,
pub size: [f32; 2],
pub anchoring: OverlayAnchoring,
pub transform: OverlayTransform,
pub style: OverlayStyle,
pub clip: OverlayClip,
pub z_order: i32,
pub provides_mask: Option<u32>,
pub animations: Option<Box<OverlayAnimations>>,
}
impl Default for OverlayShapeItem {
fn default() -> Self {
Self {
anchoring: crate::overlay::OverlayAnchoring::default(),
transform: OverlayTransform::IDENTITY,
style: OverlayStyle {
fill: OverlayFill::Solid(Colour::linear(1.0, 1.0, 1.0, 1.0)),
..Default::default()
},
clip: OverlayClip::default(),
size: [100.0, 100.0],
shape: OverlayShape::default(),
z_order: 0,
provides_mask: None,
animations: None,
}
}
}
fn sd_rounded_box(p: [f32; 2], b: [f32; 2], r: [f32; 4]) -> f32 {
let chosen = if p[0] > 0.0 {
if p[1] > 0.0 { r[1] } else { r[0] } } else {
if p[1] > 0.0 { r[2] } else { r[3] } };
let qx = (p[0].abs() - b[0] + chosen).max(0.0);
let qy = (p[1].abs() - b[1] + chosen).max(0.0);
let outer = (qx * qx + qy * qy).sqrt();
let inner = (p[0].abs() - b[0] + chosen)
.max(p[1].abs() - b[1] + chosen)
.min(0.0);
inner + outer - chosen
}
fn sd_circle(p: [f32; 2], r: f32) -> f32 {
(p[0] * p[0] + p[1] * p[1]).sqrt() - r
}
fn sd_ellipse(p: [f32; 2], ab: [f32; 2]) -> f32 {
let pa = [p[0].abs(), p[1].abs()];
let ei = [1.0 / ab[0], 1.0 / ab[1]];
let e2 = [ab[0] * ab[0], ab[1] * ab[1]];
let ve = [ei[0] * (e2[0] - e2[1]), ei[1] * (e2[1] - e2[0])];
let mut t = [std::f32::consts::FRAC_1_SQRT_2; 2];
for _ in 0..3 {
let v = [ve[0] * t[0] * t[0] * t[0], ve[1] * t[1] * t[1] * t[1]];
let diff = [pa[0] - v[0], pa[1] - v[1]];
let diff_len = (diff[0] * diff[0] + diff[1] * diff[1]).sqrt();
let tab_v = [t[0] * ab[0] - v[0], t[1] * ab[1] - v[1]];
let tab_v_len = (tab_v[0] * tab_v[0] + tab_v[1] * tab_v[1]).sqrt();
let u = if diff_len > 0.0 {
let s = tab_v_len / diff_len;
[diff[0] * s, diff[1] * s]
} else {
[0.0, 0.0]
};
let w = [ei[0] * (v[0] + u[0]), ei[1] * (v[1] + u[1])];
let wc = [w[0].clamp(0.0, 1.0), w[1].clamp(0.0, 1.0)];
let wlen = (wc[0] * wc[0] + wc[1] * wc[1]).sqrt();
t = if wlen > 0.0 {
[wc[0] / wlen, wc[1] / wlen]
} else {
t
};
}
let nearest = [t[0] * ab[0], t[1] * ab[1]];
let dx = pa[0] - nearest[0];
let dy = pa[1] - nearest[1];
let d = (dx * dx + dy * dy).sqrt();
let np = [pa[0] / ab[0], pa[1] / ab[1]];
let inside = np[0] * np[0] + np[1] * np[1];
if inside < 1.0 { -d } else { d }
}
fn sd_capsule(p: [f32; 2], hs: [f32; 2]) -> f32 {
let r = hs[0].min(hs[1]);
let mut qx = p[0].abs();
let mut qy = p[1].abs();
if hs[0] > hs[1] {
qx -= hs[0] - r;
} else {
qy -= hs[1] - r;
}
(qx.max(0.0) * qx.max(0.0) + qy.max(0.0) * qy.max(0.0)).sqrt() - r
}
fn sd_ring(p: [f32; 2], outer_r: f32, inner_frac: f32) -> f32 {
let wall = outer_r * (1.0 - inner_frac) * 0.5;
let mid_r = outer_r - wall;
((p[0] * p[0] + p[1] * p[1]).sqrt() - mid_r).abs() - wall
}
fn sd_arc(p: [f32; 2], outer_r: f32, inner_frac: f32, sa: f32, ea: f32) -> f32 {
let d_ring = sd_ring(p, outer_r, inner_frac);
let angle = p[1].atan2(p[0]);
let two_pi = std::f32::consts::TAU;
let sweep = ((ea - sa) % two_pi + two_pi) % two_pi;
let a = ((angle - sa) % two_pi + two_pi) % two_pi;
if a <= sweep {
return d_ring;
}
let wall = outer_r * (1.0 - inner_frac) * 0.5;
let mid_r = outer_r - wall;
let inner_r = mid_r - wall;
let outer_edge = mid_r + wall;
let cs = [sa.cos(), sa.sin()];
let ce = [ea.cos(), ea.sin()];
let dot_s = (p[0] * cs[0] + p[1] * cs[1]).clamp(inner_r, outer_edge);
let dot_e = (p[0] * ce[0] + p[1] * ce[1]).clamp(inner_r, outer_edge);
let dsx = p[0] - cs[0] * dot_s;
let dsy = p[1] - cs[1] * dot_s;
let ds = (dsx * dsx + dsy * dsy).sqrt();
let dex = p[0] - ce[0] * dot_e;
let dey = p[1] - ce[1] * dot_e;
let de = (dex * dex + dey * dey).sqrt();
ds.min(de)
}
fn sd_line(p: [f32; 2], hs: [f32; 2], radius: f32, square: bool) -> f32 {
if square {
let seg_len = (hs[0] * hs[0] + hs[1] * hs[1]).sqrt();
if seg_len < 1e-6 {
return (p[0] * p[0] + p[1] * p[1]).sqrt() - radius;
}
let dx = hs[0] / seg_len;
let dy = hs[1] / seg_len;
let along = p[0] * dx + p[1] * dy;
let perp = -p[0] * dy + p[1] * dx;
let qx = along.abs() - seg_len;
let qy = perp.abs() - radius;
(qx.max(0.0) * qx.max(0.0) + qy.max(0.0) * qy.max(0.0)).sqrt() + qx.max(qy).min(0.0)
} else {
let bax = 2.0 * hs[0];
let bay = 2.0 * hs[1];
let pax = p[0] + hs[0];
let pay = p[1] + hs[1];
let t = ((pax * bax + pay * bay) / (bax * bax + bay * bay)).clamp(0.0, 1.0);
let ex = pax - bax * t;
let ey = pay - bay * t;
(ex * ex + ey * ey).sqrt() - radius
}
}
fn sd_star(p: [f32; 2], r: f32, n: f32, rf: f32) -> f32 {
let ri = r * rf;
let an = std::f32::consts::PI / n;
let two_an = 2.0 * an;
let a = p[1].atan2(p[0]);
let a_mod = ((a % two_an) + two_an) % two_an;
let a_abs = if a_mod > an { two_an - a_mod } else { a_mod };
let rp = (p[0] * p[0] + p[1] * p[1]).sqrt();
let q = [rp * a_abs.cos(), rp * a_abs.sin()];
let bax = ri * an.cos() - r;
let bay = ri * an.sin();
let qax = q[0] - r;
let qay = q[1];
let t = ((qax * bax + qay * bay) / (bax * bax + bay * bay)).clamp(0.0, 1.0);
let ex = qax - bax * t;
let ey = qay - bay * t;
let d = (ex * ex + ey * ey).sqrt();
let cross = qax * bay - qay * bax;
if cross < 0.0 { -d } else { d }
}
fn sd_ngon(p: [f32; 2], r: f32, n: f32) -> f32 {
let an = std::f32::consts::PI / n;
let two_an = 2.0 * an;
let a = p[1].atan2(p[0]) + an;
let a_mod = ((a % two_an) + two_an) % two_an;
let a_abs = if a_mod > an { two_an - a_mod } else { a_mod };
let rp = (p[0] * p[0] + p[1] * p[1]).sqrt();
let q = [rp * a_abs.cos(), rp * a_abs.sin()];
let he = r * an.cos(); let hv = r * an.sin();
let dx = q[0] - he;
let dy = (q[1] - hv).max(0.0);
if dy > 0.0 {
(dx * dx + dy * dy).sqrt()
} else {
dx
}
}
fn sd_cross(p: [f32; 2], hs: [f32; 2], arm_frac: f32) -> f32 {
let arm_w = arm_frac * hs[0].min(hs[1]);
let box_sdf = |p: [f32; 2], b: [f32; 2]| -> f32 {
let qx = p[0].abs() - b[0];
let qy = p[1].abs() - b[1];
(qx.max(0.0) * qx.max(0.0) + qy.max(0.0) * qy.max(0.0)).sqrt() + qx.max(qy).min(0.0)
};
let d_h = box_sdf(p, [hs[0], arm_w]);
let d_v = box_sdf(p, [arm_w, hs[1]]);
d_h.min(d_v)
}
fn sd_triangle(p: [f32; 2], hs: [f32; 2]) -> f32 {
let q = [p[0].abs(), p[1]];
let e = [hs[0], 2.0 * hs[1]];
let elen = (e[0] * e[0] + e[1] * e[1]).sqrt();
let en = [e[0] / elen, e[1] / elen];
let n = [en[1], -en[0]];
let d_edge = (q[0] - 0.0) * n[0] + (q[1] - (-hs[1])) * n[1];
let d_base = q[1] - hs[1];
d_edge.max(d_base)
}
impl OverlayShapeItem {
pub fn new(shape: OverlayShape, position: [f32; 2], size: [f32; 2]) -> Self {
Self {
shape,
transform: OverlayTransform::at(position),
size,
..Default::default()
}
}
pub fn textured_image(
texture: OverlayTextureId,
natural_size: [f32; 2],
scale: f32,
anchor_x: AnchorX,
anchor_y: AnchorY,
viewport_size: [f32; 2],
) -> Self {
let size = [natural_size[0] * scale, natural_size[1] * scale];
let position =
super::anchor::viewport_anchored_top_left(anchor_x, anchor_y, size, viewport_size);
Self::new(OverlayShape::Rect { corner_radius: 0.0 }, position, size).with_texture(texture)
}
pub fn vector(
subpaths: Vec<SubPath>,
fill_rule: FillRule,
position: [f32; 2],
size: [f32; 2],
) -> Self {
Self::new(
OverlayShape::Vector {
subpaths,
fill_rule,
},
position,
size,
)
}
pub fn polygon(points: &[[f32; 2]]) -> Self {
if points.len() < 3 {
return Self::vector(Vec::new(), FillRule::NonZero, [0.0, 0.0], [0.0, 0.0]);
}
let (lo, hi) = points
.iter()
.skip(1)
.fold((points[0], points[0]), |(lo, hi), p| {
(
[lo[0].min(p[0]), lo[1].min(p[1])],
[hi[0].max(p[0]), hi[1].max(p[1])],
)
});
let path = SubPath::polygon(points).map_points(|p| [p[0] - lo[0], p[1] - lo[1]]);
Self::vector(
vec![path],
FillRule::NonZero,
lo,
[hi[0] - lo[0], hi[1] - lo[1]],
)
}
pub fn with_size_fitted(mut self, size: [f32; 2]) -> Self {
if let OverlayShape::Vector { subpaths, .. } = &mut self.shape {
let factor = |new: f32, old: f32| if old > 0.0 { new / old } else { 1.0 };
let fx = factor(size[0], self.size[0]);
let fy = factor(size[1], self.size[1]);
for sp in subpaths.iter_mut() {
*sp = std::mem::take(sp).map_points(|p| [p[0] * fx, p[1] * fy]);
}
}
self.size = size;
self
}
pub fn with_style(mut self, style: OverlayStyle) -> Self {
self.style = style;
self
}
pub fn with_fill(mut self, fill: OverlayFill) -> Self {
self.style.fill = fill;
self
}
pub fn with_opacity(mut self, opacity: f32) -> Self {
self.style.opacity = opacity;
self
}
pub fn with_outline(
mut self,
colour: impl Into<crate::colour::Colour>,
width: f32,
mode: OutlineMode,
) -> Self {
if width <= 0.0 {
return self;
}
let colour = colour.into();
let band = |spread: f32| ShadowLayer::new(colour, 0.0, [0.0, 0.0]).with_spread(spread);
match mode {
OutlineMode::Inset => self.style.inner_shadows.push(band(width)),
OutlineMode::Outer => self.style.shadows.push(band(width)),
OutlineMode::Centre => {
self.style.inner_shadows.push(band(width * 0.5));
self.style.shadows.push(band(width * 0.5));
}
}
self
}
pub fn with_z_order(mut self, z_order: i32) -> Self {
self.z_order = z_order;
self
}
pub fn with_texture(mut self, texture: OverlayTextureId) -> Self {
self.style.fill = OverlayFill::texture(texture);
self
}
pub fn with_backdrop_blur(mut self, radius: f32) -> Self {
self.style.backdrop.blur = radius;
self
}
pub fn with_rotation(mut self, radians: f32) -> Self {
self.transform.rotation = radians;
self
}
pub fn with_rotation_pivot(mut self, pivot: [f32; 2]) -> Self {
self.transform.pivot = pivot;
self
}
pub fn with_backdrop_filters(
mut self,
saturation: f32,
brightness: f32,
hue_shift: f32,
) -> Self {
self.style.backdrop.saturation = saturation;
self.style.backdrop.brightness = brightness;
self.style.backdrop.hue_shift = hue_shift;
self
}
pub fn with_shadows(mut self, shadows: Vec<ShadowLayer>) -> Self {
self.style.shadows = shadows;
self
}
pub fn with_shadow(mut self, shadow: ShadowLayer) -> Self {
self.style.shadows.push(shadow);
self
}
pub fn with_inner_shadow(mut self, shadow: ShadowLayer) -> Self {
self.style.inner_shadows.push(shadow);
self
}
pub fn with_inner_shadows(mut self, shadows: Vec<ShadowLayer>) -> Self {
self.style.inner_shadows = shadows;
self
}
pub fn provides_mask(mut self, mask_id: u32) -> Self {
self.provides_mask = Some(mask_id);
self
}
pub fn with_clip(mut self, clip_id: u32) -> Self {
self.clip.mask = Some(clip_id);
self
}
pub fn with_animations(mut self, animations: OverlayAnimations) -> Self {
self.animations = Some(Box::new(animations));
self
}
pub fn with_anchor(mut self, anchor: OverlayOrigin) -> Self {
self.anchoring.origin = anchor;
self
}
pub fn with_world_anchor(mut self, pos: impl crate::scene::IntoWorldPosition) -> Self {
self.anchoring.origin = OverlayOrigin::World(pos.into_world_position());
self
}
pub fn with_screen_anchor(mut self, pos: [f32; 2]) -> Self {
self.anchoring =
crate::overlay::OverlayAnchoring::default().with_align(self.anchoring.align);
self.transform.translate = pos;
self
}
pub fn with_align(mut self, align: Alignment) -> Self {
self.anchoring.align = align;
self
}
pub fn resolve_top_left(
&self,
viewport_size: [f32; 2],
view: &glam::Mat4,
proj: &glam::Mat4,
) -> Option<[f32; 2]> {
self.resolve_top_left_at(viewport_size, view, proj, glam::DVec3::ZERO)
}
pub fn resolve_top_left_at(
&self,
viewport_size: [f32; 2],
view: &glam::Mat4,
proj: &glam::Mat4,
world_origin: glam::DVec3,
) -> Option<[f32; 2]> {
let origin = crate::overlay::resolve_anchor_origin_at(
&self.anchoring.origin,
viewport_size,
view,
proj,
world_origin,
)?;
Some([
origin[0]
+ self.transform.translate[0]
+ self.anchoring.align.x.align_shift(self.size[0]),
origin[1]
+ self.transform.translate[1]
+ self.anchoring.align.y.align_shift(self.size[1], None),
])
}
pub fn distance(&self, point: [f32; 2]) -> f32 {
let scale = self.transform.scale;
if !(scale.is_finite() && scale > 0.0) {
return f32::INFINITY;
}
let hw = self.size[0] * 0.5;
let hh = self.size[1] * 0.5;
let cx = self.transform.translate[0] + hw;
let cy = self.transform.translate[1] + hh;
let dx = point[0] - cx;
let dy = point[1] - cy;
let c = (-self.transform.rotation).cos();
let s = (-self.transform.rotation).sin();
let piv = self.transform.pivot;
let rx = dx - piv[0];
let ry = dy - piv[1];
let inv = 1.0 / scale;
let p = [
(c * rx - s * ry) * inv + piv[0],
(s * rx + c * ry) * inv + piv[1],
];
self.local_distance(p) * scale
}
fn local_distance(&self, p: [f32; 2]) -> f32 {
let hw = self.size[0] * 0.5;
let hh = self.size[1] * 0.5;
let hs = [hw, hh];
match &self.shape {
OverlayShape::Rect { corner_radius } => {
let r = corner_radius.min(hw).min(hh).max(0.0);
sd_rounded_box(p, hs, [r, r, r, r])
}
OverlayShape::RoundedRect { radii: r } => {
let clamped = [
r[1].min(hw).min(hh).max(0.0),
r[2].min(hw).min(hh).max(0.0),
r[3].min(hw).min(hh).max(0.0),
r[0].min(hw).min(hh).max(0.0),
];
sd_rounded_box(p, hs, clamped)
}
OverlayShape::Circle => sd_circle(p, hw.min(hh)),
OverlayShape::Ellipse => sd_ellipse(p, hs),
OverlayShape::Capsule => sd_capsule(p, hs),
OverlayShape::Ring { inner_radius_frac } => {
sd_ring(p, hw.min(hh), inner_radius_frac.clamp(0.0, 1.0))
}
OverlayShape::Arc {
inner_radius_frac,
start_angle,
end_angle,
} => sd_arc(
p,
hw.min(hh),
inner_radius_frac.clamp(0.0, 1.0),
*start_angle,
*end_angle,
),
OverlayShape::Triangle { direction } => {
let (tp, ths) = match direction {
TriangleDirection::Up => (p, hs),
TriangleDirection::Down => ([p[0], -p[1]], hs),
TriangleDirection::Left => ([p[1], p[0]], [hh, hw]),
TriangleDirection::Right => ([-p[1], p[0]], [hh, hw]),
};
sd_triangle(tp, ths)
}
OverlayShape::Line { thickness, cap } => {
sd_line(p, hs, thickness * 0.5, *cap == LineCap::Square)
}
OverlayShape::Star {
points,
inner_radius_frac,
} => {
let r = hw.min(hh);
sd_star(p, r, *points as f32, inner_radius_frac.clamp(0.0, 1.0))
}
OverlayShape::RegularPolygon { sides } => {
let r = hw.min(hh);
sd_ngon(p, r, (*sides).max(3) as f32)
}
OverlayShape::Cross { arm_width_frac } => {
sd_cross(p, hs, arm_width_frac.clamp(0.0, 1.0))
}
OverlayShape::Vector {
subpaths,
fill_rule,
} => {
let q = [p[0] + hw, p[1] + hh];
if path_contains(subpaths, *fill_rule, q) {
-1.0
} else {
1.0
}
}
}
}
pub fn contains(&self, point: [f32; 2]) -> bool {
self.distance(point) <= 0.0
}
pub fn with_transform(mut self, transform: OverlayTransform) -> Self {
self.transform = transform;
self
}
pub fn with_position(mut self, position: [f32; 2]) -> Self {
self.transform.translate = position;
self
}
pub fn with_scale(mut self, scale: f32) -> Self {
self.transform.scale = scale;
self
}
pub fn with_tint(mut self, tint: [f32; 4]) -> Self {
self.style.tint = tint;
self
}
pub fn with_clip_rect(mut self, clip_rect: [f32; 4]) -> Self {
self.clip.rect = Some(clip_rect);
self
}
}
#[cfg(test)]
mod tests {
use super::*;
fn shape_at(x: f32, y: f32, w: f32, h: f32, shape: OverlayShape) -> OverlayShapeItem {
OverlayShapeItem {
transform: OverlayTransform::at([x, y]),
size: [w, h],
shape,
..Default::default()
}
}
#[test]
fn rect_centre_is_inside() {
let s = shape_at(
100.0,
100.0,
80.0,
60.0,
OverlayShape::Rect { corner_radius: 0.0 },
);
assert!(s.contains([140.0, 130.0])); assert!(s.distance([140.0, 130.0]) < 0.0);
}
#[test]
fn rect_outside() {
let s = shape_at(
100.0,
100.0,
80.0,
60.0,
OverlayShape::Rect { corner_radius: 0.0 },
);
assert!(!s.contains([50.0, 130.0])); assert!(!s.contains([200.0, 130.0])); }
#[test]
fn rect_edge_distance() {
let s = shape_at(
0.0,
0.0,
100.0,
100.0,
OverlayShape::Rect { corner_radius: 0.0 },
);
let d = s.distance([100.0, 50.0]);
assert!(d.abs() < 0.01, "edge distance should be ~0, got {d}");
}
#[test]
fn rounded_rect_corner_is_outside() {
let s = shape_at(
0.0,
0.0,
100.0,
100.0,
OverlayShape::Rect {
corner_radius: 20.0,
},
);
assert!(!s.contains([1.0, 1.0]));
assert!(s.contains([50.0, 50.0]));
}
#[test]
fn circle_contains() {
let s = shape_at(0.0, 0.0, 100.0, 100.0, OverlayShape::Circle);
assert!(s.contains([50.0, 50.0])); assert!(!s.contains([1.0, 1.0])); assert!(s.contains([50.0, 1.5]));
}
#[test]
fn ellipse_contains() {
let s = shape_at(0.0, 0.0, 200.0, 100.0, OverlayShape::Ellipse);
assert!(s.contains([100.0, 50.0])); assert!(!s.contains([1.0, 1.0])); }
#[test]
fn capsule_contains() {
let s = shape_at(0.0, 0.0, 120.0, 40.0, OverlayShape::Capsule);
assert!(s.contains([60.0, 20.0])); assert!(!s.contains([1.0, 1.0]));
}
#[test]
fn ring_hole_is_outside() {
let s = shape_at(
0.0,
0.0,
100.0,
100.0,
OverlayShape::Ring {
inner_radius_frac: 0.7,
},
);
assert!(!s.contains([50.0, 50.0]));
assert!(s.contains([50.0, 8.0]));
}
#[test]
fn arc_inside_sweep() {
let s = shape_at(
0.0,
0.0,
100.0,
100.0,
OverlayShape::Arc {
inner_radius_frac: 0.6,
start_angle: 0.0,
end_angle: std::f32::consts::PI,
},
);
assert!(s.contains([92.0, 50.0]));
assert!(!s.contains([50.0, 8.0]));
}
#[test]
fn triangle_centre_inside() {
let s = shape_at(
0.0,
0.0,
60.0,
60.0,
OverlayShape::Triangle {
direction: TriangleDirection::Up,
},
);
assert!(s.contains([30.0, 35.0])); assert!(!s.contains([1.0, 1.0])); }
#[test]
fn triangle_directions() {
for dir in [
TriangleDirection::Up,
TriangleDirection::Down,
TriangleDirection::Left,
TriangleDirection::Right,
] {
let s = shape_at(
0.0,
0.0,
60.0,
60.0,
OverlayShape::Triangle { direction: dir },
);
assert!(
s.contains([30.0, 30.0]),
"centre should be inside for {dir:?}"
);
}
}
#[test]
fn distance_is_negative_inside_positive_outside() {
let s = shape_at(0.0, 0.0, 100.0, 100.0, OverlayShape::Circle);
assert!(s.distance([50.0, 50.0]) < 0.0, "centre should be negative");
assert!(
s.distance([0.0, 0.0]) > 0.0,
"far corner should be positive"
);
}
#[test]
fn scaled_rect_hits_its_drawn_size() {
for scale in [2.0, 0.5] {
let s = shape_at(
0.0,
0.0,
100.0,
100.0,
OverlayShape::Rect { corner_radius: 0.0 },
)
.with_scale(scale);
let edge = 50.0 + 50.0 * scale;
assert!(s.contains([edge - 1.0, 50.0]), "scale {scale}");
assert!(!s.contains([edge + 1.0, 50.0]), "scale {scale}");
let d = s.distance([edge + 10.0, 50.0]);
assert!((d - 10.0).abs() < 1e-3, "scale {scale}: {d}");
}
}
#[test]
fn scaled_vector_shape_hits_its_drawn_size() {
let square = SubPath::polygon(&[[0.0, 0.0], [100.0, 0.0], [100.0, 100.0], [0.0, 100.0]]);
for scale in [2.0, 0.5] {
let s = OverlayShapeItem::vector(
vec![square.clone()],
FillRule::NonZero,
[0.0, 0.0],
[100.0, 100.0],
)
.with_scale(scale);
let edge = 50.0 + 50.0 * scale;
assert!(s.contains([edge - 1.0, 50.0]), "scale {scale}");
assert!(!s.contains([edge + 1.0, 50.0]), "scale {scale}");
}
}
#[test]
fn scale_rotation_and_pivot_match_the_transform() {
let transform = OverlayTransform {
translate: [40.0, 30.0],
rotation: 0.6,
pivot: [15.0, -10.0],
scale: 1.7,
};
let s = shape_at(
0.0,
0.0,
80.0,
60.0,
OverlayShape::Rect { corner_radius: 0.0 },
)
.with_transform(transform);
let centre = [40.0 + 40.0, 30.0 + 30.0];
let to_screen = |local: [f32; 2]| {
let t = OverlayTransform {
translate: [0.0, 0.0],
..transform
}
.apply(local);
[centre[0] + t[0], centre[1] + t[1]]
};
for (corner, inward) in [
([-40.0, -30.0], [1.0, 1.0]),
([40.0, -30.0], [-1.0, 1.0]),
([40.0, 30.0], [-1.0, -1.0]),
([-40.0, 30.0], [1.0, -1.0]),
] {
let d = s.distance(to_screen(corner));
assert!(d.abs() < 1e-3, "corner {corner:?} at distance {d}");
let inside = [corner[0] + inward[0], corner[1] + inward[1]];
let outside = [corner[0] - inward[0], corner[1] - inward[1]];
assert!(s.contains(to_screen(inside)), "inside {corner:?}");
assert!(!s.contains(to_screen(outside)), "outside {corner:?}");
}
}
#[test]
fn polygon_draws_where_its_points_are() {
let pts = [[100.0, 50.0], [160.0, 70.0], [120.0, 130.0]];
let s = OverlayShapeItem::polygon(&pts);
assert_eq!(s.transform.translate, [100.0, 50.0]);
assert_eq!(s.size, [60.0, 80.0]);
let centroid = [
(pts[0][0] + pts[1][0] + pts[2][0]) / 3.0,
(pts[0][1] + pts[1][1] + pts[2][1]) / 3.0,
];
assert!(s.contains(centroid));
assert!(
!s.contains([101.0, 129.0]),
"inside the box, outside the triangle"
);
let empty = OverlayShapeItem::polygon(&pts[..2]);
assert_eq!(empty.size, [0.0, 0.0]);
assert!(!empty.contains([100.0, 50.0]));
}
#[test]
fn size_fitted_scales_a_vector_path_with_its_box() {
let square = SubPath::polygon(&[[5.0, 5.0], [15.0, 5.0], [15.0, 15.0], [5.0, 15.0]]);
let s = OverlayShapeItem::vector(vec![square], FillRule::NonZero, [0.0, 0.0], [20.0, 20.0])
.with_size_fitted([40.0, 80.0]);
assert_eq!(s.size, [40.0, 80.0]);
let OverlayShape::Vector { subpaths, .. } = &s.shape else {
unreachable!()
};
assert_eq!(path_bounds(subpaths), Some(([10.0, 20.0], [30.0, 60.0])));
assert!(s.contains([20.0, 40.0]));
assert!(!s.contains([5.0, 10.0]), "the padding scaled too");
let c = OverlayShapeItem::new(OverlayShape::Circle, [0.0, 0.0], [10.0, 10.0])
.with_size_fitted([30.0, 30.0]);
assert_eq!(c.size, [30.0, 30.0]);
}
#[test]
fn degenerate_scale_hits_nothing() {
for scale in [0.0, -1.0, f32::NAN] {
let s = shape_at(0.0, 0.0, 100.0, 100.0, OverlayShape::Circle).with_scale(scale);
assert!(!s.contains([50.0, 50.0]), "scale {scale}");
}
}
#[test]
fn line_round_contains() {
let s = shape_at(
0.0,
0.0,
100.0,
4.0,
OverlayShape::Line {
thickness: 4.0,
cap: LineCap::Round,
},
);
assert!(s.contains([50.0, 2.0])); assert!(!s.contains([50.0, 10.0])); }
#[test]
fn line_round_endpoint_is_on_boundary() {
let s = shape_at(
0.0,
0.0,
60.0,
60.0,
OverlayShape::Line {
thickness: 10.0,
cap: LineCap::Round,
},
);
assert!(s.contains([30.0, 30.0]));
}
#[test]
fn line_square_cap_flat_end() {
let s = shape_at(
0.0,
0.0,
100.0,
4.0,
OverlayShape::Line {
thickness: 4.0,
cap: LineCap::Square,
},
);
assert!(s.contains([50.0, 2.0])); assert!(!s.contains([50.0, 10.0])); }
#[test]
fn star_centre_inside() {
let s = shape_at(
0.0,
0.0,
100.0,
100.0,
OverlayShape::Star {
points: 5,
inner_radius_frac: 0.45,
},
);
assert!(s.contains([50.0, 50.0])); assert!(!s.contains([1.0, 1.0])); }
#[test]
fn star_outer_tip_is_on_boundary() {
let s = shape_at(
0.0,
0.0,
100.0,
100.0,
OverlayShape::Star {
points: 5,
inner_radius_frac: 0.45,
},
);
let d = s.distance([100.0, 50.0]);
assert!(
d.abs() < 1.0,
"outer tip distance should be near 0, got {d}"
);
}
#[test]
fn regular_polygon_centre_inside() {
let s = shape_at(
0.0,
0.0,
100.0,
100.0,
OverlayShape::RegularPolygon { sides: 6 },
);
assert!(s.contains([50.0, 50.0])); assert!(!s.contains([1.0, 1.0])); }
#[test]
fn regular_polygon_vertex_on_boundary() {
let s = shape_at(
0.0,
0.0,
100.0,
100.0,
OverlayShape::RegularPolygon { sides: 6 },
);
assert!(s.distance([50.0, 50.0]) < 0.0);
assert!(s.distance([0.0, 0.0]) > 0.0);
}
#[test]
fn cross_arms_inside_body_outside() {
let s = shape_at(
0.0,
0.0,
100.0,
100.0,
OverlayShape::Cross {
arm_width_frac: 0.3,
},
);
assert!(s.contains([50.0, 50.0])); assert!(s.contains([95.0, 50.0]));
assert!(!s.contains([5.0, 5.0]));
}
#[test]
fn cross_centre_distance_negative() {
let s = shape_at(
0.0,
0.0,
100.0,
100.0,
OverlayShape::Cross {
arm_width_frac: 0.4,
},
);
assert!(s.distance([50.0, 50.0]) < 0.0);
assert!(s.distance([0.0, 0.0]) > 0.0);
}
#[test]
fn anim_track_linear_lerps_endpoints() {
let track = AnimTrack::<f32> {
start_time: 10.0,
duration: 2.0,
from: 0.0,
to: 100.0,
easing: OverlayEasing::Linear,
repeat: RepeatMode::Once,
};
assert!((track.sample(10.0) - 0.0).abs() < 1e-3);
assert!((track.sample(11.0) - 50.0).abs() < 1e-3);
assert!((track.sample(12.0) - 100.0).abs() < 1e-3);
assert!((track.sample(50.0) - 100.0).abs() < 1e-3);
}
#[test]
fn anim_track_pingpong_oscillates() {
let track = AnimTrack::<f32> {
start_time: 0.0,
duration: 1.0,
from: 0.0,
to: 10.0,
easing: OverlayEasing::Linear,
repeat: RepeatMode::PingPong,
};
assert!((track.sample(0.5) - 5.0).abs() < 1e-3);
assert!((track.sample(1.0) - 10.0).abs() < 1e-3);
assert!((track.sample(1.5) - 5.0).abs() < 1e-3);
assert!((track.sample(2.0) - 0.0).abs() < 1e-3);
assert!((track.sample(2.5) - 5.0).abs() < 1e-3);
}
#[test]
fn anim_track_vec2_interpolates_componentwise() {
let track = AnimTrack::<[f32; 2]> {
start_time: 0.0,
duration: 1.0,
from: [0.0, 100.0],
to: [200.0, 0.0],
easing: OverlayEasing::Linear,
repeat: RepeatMode::Once,
};
let v = track.sample(0.5);
assert!((v[0] - 100.0).abs() < 1e-3);
assert!((v[1] - 50.0).abs() < 1e-3);
}
#[test]
fn rotation_affects_hit_test() {
let mut s = OverlayShapeItem {
transform: OverlayTransform::at([0.0, 30.0]),
size: [100.0, 40.0],
shape: OverlayShape::Capsule,
..Default::default()
};
assert!(!s.contains([50.0, 80.0]));
s.transform.rotation = std::f32::consts::FRAC_PI_2;
assert!(s.contains([50.0, 80.0]));
}
#[test]
fn rotation_pivot_shifts_hit_boundary() {
let mut s = OverlayShapeItem {
transform: OverlayTransform::IDENTITY.with_rotation(std::f32::consts::FRAC_PI_2),
size: [80.0, 40.0],
shape: OverlayShape::Rect { corner_radius: 0.0 },
..Default::default()
};
assert!(s.contains([40.0, 20.0]));
s.transform.pivot = [200.0, 0.0];
assert!(!s.contains([40.0, 20.0]));
}
#[test]
fn default_anchor_resolves_to_position() {
let s = OverlayShapeItem::new(OverlayShape::Circle, [40.0, 70.0], [30.0, 30.0]);
let tl = s
.resolve_top_left([800.0, 600.0], &glam::Mat4::IDENTITY, &glam::Mat4::IDENTITY)
.unwrap();
assert_eq!(tl, [40.0, 70.0]);
}
#[test]
fn viewport_corner_pins_across_sizes() {
let s = OverlayShapeItem::new(
OverlayShape::Rect { corner_radius: 0.0 },
[0.0, 0.0],
[50.0, 20.0],
)
.with_anchor(OverlayOrigin::Viewport(Alignment::new(
AnchorX::Right,
AnchorY::Bottom,
)))
.with_align(Alignment::new(AnchorX::Right, AnchorY::Bottom));
let id = glam::Mat4::IDENTITY;
let a = s.resolve_top_left([800.0, 600.0], &id, &id).unwrap();
assert_eq!(a, [750.0, 580.0]);
let b = s.resolve_top_left([1024.0, 768.0], &id, &id).unwrap();
assert_eq!(b, [974.0, 748.0]);
}
#[test]
fn centre_anchor_centres_box() {
let s = OverlayShapeItem::new(
OverlayShape::Rect { corner_radius: 0.0 },
[0.0, 0.0],
[80.0, 60.0],
)
.with_anchor(OverlayOrigin::Viewport(Alignment::new(
AnchorX::Middle,
AnchorY::Middle,
)))
.with_align(Alignment::new(AnchorX::Middle, AnchorY::Middle));
let id = glam::Mat4::IDENTITY;
let tl = s.resolve_top_left([800.0, 600.0], &id, &id).unwrap();
assert_eq!(tl, [360.0, 270.0]); let mut drawn = s.clone();
drawn.transform.translate = tl;
assert!(drawn.contains([400.0, 300.0]));
}
#[test]
fn position_nudges_from_origin() {
let s = OverlayShapeItem::new(OverlayShape::Circle, [12.0, -8.0], [20.0, 20.0])
.with_anchor(OverlayOrigin::Viewport(Alignment::new(
AnchorX::Right,
AnchorY::Top,
)))
.with_align(Alignment::new(AnchorX::Right, AnchorY::Top));
let id = glam::Mat4::IDENTITY;
let tl = s.resolve_top_left([500.0, 500.0], &id, &id).unwrap();
assert_eq!(tl, [500.0 - 20.0 + 12.0, 0.0 - 8.0]);
}
#[test]
fn world_anchor_culls_when_offscreen() {
let s = OverlayShapeItem::new(OverlayShape::Circle, [0.0, 0.0], [10.0, 10.0])
.with_world_anchor([0.0, 0.0, 0.0]);
let proj = glam::Mat4::perspective_rh(1.0, 1.0, 0.1, 100.0);
let view = glam::Mat4::look_at_rh(
glam::vec3(0.0, 0.0, 5.0),
glam::vec3(0.0, 0.0, 0.0),
glam::vec3(0.0, 1.0, 0.0),
);
let on = s.resolve_top_left([400.0, 400.0], &view, &proj);
assert!(on.is_some());
let p = on.unwrap();
assert!((p[0] - 200.0).abs() < 1.0 && (p[1] - 200.0).abs() < 1.0);
let behind = glam::Mat4::look_at_rh(
glam::vec3(0.0, 0.0, 5.0),
glam::vec3(0.0, 0.0, 10.0),
glam::vec3(0.0, 1.0, 0.0),
);
assert!(s.resolve_top_left([400.0, 400.0], &behind, &proj).is_none());
}
#[test]
fn rotation_pivot_zero_matches_centre_rotation() {
let base = OverlayShapeItem {
transform: OverlayTransform::at([10.0, 10.0]).with_rotation(0.7),
size: [100.0, 30.0],
shape: OverlayShape::Capsule,
..Default::default()
};
let mut piv = base.clone();
piv.transform.pivot = [0.0, 0.0];
for pt in [[60.0, 25.0], [20.0, 20.0], [90.0, 40.0]] {
assert!((base.distance(pt) - piv.distance(pt)).abs() < 1e-4);
}
}
}
#[cfg(test)]
mod size_tests {
use super::*;
#[test]
fn shape_item_stays_small_without_animation_state() {
assert_eq!(
std::mem::size_of::<Option<Box<OverlayAnimations>>>(),
std::mem::size_of::<usize>(),
"the animation block is no longer boxed"
);
let item = std::mem::size_of::<OverlayShapeItem>();
assert!(
item <= 512,
"OverlayShapeItem grew to {item} bytes (budget 512)"
);
}
}