use std::{error::Error, fmt};
use bevy_ecs::prelude::Component;
use sim_engine::{Color, Layer, LogicalScreenPosition, LogicalScreenVector};
use crate::input::PointerSample;
#[path = "screen/image.rs"]
mod image;
pub use image::{ImageFilter, ImageRegion, ImageVisualError, ScreenImageVisual};
#[path = "screen/clip.rs"]
mod clip;
#[path = "screen/rectangle.rs"]
mod rectangle;
pub use clip::ScreenClip;
#[path = "screen/vectors.rs"]
mod vectors;
pub use vectors::{ScreenCircleVisual, ScreenLineVisual};
#[path = "screen/polyline.rs"]
mod polyline;
pub use polyline::{ScreenPolylineError, ScreenPolylineVisual};
#[derive(Debug, Clone, Copy, PartialEq, Component)]
pub struct ScreenRectangleVisual {
position: LogicalScreenPosition,
size: LogicalScreenVector,
color: Color,
layer: Layer,
draw_order_depth: f32,
corner_radius: f32,
stroke: Option<sim_engine::Stroke>,
clip: ScreenClip,
}
impl ScreenRectangleVisual {
pub fn new(
position: LogicalScreenPosition,
size: LogicalScreenVector,
color: Color,
) -> Result<Self, ScreenVisualError> {
let visual = Self {
position,
size,
color,
layer: Layer::DEFAULT,
draw_order_depth: 0.0,
corner_radius: 0.0,
stroke: None,
clip: ScreenClip::Unclipped,
};
visual.validate()?;
Ok(visual)
}
pub const fn position(&self) -> LogicalScreenPosition {
self.position
}
pub const fn size(&self) -> LogicalScreenVector {
self.size
}
pub fn contains_pointer(&self, sample: PointerSample) -> bool {
if !self.clip.contains_pointer(sample) {
return false;
}
let point = sample.position().to_vec2();
let minimum = self.position.to_vec2();
let maximum = minimum + self.size.to_vec2();
let inside = point.x() >= minimum.x()
&& point.y() >= minimum.y()
&& point.x() < maximum.x()
&& point.y() < maximum.y();
if !inside {
return false;
}
let radius = f64::from(self.corner_radius)
.min(f64::from(self.size.to_vec2().x()) * 0.5)
.min(f64::from(self.size.to_vec2().y()) * 0.5);
let x = f64::from(point.x()) - f64::from(minimum.x());
let y = f64::from(point.y()) - f64::from(minimum.y());
let dx = (x - x.clamp(radius, f64::from(self.size.to_vec2().x()) - radius)).abs();
let dy = (y - y.clamp(radius, f64::from(self.size.to_vec2().y()) - radius)).abs();
dx.hypot(dy) <= radius
}
pub const fn color(&self) -> Color {
self.color
}
pub const fn layer(&self) -> Layer {
self.layer
}
pub const fn draw_order_depth(&self) -> f32 {
self.draw_order_depth
}
pub fn set_geometry(
&mut self,
position: LogicalScreenPosition,
size: LogicalScreenVector,
) -> Result<(), ScreenVisualError> {
validate_geometry(position, size)?;
self.position = position;
self.size = size;
Ok(())
}
pub fn set_position(
&mut self,
position: LogicalScreenPosition,
) -> Result<(), ScreenVisualError> {
self.set_geometry(position, self.size)
}
pub fn set_size(&mut self, size: LogicalScreenVector) -> Result<(), ScreenVisualError> {
self.set_geometry(self.position, size)
}
pub fn set_color(&mut self, color: Color) -> Result<(), ScreenVisualError> {
validate_color(color)?;
self.color = color;
Ok(())
}
pub fn set_layer(&mut self, layer: Layer) {
self.layer = layer;
}
pub fn set_draw_order_depth(&mut self, depth: f32) -> Result<(), ScreenVisualError> {
validate_draw_order_depth(depth)?;
self.draw_order_depth = depth;
Ok(())
}
pub(crate) fn validate(&self) -> Result<(), ScreenVisualError> {
validate_geometry(self.position, self.size)?;
validate_color(self.color)?;
validate_draw_order_depth(self.draw_order_depth)
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub enum ScreenVisualError {
MissingPaint,
InvalidRotation {
value: f32,
},
InvalidLine,
InvalidRadius {
value: f32,
},
InvalidStrokeWidth {
value: f32,
},
InvalidPosition {
value: LogicalScreenPosition,
},
InvalidSize {
value: LogicalScreenVector,
},
InvalidBounds {
position: LogicalScreenPosition,
size: LogicalScreenVector,
},
InvalidColor {
value: Color,
},
InvalidDrawOrderDepth {
value: f32,
},
}
impl fmt::Display for ScreenVisualError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::MissingPaint => formatter.write_str("an outline-only shape requires a stroke"),
Self::InvalidRotation { value } => {
write!(formatter, "non-finite screen rotation: {value}")
}
Self::InvalidLine => formatter
.write_str("screen line endpoints must be distinct with finite displacement"),
Self::InvalidRadius { value } => write!(formatter, "invalid screen radius: {value}"),
Self::InvalidStrokeWidth { value } => {
write!(formatter, "invalid screen stroke width: {value}")
}
Self::InvalidPosition { value } => {
write!(
formatter,
"logical screen position must be finite, got {value:?}"
)
}
Self::InvalidSize { value } => write!(
formatter,
"logical screen size must be positive and finite, got {value:?}"
),
Self::InvalidBounds { position, size } => write!(
formatter,
"logical screen bounds must be finite and strictly increasing, got {position:?} plus {size:?}"
),
Self::InvalidColor { value } => write!(
formatter,
"screen color must be normalized linear RGBA, got {value:?}"
),
Self::InvalidDrawOrderDepth { value } => {
write!(
formatter,
"screen draw-order depth must be finite, got {value}"
)
}
}
}
}
impl Error for ScreenVisualError {}
fn validate_geometry(
position: LogicalScreenPosition,
size: LogicalScreenVector,
) -> Result<(), ScreenVisualError> {
if !position.is_finite() {
return Err(ScreenVisualError::InvalidPosition { value: position });
}
let extent = size.to_vec2();
if !size.is_finite() || extent.x() <= 0.0 || extent.y() <= 0.0 {
return Err(ScreenVisualError::InvalidSize { value: size });
}
let minimum = position.to_vec2();
let maximum = minimum + extent;
if !maximum.is_finite() || maximum.x() <= minimum.x() || maximum.y() <= minimum.y() {
return Err(ScreenVisualError::InvalidBounds { position, size });
}
Ok(())
}
fn validate_color(value: Color) -> Result<(), ScreenVisualError> {
value
.is_normalized()
.then_some(())
.ok_or(ScreenVisualError::InvalidColor { value })
}
fn validate_draw_order_depth(value: f32) -> Result<(), ScreenVisualError> {
value
.is_finite()
.then_some(())
.ok_or(ScreenVisualError::InvalidDrawOrderDepth { value })
}
#[cfg(test)]
mod tests {
use super::*;
fn state_bits(visual: ScreenRectangleVisual) -> [u32; 9] {
let position = visual.position().to_vec2();
let size = visual.size().to_vec2();
[
position.x(),
position.y(),
size.x(),
size.y(),
visual.color().red(),
visual.color().green(),
visual.color().blue(),
visual.color().alpha(),
visual.draw_order_depth(),
]
.map(f32::to_bits)
}
#[test]
fn finite_offscreen_and_small_representable_geometry_is_preserved()
-> Result<(), ScreenVisualError> {
let position = LogicalScreenPosition::new(-40.0, 9_000.0);
let size = LogicalScreenVector::new(20.0, 10.0);
let mut visual = ScreenRectangleVisual::new(position, size, Color::WHITE)?;
assert_eq!(visual.position(), position);
assert_eq!(visual.size(), size);
assert_eq!(visual.layer(), Layer::DEFAULT);
assert_eq!(visual.draw_order_depth(), 0.0);
let subnormal = f32::from_bits(1);
visual.set_geometry(
LogicalScreenPosition::new(-0.0, 0.0),
LogicalScreenVector::new(subnormal, subnormal),
)?;
assert_eq!(
visual.position().to_vec2().x().to_bits(),
(-0.0_f32).to_bits()
);
assert_eq!(visual.size().to_vec2().x().to_bits(), 1);
visual.set_layer(Layer::new(-3));
visual.set_draw_order_depth(-2.0)?;
visual.set_color(Color::TRANSPARENT)?;
assert_eq!(visual.layer(), Layer::new(-3));
assert_eq!(visual.draw_order_depth(), -2.0);
assert_eq!(visual.color(), Color::TRANSPARENT);
Ok(())
}
#[test]
fn constructors_reject_nonfinite_nonpositive_and_unrepresentable_geometry() {
let origin = LogicalScreenPosition::default();
let unit = LogicalScreenVector::new(1.0, 1.0);
for value in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
for position in [
LogicalScreenPosition::new(value, 0.0),
LogicalScreenPosition::new(0.0, value),
] {
assert!(matches!(
ScreenRectangleVisual::new(position, unit, Color::WHITE),
Err(ScreenVisualError::InvalidPosition { .. })
));
}
}
for value in [0.0, -0.0, -1.0, f32::NAN, f32::INFINITY] {
for size in [
LogicalScreenVector::new(value, 1.0),
LogicalScreenVector::new(1.0, value),
] {
assert!(matches!(
ScreenRectangleVisual::new(origin, size, Color::WHITE),
Err(ScreenVisualError::InvalidSize { .. })
));
}
}
for (position, size) in [
(
LogicalScreenPosition::new(f32::MAX, 0.0),
LogicalScreenVector::new(f32::MAX, 1.0),
),
(
LogicalScreenPosition::new(0.0, f32::MAX),
LogicalScreenVector::new(1.0, f32::MAX),
),
(LogicalScreenPosition::new(16_777_216.0, 0.0), unit),
(LogicalScreenPosition::new(0.0, 16_777_216.0), unit),
] {
assert!(matches!(
ScreenRectangleVisual::new(position, size, Color::WHITE),
Err(ScreenVisualError::InvalidBounds { .. })
));
}
assert!(matches!(
ScreenRectangleVisual::new(origin, unit, Color::rgb(2.0, 0.0, 0.0)),
Err(ScreenVisualError::InvalidColor { .. })
));
}
#[test]
fn failed_setters_preserve_every_prior_bit() -> Result<(), ScreenVisualError> {
let mut visual = ScreenRectangleVisual::new(
LogicalScreenPosition::new(-0.0, -0.0),
LogicalScreenVector::new(16.0, 8.0),
Color::rgba(-0.0, 0.25, 0.5, 1.0),
)?;
visual.set_draw_order_depth(-0.0)?;
visual.set_layer(Layer::new(7));
let before = state_bits(visual);
assert!(
visual
.set_geometry(
LogicalScreenPosition::new(3.0, 4.0),
LogicalScreenVector::new(0.0, 1.0)
)
.is_err()
);
assert_eq!(state_bits(visual), before);
assert!(
visual
.set_position(LogicalScreenPosition::new(f32::MAX, 0.0))
.is_err()
);
assert_eq!(state_bits(visual), before);
assert!(
visual
.set_size(LogicalScreenVector::new(1.0, f32::NAN))
.is_err()
);
assert_eq!(state_bits(visual), before);
for value in [f32::NAN, f32::INFINITY, -0.1, 1.1] {
assert!(visual.set_color(Color::WHITE.with_alpha(value)).is_err());
assert_eq!(state_bits(visual), before);
}
for value in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
assert!(visual.set_draw_order_depth(value).is_err());
assert_eq!(state_bits(visual), before);
}
assert_eq!(visual.layer(), Layer::new(7));
Ok(())
}
#[test]
fn geometry_setter_validates_the_requested_pair_together() -> Result<(), ScreenVisualError> {
let mut visual = ScreenRectangleVisual::new(
LogicalScreenPosition::default(),
LogicalScreenVector::new(1.0, 1.0),
Color::WHITE,
)?;
let position = LogicalScreenPosition::new(16_777_216.0, 16_777_216.0);
let size = LogicalScreenVector::new(2.0, 2.0);
assert!(visual.set_position(position).is_err());
visual.set_geometry(position, size)?;
assert_eq!(visual.position(), position);
assert_eq!(visual.size(), size);
assert!(visual.set_size(LogicalScreenVector::new(1.0, 1.0)).is_err());
assert_eq!(visual.size(), size);
Ok(())
}
}