22struct LinearGradientNormalized {
24 std::vector<Color> colors;
25 std::vector<float> positions;
29LinearGradientNormalized Normalize(LinearGradient gradient) {
31 if (gradient.stops.empty()) {
32 return LinearGradientNormalized{
40 if (!gradient.stops.front().position) {
41 gradient.stops.front().position = 0.F;
43 if (!gradient.stops.back().position) {
44 gradient.stops.back().position = 1.F;
48 size_t last_checkpoint = 0;
49 for (
size_t i = 1; i < gradient.stops.size(); ++i) {
50 if (!gradient.stops[i].position) {
54 if (i - last_checkpoint >= 2) {
55 const float min = gradient.stops[i].position.value();
57 gradient.stops[last_checkpoint].position.value();
58 for (
size_t j = last_checkpoint + 1; j < i; ++j) {
59 gradient.stops[j].position = min + (max - min) *
60 float(j - last_checkpoint) /
61 float(i - last_checkpoint);
70 gradient.stops.begin(), gradient.stops.end(),
71 [](
const auto& a,
const auto& b) { return a.position < b.position; });
74 if (gradient.stops.front().position != 0) {
75 gradient.stops.insert(gradient.stops.begin(),
76 {gradient.stops.front().color, 0.F});
79 if (gradient.stops.back().position != 1) {
80 gradient.stops.push_back({gradient.stops.back().
color, 1.F});
84 LinearGradientNormalized normalized;
85 const float modulo = 360.F;
87 std::fmod(std::fmod(gradient.angle, modulo) + modulo, modulo);
88 for (
auto& stop : gradient.stops) {
89 normalized.colors.push_back(stop.color);
91 normalized.positions.push_back(stop.position.value());
96Color Interpolate(
const LinearGradientNormalized& gradient,
float t) {
100 if (i > gradient.positions.size()) {
101 const float half = 0.5F;
103 gradient.colors.back());
105 if (t <= gradient.positions[i]) {
111 const float t0 = gradient.positions[i - 1];
112 const float t1 = gradient.positions[i - 0];
113 const float tt = (t - t0) / (t1 - t0);
115 const Color& c0 = gradient.colors[i - 1];
116 const Color& c1 = gradient.colors[i - 0];
122class LinearGradientColor :
public NodeDecorator {
124 explicit LinearGradientColor(
Element child,
125 const LinearGradient& gradient,
126 bool background_color)
127 : NodeDecorator(std::move(child)),
128 gradient_(Normalize(gradient)),
129 background_color_{background_color} {}
132 void Render(Screen& screen)
override {
133 const float degtorad = 0.01745329251F;
134 const float dx = std::cos(gradient_.angle * degtorad);
135 const float dy = std::sin(gradient_.angle * degtorad);
138 const float p1 = float(box_.x_min) * dx + float(box_.y_min) * dy;
139 const float p2 = float(box_.x_min) * dx + float(box_.y_max) * dy;
140 const float p3 = float(box_.x_max) * dx + float(box_.y_min) * dy;
141 const float p4 = float(box_.x_max) * dx + float(box_.y_max) * dy;
142 const float min = std::min({p1, p2, p3, p4});
143 const float max = std::max({p1, p2, p3, p4});
147 const float dX = dx / (max - min);
148 const float dY = dy / (max - min);
149 const float dZ = -min / (max - min);
152 if (background_color_) {
153 for (
int y = box_.y_min; y <= box_.y_max; ++y) {
154 for (
int x = box_.x_min; x <= box_.x_max; ++x) {
155 const float t = float(x) * dX + float(y) * dY + dZ;
156 screen.PixelAt(x, y).background_color = Interpolate(gradient_, t);
160 for (
int y = box_.y_min; y <= box_.y_max; ++y) {
161 for (
int x = box_.x_min; x <= box_.x_max; ++x) {
162 const float t = float(x) * dX + float(y) * dY + dZ;
163 screen.PixelAt(x, y).foreground_color = Interpolate(gradient_, t);
171 LinearGradientNormalized gradient_;
172 bool background_color_;
204 stops.push_back({begin, {}});
205 stops.push_back({end, {}});
222 stops.push_back({c, p});
232 stops.push_back({c, {}});
248 return std::make_shared<LinearGradientColor>(std::move(child), gradient,
264 return std::make_shared<LinearGradientColor>(std::move(child), gradient,
280 [gradient](
Element child) {
return color(gradient, std::move(child)); };
295 [gradient](
Element child) {
return bgcolor(gradient, std::move(child)); };
A class representing terminal colors.
static Color Interpolate(float t, const Color &a, const Color &b)
virtual void Render(Screen &screen)
Display an element on a ftxui::Screen.
Decorator bgcolor(Color)
Decorate using a background color.
std::function< Element(Element)> Decorator
std::shared_ptr< Node > Element
void Render(Screen &screen, const Element &element)
Display an element on a ftxui::Screen.
Decorator color(Color)
Decorate using a foreground color.
A class representing the settings for linear-gradient color effect.
LinearGradient & Stop(Color color, float position)
Add a color stop to the gradient.
LinearGradient & Angle(float angle)
Set the angle of the gradient.
LinearGradient()
Build the "empty" gradient. This is often followed by calls to LinearGradient::Angle() and LinearGrad...
std::vector< Stop > stops