use crate::colour::Colour;
use crate::overlay::{NineSlice, OverlayTextureId, TextureTransform};
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum OverlayFill {
Solid(crate::colour::Colour),
LinearGradient {
start_colour: crate::colour::Colour,
end_colour: crate::colour::Colour,
angle: f32,
},
RadialGradient {
centre_colour: crate::colour::Colour,
edge_colour: crate::colour::Colour,
},
ConicalGradient {
start_colour: crate::colour::Colour,
end_colour: crate::colour::Colour,
offset_angle: f32,
},
LinearGradientMulti {
stops: Vec<GradientStop>,
angle: f32,
},
RadialGradientMulti {
stops: Vec<GradientStop>,
},
ConicalGradientMulti {
stops: Vec<GradientStop>,
offset_angle: f32,
},
Texture {
id: OverlayTextureId,
transform: TextureTransform,
nine_slice: Option<NineSlice>,
tint: crate::colour::Colour,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum OverlayFillKind {
Solid,
Gradient,
Texture,
}
impl Default for OverlayFill {
fn default() -> Self {
OverlayFill::Solid(Colour::linear(0.0, 0.0, 0.0, 0.55))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Default)]
#[non_exhaustive]
pub struct GradientStop {
pub position: f32,
pub colour: crate::colour::Colour,
}
impl GradientStop {
pub fn new(position: f32, colour: impl Into<crate::colour::Colour>) -> Self {
Self {
position,
colour: colour.into(),
}
}
}
pub const OVERLAY_MAX_GRADIENT_STOPS: usize = 4;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum OutlineMode {
#[default]
Inset,
Outer,
Centre,
}
impl OverlayFill {
pub fn texture(id: OverlayTextureId) -> Self {
OverlayFill::Texture {
id,
transform: TextureTransform::default(),
nine_slice: None,
tint: crate::colour::Colour::linear(1.0, 1.0, 1.0, 1.0),
}
}
pub fn none() -> Self {
OverlayFill::Solid(crate::colour::Colour::linear(0.0, 0.0, 0.0, 0.0))
}
pub fn is_set(&self) -> bool {
*self != OverlayFill::none()
}
pub fn kind(&self) -> OverlayFillKind {
match self {
OverlayFill::Solid(_) => OverlayFillKind::Solid,
OverlayFill::Texture { .. } => OverlayFillKind::Texture,
_ => OverlayFillKind::Gradient,
}
}
pub fn texture_id(&self) -> Option<OverlayTextureId> {
match self {
OverlayFill::Texture { id, .. } => Some(*id),
_ => None,
}
}
pub fn with_texture_transform(mut self, tt: TextureTransform) -> Self {
if let OverlayFill::Texture { transform, .. } = &mut self {
*transform = tt;
}
self
}
pub fn with_nine_slice(mut self, ns: NineSlice) -> Self {
if let OverlayFill::Texture { nine_slice, .. } = &mut self {
*nine_slice = Some(ns);
}
self
}
pub fn with_tint(mut self, colour: impl Into<crate::colour::Colour>) -> Self {
if let OverlayFill::Texture { tint, .. } = &mut self {
*tint = colour.into();
}
self
}
pub fn map_colours(&self, f: impl Fn(Colour) -> Colour) -> OverlayFill {
let stops = |stops: &[GradientStop]| -> Vec<GradientStop> {
stops
.iter()
.map(|s| GradientStop {
position: s.position,
colour: f(s.colour),
})
.collect()
};
match self {
OverlayFill::Solid(c) => OverlayFill::Solid(f(*c)),
OverlayFill::LinearGradient {
start_colour,
end_colour,
angle,
} => OverlayFill::LinearGradient {
start_colour: f(*start_colour),
end_colour: f(*end_colour),
angle: *angle,
},
OverlayFill::RadialGradient {
centre_colour,
edge_colour,
} => OverlayFill::RadialGradient {
centre_colour: f(*centre_colour),
edge_colour: f(*edge_colour),
},
OverlayFill::ConicalGradient {
start_colour,
end_colour,
offset_angle,
} => OverlayFill::ConicalGradient {
start_colour: f(*start_colour),
end_colour: f(*end_colour),
offset_angle: *offset_angle,
},
OverlayFill::LinearGradientMulti { stops: s, angle } => {
OverlayFill::LinearGradientMulti {
stops: stops(s),
angle: *angle,
}
}
OverlayFill::RadialGradientMulti { stops: s } => {
OverlayFill::RadialGradientMulti { stops: stops(s) }
}
OverlayFill::ConicalGradientMulti {
stops: s,
offset_angle,
} => OverlayFill::ConicalGradientMulti {
stops: stops(s),
offset_angle: *offset_angle,
},
OverlayFill::Texture {
id,
transform,
nine_slice,
tint,
} => OverlayFill::Texture {
id: *id,
transform: *transform,
nine_slice: *nine_slice,
tint: f(*tint),
},
}
}
pub fn sample_in_box(&self, p: [f32; 2], half_size: [f32; 2]) -> [f32; 4] {
fn lerp(a: [f32; 4], b: [f32; 4], t: f32) -> [f32; 4] {
[
a[0] + (b[0] - a[0]) * t,
a[1] + (b[1] - a[1]) * t,
a[2] + (b[2] - a[2]) * t,
a[3] + (b[3] - a[3]) * t,
]
}
fn linear_t(p: [f32; 2], hs: [f32; 2], angle: f32) -> f32 {
let dir = [angle.cos(), angle.sin()];
let max_proj = (hs[0] * dir[0]).abs() + (hs[1] * dir[1]).abs();
((p[0] * dir[0] + p[1] * dir[1]) / max_proj.max(0.001) * 0.5 + 0.5).clamp(0.0, 1.0)
}
fn radial_t(p: [f32; 2], hs: [f32; 2]) -> f32 {
let max_half = hs[0].max(hs[1]);
((p[0] * p[0] + p[1] * p[1]).sqrt() / max_half.max(0.001)).clamp(0.0, 1.0)
}
fn conical_t(p: [f32; 2], offset: f32) -> f32 {
let a = p[1].atan2(p[0]) - offset;
(a / std::f32::consts::TAU + 1.0).fract()
}
fn sample_stops(stops: &[GradientStop], t: f32) -> [f32; 4] {
let mut sorted: Vec<&GradientStop> = stops.iter().collect();
sorted.sort_by(|a, b| {
a.position
.partial_cmp(&b.position)
.unwrap_or(std::cmp::Ordering::Equal)
});
let Some(first) = sorted.first() else {
return [0.0; 4];
};
if t <= first.position {
return first.colour.to_linear_rgba();
}
for pair in sorted.windows(2) {
let (a, b) = (pair[0], pair[1]);
if t <= b.position {
let span = (b.position - a.position).max(1e-6);
return lerp(
a.colour.to_linear_rgba(),
b.colour.to_linear_rgba(),
((t - a.position) / span).clamp(0.0, 1.0),
);
}
}
sorted[sorted.len() - 1].colour.to_linear_rgba()
}
match self {
OverlayFill::Solid(c) => c.to_linear_rgba(),
OverlayFill::Texture { tint, .. } => tint.to_linear_rgba(),
OverlayFill::LinearGradient {
start_colour,
end_colour,
angle,
} => lerp(
start_colour.to_linear_rgba(),
end_colour.to_linear_rgba(),
linear_t(p, half_size, *angle),
),
OverlayFill::RadialGradient {
centre_colour,
edge_colour,
} => lerp(
centre_colour.to_linear_rgba(),
edge_colour.to_linear_rgba(),
radial_t(p, half_size),
),
OverlayFill::ConicalGradient {
start_colour,
end_colour,
offset_angle,
} => lerp(
start_colour.to_linear_rgba(),
end_colour.to_linear_rgba(),
conical_t(p, *offset_angle),
),
OverlayFill::LinearGradientMulti { stops, angle } => {
sample_stops(stops, linear_t(p, half_size, *angle))
}
OverlayFill::RadialGradientMulti { stops } => {
sample_stops(stops, radial_t(p, half_size))
}
OverlayFill::ConicalGradientMulti {
stops,
offset_angle,
} => sample_stops(stops, conical_t(p, *offset_angle)),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn map_colours_reaches_every_colour() {
let a = Colour::linear(0.2, 0.4, 0.6, 1.0);
let b = Colour::linear(0.8, 0.6, 0.4, 0.5);
let double = |c: Colour| {
let [r, g, b, a] = c.to_linear_rgba();
Colour::linear(r * 2.0, g * 2.0, b * 2.0, a)
};
let stops = vec![GradientStop::new(0.0, a), GradientStop::new(0.7, b)];
let fills = [
OverlayFill::Solid(a),
OverlayFill::LinearGradient {
start_colour: a,
end_colour: b,
angle: 0.3,
},
OverlayFill::RadialGradient {
centre_colour: a,
edge_colour: b,
},
OverlayFill::ConicalGradient {
start_colour: a,
end_colour: b,
offset_angle: 0.3,
},
OverlayFill::LinearGradientMulti {
stops: stops.clone(),
angle: 0.3,
},
OverlayFill::RadialGradientMulti {
stops: stops.clone(),
},
OverlayFill::ConicalGradientMulti {
stops: stops.clone(),
offset_angle: 0.3,
},
OverlayFill::texture(OverlayTextureId(3)).with_tint(a),
];
let p = [3.0, -2.0];
let half = [10.0, 10.0];
for fill in fills {
let mapped = fill.map_colours(double);
assert_eq!(mapped.kind(), fill.kind());
assert_eq!(mapped.texture_id(), fill.texture_id());
if let OverlayFill::Texture { tint, .. } = &mapped {
assert_eq!(*tint, double(a));
continue;
}
let before = fill.sample_in_box(p, half);
let after = mapped.sample_in_box(p, half);
for i in 0..3 {
assert!((after[i] - before[i] * 2.0).abs() < 1e-5, "{fill:?}");
}
assert!((after[3] - before[3]).abs() < 1e-5, "{fill:?}");
}
}
}