From 6551a0b2ab6c831dd1d3646ecf55180339275e22 Mon Sep 17 00:00:00 2001
From: Bingus <shankern@protonmail.com>
Date: Thu, 11 May 2023 09:12:06 -0700
Subject: Added support for gradients as background variants + other
optimizations.
---
core/src/angle.rs | 33 +++++++++
core/src/background.rs | 14 +++-
core/src/gradient.rs | 176 ++++++++++++++++++++++++--------------------
core/src/gradient/linear.rs | 112 ----------------------------
core/src/lib.rs | 2 +
core/src/renderer.rs | 2 +-
6 files changed, 143 insertions(+), 196 deletions(-)
create mode 100644 core/src/angle.rs
delete mode 100644 core/src/gradient/linear.rs
(limited to 'core/src')
diff --git a/core/src/angle.rs b/core/src/angle.rs
new file mode 100644
index 00000000..75a57c76
--- /dev/null
+++ b/core/src/angle.rs
@@ -0,0 +1,33 @@
+use crate::{Point, Rectangle, Vector};
+use std::f32::consts::PI;
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+/// Degrees
+pub struct Degrees(pub f32);
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+/// Radians
+pub struct Radians(pub f32);
+
+impl From<Degrees> for Radians {
+ fn from(degrees: Degrees) -> Self {
+ Radians(degrees.0 * PI / 180.0)
+ }
+}
+
+impl Radians {
+ /// Calculates the line in which the [`Angle`] intercepts the `bounds`.
+ pub fn to_distance(&self, bounds: &Rectangle) -> (Point, Point) {
+ let v1 = Vector::new(f32::cos(self.0), f32::sin(self.0));
+
+ let distance_to_rect = f32::min(
+ f32::abs((bounds.y - bounds.center().y) / v1.y),
+ f32::abs(((bounds.x + bounds.width) - bounds.center().x) / v1.x),
+ );
+
+ let start = bounds.center() + v1 * distance_to_rect;
+ let end = bounds.center() - v1 * distance_to_rect;
+
+ (start, end)
+ }
+}
diff --git a/core/src/background.rs b/core/src/background.rs
index cfb95867..6af33c3e 100644
--- a/core/src/background.rs
+++ b/core/src/background.rs
@@ -1,11 +1,13 @@
-use crate::Color;
+use crate::{Color, Gradient};
/// The background of some element.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Background {
- /// A solid color
+ /// A solid color.
Color(Color),
- // TODO: Add gradient and image variants
+ /// Linearly interpolate between several colors.
+ Gradient(Gradient),
+ // TODO: Add image variant
}
impl From<Color> for Background {
@@ -19,3 +21,9 @@ impl From<Color> for Option<Background> {
Some(Background::from(color))
}
}
+
+impl From<Gradient> for Option<Background> {
+ fn from(gradient: Gradient) -> Self {
+ Some(Background::Gradient(gradient))
+ }
+}
diff --git a/core/src/gradient.rs b/core/src/gradient.rs
index 61e919d6..54bb86a4 100644
--- a/core/src/gradient.rs
+++ b/core/src/gradient.rs
@@ -1,27 +1,42 @@
//! For creating a Gradient.
-pub mod linear;
-
pub use linear::Linear;
-use crate::{Color, Point, Size};
+use crate::{Color, Radians};
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
/// A fill which transitions colors progressively along a direction, either linearly, radially (TBD),
/// or conically (TBD).
+///
+/// For a gradient which can be used as a fill on a canvas, see [`iced_graphics::Gradient`].
pub enum Gradient {
- /// A linear gradient interpolates colors along a direction from its `start` to its `end`
- /// point.
+ /// A linear gradient interpolates colors along a direction at a specific [`Angle`].
Linear(Linear),
}
impl Gradient {
/// Creates a new linear [`linear::Builder`].
- pub fn linear(position: impl Into<Position>) -> linear::Builder {
- linear::Builder::new(position.into())
+ ///
+ /// This must be defined by an angle (in [`Degrees`] or [`Radians`])
+ /// which will use the bounds of the widget as a guide.
+ pub fn linear(angle: impl Into<Radians>) -> linear::Builder {
+ linear::Builder::new(angle.into())
+ }
+
+ /// Adjust the opacity of the gradient by a multiplier applied to each color stop.
+ pub fn mul_alpha(mut self, alpha_multiplier: f32) -> Self {
+ match &mut self {
+ Gradient::Linear(linear) => {
+ for stop in linear.color_stops.iter_mut().flatten() {
+ stop.color.a *= alpha_multiplier;
+ }
+ }
+ }
+
+ self
}
}
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Default, Clone, Copy, PartialEq)]
/// A point along the gradient vector where the specified [`color`] is unmixed.
///
/// [`color`]: Self::color
@@ -35,83 +50,84 @@ pub struct ColorStop {
pub color: Color,
}
-#[derive(Debug)]
-/// The position of the gradient within its bounds.
-pub enum Position {
- /// The gradient will be positioned with respect to two points.
- Absolute {
- /// The starting point of the gradient.
- start: Point,
- /// The ending point of the gradient.
- end: Point,
- },
- /// The gradient will be positioned relative to the provided bounds.
- Relative {
- /// The top left position of the bounds.
- top_left: Point,
- /// The width & height of the bounds.
- size: Size,
- /// The start [Location] of the gradient.
- start: Location,
- /// The end [Location] of the gradient.
- end: Location,
- },
-}
+pub mod linear {
+ //! Linear gradient builder & definition.
+ use crate::gradient::{ColorStop, Gradient};
+ use crate::{Color, Radians};
+ use std::cmp::Ordering;
-impl From<(Point, Point)> for Position {
- fn from((start, end): (Point, Point)) -> Self {
- Self::Absolute { start, end }
+ /// A linear gradient that can be used as a [`Background`].
+ #[derive(Debug, Clone, Copy, PartialEq)]
+ pub struct Linear {
+ /// How the [`Gradient`] is angled within its bounds.
+ pub angle: Radians,
+ /// [`ColorStop`]s along the linear gradient path.
+ pub color_stops: [Option<ColorStop>; 8],
}
-}
-#[derive(Debug, Clone, Copy)]
-/// The location of a relatively-positioned gradient.
-pub enum Location {
- /// Top left.
- TopLeft,
- /// Top.
- Top,
- /// Top right.
- TopRight,
- /// Right.
- Right,
- /// Bottom right.
- BottomRight,
- /// Bottom.
- Bottom,
- /// Bottom left.
- BottomLeft,
- /// Left.
- Left,
-}
+ /// A [`Linear`] builder.
+ #[derive(Debug)]
+ pub struct Builder {
+ angle: Radians,
+ stops: [Option<ColorStop>; 8],
+ }
-impl Location {
- fn to_absolute(self, top_left: Point, size: Size) -> Point {
- match self {
- Location::TopLeft => top_left,
- Location::Top => {
- Point::new(top_left.x + size.width / 2.0, top_left.y)
- }
- Location::TopRight => {
- Point::new(top_left.x + size.width, top_left.y)
- }
- Location::Right => Point::new(
- top_left.x + size.width,
- top_left.y + size.height / 2.0,
- ),
- Location::BottomRight => {
- Point::new(top_left.x + size.width, top_left.y + size.height)
- }
- Location::Bottom => Point::new(
- top_left.x + size.width / 2.0,
- top_left.y + size.height,
- ),
- Location::BottomLeft => {
- Point::new(top_left.x, top_left.y + size.height)
+ impl Builder {
+ /// Creates a new [`Builder`].
+ pub fn new(angle: Radians) -> Self {
+ Self {
+ angle,
+ stops: [None; 8],
}
- Location::Left => {
- Point::new(top_left.x, top_left.y + size.height / 2.0)
+ }
+
+ /// Adds a new [`ColorStop`], defined by an offset and a color, to the gradient.
+ ///
+ /// Any `offset` that is not within `0.0..=1.0` will be silently ignored.
+ ///
+ /// Any stop added after the 8th will be silently ignored.
+ pub fn add_stop(mut self, offset: f32, color: Color) -> Self {
+ if offset.is_finite() && (0.0..=1.0).contains(&offset) {
+ let (Ok(index) | Err(index)) =
+ self.stops.binary_search_by(|stop| match stop {
+ None => Ordering::Greater,
+ Some(stop) => stop.offset.partial_cmp(&offset).unwrap(),
+ });
+
+ if index < 8 {
+ self.stops[index] = Some(ColorStop { offset, color });
+ }
+ } else {
+ log::warn!(
+ "Gradient color stop must be within 0.0..=1.0 range."
+ );
+ };
+
+ self
+ }
+
+ /// Adds multiple [`ColorStop`]s to the gradient.
+ ///
+ /// Any stop added after the 8th will be silently ignored.
+ pub fn add_stops(
+ mut self,
+ stops: impl IntoIterator<Item = ColorStop>,
+ ) -> Self {
+ for stop in stops.into_iter() {
+ self = self.add_stop(stop.offset, stop.color)
}
+
+ self
+ }
+
+ /// Builds the linear [`Gradient`] of this [`Builder`].
+ ///
+ /// Returns `BuilderError` if gradient in invalid.
+ pub fn build(self) -> Gradient {
+ Gradient::Linear(Linear {
+ angle: self.angle,
+ color_stops: self.stops,
+ })
}
}
}
diff --git a/core/src/gradient/linear.rs b/core/src/gradient/linear.rs
deleted file mode 100644
index c886db47..00000000
--- a/core/src/gradient/linear.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-//! Linear gradient builder & definition.
-use crate::gradient::{ColorStop, Gradient, Position};
-use crate::{Color, Point};
-
-/// A linear gradient that can be used in the style of [`Fill`] or [`Stroke`].
-///
-/// [`Fill`]: crate::widget::canvas::Fill
-/// [`Stroke`]: crate::widget::canvas::Stroke
-#[derive(Debug, Clone, PartialEq)]
-pub struct Linear {
- /// The point where the linear gradient begins.
- pub start: Point,
- /// The point where the linear gradient ends.
- pub end: Point,
- /// [`ColorStop`]s along the linear gradient path.
- pub color_stops: Vec<ColorStop>,
-}
-
-/// A [`Linear`] builder.
-#[derive(Debug)]
-pub struct Builder {
- start: Point,
- end: Point,
- stops: Vec<ColorStop>,
- error: Option<BuilderError>,
-}
-
-impl Builder {
- /// Creates a new [`Builder`].
- pub fn new(position: Position) -> Self {
- let (start, end) = match position {
- Position::Absolute { start, end } => (start, end),
- Position::Relative {
- top_left,
- size,
- start,
- end,
- } => (
- start.to_absolute(top_left, size),
- end.to_absolute(top_left, size),
- ),
- };
-
- Self {
- start,
- end,
- stops: vec![],
- error: None,
- }
- }
-
- /// Adds a new stop, defined by an offset and a color, to the gradient.
- ///
- /// `offset` must be between `0.0` and `1.0` or the gradient cannot be built.
- ///
- /// Note: when using the [`glow`] backend, any color stop added after the 16th
- /// will not be displayed.
- ///
- /// On the [`wgpu`] backend this limitation does not exist (technical limit is 524,288 stops).
- ///
- /// [`glow`]: https://docs.rs/iced_glow
- /// [`wgpu`]: https://docs.rs/iced_wgpu
- pub fn add_stop(mut self, offset: f32, color: Color) -> Self {
- if offset.is_finite() && (0.0..=1.0).contains(&offset) {
- match self.stops.binary_search_by(|stop| {
- stop.offset.partial_cmp(&offset).unwrap()
- }) {
- Ok(_) => {
- self.error = Some(BuilderError::DuplicateOffset(offset))
- }
- Err(index) => {
- self.stops.insert(index, ColorStop { offset, color });
- }
- }
- } else {
- self.error = Some(BuilderError::InvalidOffset(offset))
- };
-
- self
- }
-
- /// Builds the linear [`Gradient`] of this [`Builder`].
- ///
- /// Returns `BuilderError` if gradient in invalid.
- pub fn build(self) -> Result<Gradient, BuilderError> {
- if self.stops.is_empty() {
- Err(BuilderError::MissingColorStop)
- } else if let Some(error) = self.error {
- Err(error)
- } else {
- Ok(Gradient::Linear(Linear {
- start: self.start,
- end: self.end,
- color_stops: self.stops,
- }))
- }
- }
-}
-
-/// An error that happened when building a [`Linear`] gradient.
-#[derive(Debug, thiserror::Error)]
-pub enum BuilderError {
- #[error("Gradients must contain at least one color stop.")]
- /// Gradients must contain at least one color stop.
- MissingColorStop,
- #[error("Offset {0} must be a unique, finite number.")]
- /// Offsets in a gradient must all be unique & finite.
- DuplicateOffset(f32),
- #[error("Offset {0} must be between 0.0..=1.0.")]
- /// Offsets in a gradient must be between 0.0..=1.0.
- InvalidOffset(f32),
-}
diff --git a/core/src/lib.rs b/core/src/lib.rs
index 89dfb828..6de5ada4 100644
--- a/core/src/lib.rs
+++ b/core/src/lib.rs
@@ -42,6 +42,7 @@ pub mod touch;
pub mod widget;
pub mod window;
+mod angle;
mod background;
mod color;
mod content_fit;
@@ -57,6 +58,7 @@ mod size;
mod vector;
pub use alignment::Alignment;
+pub use angle::{Degrees, Radians};
pub use background::Background;
pub use clipboard::Clipboard;
pub use color::Color;
diff --git a/core/src/renderer.rs b/core/src/renderer.rs
index d6247e39..007a0370 100644
--- a/core/src/renderer.rs
+++ b/core/src/renderer.rs
@@ -60,7 +60,7 @@ pub struct Quad {
pub border_color: Color,
}
-/// The border radi for the corners of a graphics primitive in the order:
+/// The border radii for the corners of a graphics primitive in the order:
/// top-left, top-right, bottom-right, bottom-left.
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct BorderRadius([f32; 4]);
--
cgit