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 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
//! A `no-std` compatible library for fast color math, intended for use in programming //! addressable LEDs. //! //! Currently this library is geared toward use in embedded systems, but does contain useful //! APIs that are more generally useful. //! //! - **Fast `u8` and `u16` math** — Cichlid includes functions for scaling, dimming, and //! brightening single and double byte values. Basic trigonometric functions (sine, cosine) //! are implemented as well. //! //! - **HSV and RGB support** — Full control over each color is provided by the `HSV` and //! `ColorRGB` structures. Different means of converting from `HSV` to `ColorRGB` are also //! implemented. //! //! - **Axial (Two Point) Color Gradients** — Create smooth transitions between any two colors //! for any number of steps. //! //! - **Power Consumption Estimating** — Estimating power requirements can be done with //! structs implementing the `PowerEstimator` trait. //! //! This Library is still in its infancy, and as such there may be a lack of documentation and //! vigorous testing. //! //! # Examples //! //! General Color operations: //! //! ``` //! use cichlid::ColorRGB; //! //! let red = ColorRGB::Red; //! let blue = ColorRGB::Blue; //! let mut purple = red + blue; //! assert_eq!(purple, ColorRGB::new(255, 0, 255)); //! //! purple.scale(128); // Scale by half //! assert_eq!(purple, ColorRGB::new(128, 0, 128)); //! //! purple *= 2; // Multiple all components by two //! assert_eq!(purple, red + blue); //! ``` //! //! Using `HSV` (Hue, Saturation, Value) and converting to `ColorRGB`: //! //! ``` //! use cichlid::{HSV, ColorRGB, prelude::*}; //! //! let red_hsv = HSV::new(0, 255, 255); //! let red_rgb = ColorRGB::from(red_hsv); //! assert_eq!(red_rgb, ColorRGB::Red); //! ``` //! //! Creating a gradient is very easy, simply import the trait and call the method: //! //! ``` //! use cichlid::{HSV, ColorRGB, GradientDirection, prelude::*}; //! let mut colors = [ColorRGB::Black; 100]; //! //! let start = HSV::new(0, 255, 255); //! let end = HSV::new(100, 255, 180); //! colors.gradient_fill(start, end, GradientDirection::Longest); //! ``` //! //! We can also create rainbows from both a step size, as well as a forming a complete rainbow. //! //! ``` //! use cichlid::{HSV, ColorRGB, GradientDirection, prelude::*}; //! let mut colors = [ColorRGB::Black; 256]; //! //! let start_hue: u8 = 0; //! let hue_delta: u16 = (1 << 8); //! //! colors.rainbow_fill(start_hue, hue_delta); // From step size //! colors.rainbow_fill_single_cycle(start_hue); // Complete rainbow //! ``` //! //! # no-std //! //! To use in a `no-std` environment, simply add the following to your project's `cargo.toml`: //! //! ```ignore //! [dependencies.cichlid] //! version = "*" //! features = ["no-std"] //! ``` //! //! # Low memory usage //! //! The `low-mem` feature creates a binary that is smaller due to relying less on in memory //! tables, preferring direct computation instead. The only drawback of this is a slight //! speed decrease. //! //! # Nightly features //! //! To use some unstable nightly features and optimizations, use the `nightly` feature flag. //! //! # Acknowledgements //! //! This library takes heavy inspiration and code-reuse from //! [FastLED](https://github.com/FastLED/FastLED), an Arduino library for talking to addressable //! LEDs. // TODO: SERDE #![cfg_attr(feature = "no-std", no_std)] #![cfg_attr(feature = "nightly", feature(link_llvm_intrinsics))] //#![feature(link_llvm_intrinsics)] macro_rules! mk_rgb { ($r:expr, $g:expr, $b:expr) => { crate::rgb::ColorRGB::new($r, $g, $b) }; ($f_rgb:expr) => { crate::rgb::ColorRGB::from($f_rgb) }; } //macro_rules! HSV { // ($h:expr, $s:expr, $v:expr) => {crate::hsv::HSV::new($h, $s, $v)}; // ($h:expr) => {crate::hsv::HSV::new($h, 255, 255)}; //} pub mod color_codes; mod color_util; mod hsv; pub mod math; mod power_mgmt; mod rgb; pub use crate::color_util::GradientDirection; pub use crate::hsv::HSV; pub use crate::power_mgmt::{DefaultPowerEstimator, PowerEstimator}; pub use crate::rgb::ColorRGB; pub use crate::color_util::gradient::{hsv_gradient,rgb_gradient}; pub mod prelude { //! Easy importing of integer and color auto traits. pub use crate::math::ScalingInt; pub use crate::math::Trig; pub use crate::color_util::ColorIterMut; pub use crate::color_util::ColorSliceMut; pub use crate::color_util::GradientFill; pub use crate::color_util::GradientFillToInclusive; pub use crate::color_util::GradientFillRGB; pub use crate::color_util::GradientFillRGBToInclusive; pub use crate::color_util::RainbowFill; pub use crate::color_util::RainbowFillSingleCycle; }