1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use crate::prelude::{HSV, RGB};
use core::iter::{ExactSizeIterator, Iterator};
use std::convert::TryInto;

/// Implements an RGB Lerp as an iterator
pub struct RgbLerp {
    /// Starting color
    start: RGB,
    /// Ending color
    end: RGB,
    /// Number of lerp steps
    n_steps: usize,
    /// Current step (modified by the iterator)
    step: usize,
}

impl RgbLerp {
    /// Creates a new RGB iterator
    #[inline]
    pub fn new<T>(start: RGB, end: RGB, steps: T) -> Self
    where
        T: TryInto<usize>,
    {
        Self {
            start,
            end,
            n_steps: steps
                .try_into()
                .ok()
                .expect("Not a usize-convertible integer"),
            step: 0,
        }
    }
}

impl Iterator for RgbLerp {
    type Item = RGB;

    /// Returns the next step in the iterator
    #[inline]
    #[allow(clippy::cast_precision_loss)]
    fn next(&mut self) -> Option<RGB> {
        if self.step > self.n_steps {
            None
        } else {
            let percent = self.step as f32 / self.n_steps as f32;
            self.step += 1;

            Some(self.start.lerp(self.end, percent))
        }
    }
}

impl ExactSizeIterator for RgbLerp {
    /// Returns the `n_steps` component of the iterator
    #[inline]
    #[must_use]
    fn len(&self) -> usize {
        self.n_steps
    }
}

/// An HSV Lerp - transition from one HSV color to another in a set number of steps.
pub struct HsvLerp {
    /// The starting color
    start: HSV,
    /// The ending color
    end: HSV,
    /// The number of steps to use
    n_steps: usize,
    /// The current step (modified by the iterator)
    step: usize,
}

impl HsvLerp {
    /// Creates a new `HsvLerp` iterator.
    #[inline]
    pub fn new<T>(start: HSV, end: HSV, steps: T) -> Self
    where
        T: TryInto<usize>,
    {
        Self {
            start,
            end,
            n_steps: steps.try_into().ok().expect("Not an integer"),
            step: 0,
        }
    }
}

impl Iterator for HsvLerp {
    type Item = HSV;

    /// Returns the next Lerp step
    #[inline]
    #[allow(clippy::cast_precision_loss)]
    fn next(&mut self) -> Option<HSV> {
        if self.step > self.n_steps {
            None
        } else {
            let percent = self.step as f32 / self.n_steps as f32;
            self.step += 1;

            Some(self.start.lerp(self.end, percent))
        }
    }
}

impl ExactSizeIterator for HsvLerp {
    #[inline]
    #[must_use]
    fn len(&self) -> usize {
        self.n_steps
    }
}