use std::ops::Range;
use crate::overlay::{BackdropEffects, ColourMatrix, OverlayBlend, OverlayClip, ShadowLayer};
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct OverlayLayerStyle {
pub opacity: f32,
pub blend: OverlayBlend,
pub colour_matrix: Option<ColourMatrix>,
pub blur: f32,
pub shadow: Option<ShadowLayer>,
pub backdrop: BackdropEffects,
pub isolated: bool,
}
impl Default for OverlayLayerStyle {
fn default() -> Self {
Self {
opacity: 1.0,
blend: OverlayBlend::SourceOver,
colour_matrix: None,
blur: 0.0,
shadow: None,
backdrop: BackdropEffects::default(),
isolated: false,
}
}
}
impl OverlayLayerStyle {
pub fn with_opacity(mut self, opacity: f32) -> Self {
self.opacity = opacity;
self
}
pub fn with_blend(mut self, blend: OverlayBlend) -> Self {
self.blend = blend;
self
}
pub fn with_colour_matrix(mut self, matrix: ColourMatrix) -> Self {
self.colour_matrix = Some(matrix);
self
}
pub fn with_blur(mut self, radius: f32) -> Self {
self.blur = radius;
self
}
pub fn with_shadow(mut self, shadow: ShadowLayer) -> Self {
self.shadow = Some(shadow);
self
}
pub fn with_backdrop(mut self, backdrop: BackdropEffects) -> Self {
self.backdrop = backdrop;
self
}
pub fn with_isolated(mut self, isolated: bool) -> Self {
self.isolated = isolated;
self
}
pub fn needs_target(&self) -> bool {
self.isolated
|| self.blur > 0.0
|| self.shadow.is_some_and(|s| s.colour.alpha() > 0.0)
|| self.backdrop.is_active()
|| self.blend.reads_destination()
}
pub fn is_passthrough(&self) -> bool {
self.opacity >= 1.0
&& self.blend == OverlayBlend::SourceOver
&& self.colour_matrix.is_none_or(|m| m.is_identity())
&& !self.needs_target()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
#[non_exhaustive]
pub struct OverlayLayerMembers {
pub shapes: Range<usize>,
pub labels: Range<usize>,
pub glyph_runs: Range<usize>,
pub polylines: Range<usize>,
pub meshes: Range<usize>,
pub retained: Range<usize>,
}
impl OverlayLayerMembers {
pub fn with_shapes(mut self, range: Range<usize>) -> Self {
self.shapes = range;
self
}
pub fn with_labels(mut self, range: Range<usize>) -> Self {
self.labels = range;
self
}
pub fn with_glyph_runs(mut self, range: Range<usize>) -> Self {
self.glyph_runs = range;
self
}
pub fn with_polylines(mut self, range: Range<usize>) -> Self {
self.polylines = range;
self
}
pub fn with_meshes(mut self, range: Range<usize>) -> Self {
self.meshes = range;
self
}
pub fn with_retained(mut self, range: Range<usize>) -> Self {
self.retained = range;
self
}
pub fn between(start: OverlayLayerMark, end: OverlayLayerMark) -> Self {
Self {
shapes: start.shapes..end.shapes,
labels: start.labels..end.labels,
glyph_runs: start.glyph_runs..end.glyph_runs,
polylines: start.polylines..end.polylines,
meshes: start.meshes..end.meshes,
retained: start.retained..end.retained,
}
}
pub fn len(&self) -> usize {
self.shapes.len()
+ self.labels.len()
+ self.glyph_runs.len()
+ self.polylines.len()
+ self.meshes.len()
+ self.retained.len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct OverlayLayerMark {
shapes: usize,
labels: usize,
glyph_runs: usize,
polylines: usize,
meshes: usize,
retained: usize,
}
#[derive(Debug, Clone, PartialEq, Default)]
#[non_exhaustive]
pub struct OverlayLayer {
pub members: OverlayLayerMembers,
pub z_order: i32,
pub clip: OverlayClip,
pub style: OverlayLayerStyle,
}
impl OverlayLayer {
pub fn new(members: OverlayLayerMembers, style: OverlayLayerStyle) -> Self {
Self {
members,
z_order: 0,
clip: OverlayClip::default(),
style,
}
}
pub fn with_z_order(mut self, z_order: i32) -> Self {
self.z_order = z_order;
self
}
pub fn with_clip(mut self, clip: OverlayClip) -> Self {
self.clip = clip;
self
}
}
impl crate::overlay::OverlayFrame {
pub fn layer_mark(&self) -> OverlayLayerMark {
OverlayLayerMark {
shapes: self.shapes.len(),
labels: self.labels.len(),
glyph_runs: self.glyph_runs.len(),
polylines: self.polylines.len(),
meshes: self.meshes.len(),
retained: self.retained.len(),
}
}
pub fn push_layer(
&mut self,
start: OverlayLayerMark,
style: OverlayLayerStyle,
) -> &mut OverlayLayer {
let members = OverlayLayerMembers::between(start, self.layer_mark());
let z = self.shapes[members.shapes.clone()]
.iter()
.map(|i| i.z_order)
.chain(
self.labels[members.labels.clone()]
.iter()
.map(|i| i.z_order),
)
.chain(
self.glyph_runs[members.glyph_runs.clone()]
.iter()
.map(|i| i.z_order),
)
.chain(
self.polylines[members.polylines.clone()]
.iter()
.map(|i| i.z_order),
)
.chain(
self.meshes[members.meshes.clone()]
.iter()
.map(|i| i.z_order),
)
.chain(
self.retained[members.retained.clone()]
.iter()
.map(|i| i.z_order),
)
.min()
.unwrap_or(0);
self.layers
.push(OverlayLayer::new(members, style).with_z_order(z));
self.layers.last_mut().expect("pushed above")
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::overlay::{OverlayFrame, OverlayShape, OverlayShapeItem};
#[test]
fn marks_name_the_items_pushed_between_them() {
let mut frame = OverlayFrame::default();
let rect = || {
OverlayShapeItem::new(
OverlayShape::Rect { corner_radius: 0.0 },
[0.0; 2],
[1.0; 2],
)
};
frame.shapes.push(rect());
let mark = frame.layer_mark();
frame.shapes.push(rect().with_z_order(5));
frame.shapes.push(rect().with_z_order(3));
let layer = frame.push_layer(mark, OverlayLayerStyle::default().with_opacity(0.5));
assert_eq!(layer.members.shapes, 1..3);
assert_eq!(layer.members.len(), 2);
assert_eq!(layer.z_order, 3);
}
#[test]
fn passthrough_and_target_rules() {
assert!(OverlayLayerStyle::default().is_passthrough());
let isolated = OverlayLayerStyle::default().with_isolated(true);
assert!(isolated.needs_target() && !isolated.is_passthrough());
assert!(
!OverlayLayerStyle::default()
.with_opacity(0.5)
.is_passthrough()
);
assert!(
!OverlayLayerStyle::default()
.with_opacity(0.5)
.needs_target()
);
assert!(
OverlayLayerStyle::default()
.with_blend(OverlayBlend::Difference)
.needs_target()
);
assert!(OverlayLayerStyle::default().with_blur(2.0).needs_target());
}
}