react-native-vroom-chart 0.14.0 → 0.16.0

package/cpp/_core_src/chart.cpp

@@ -20,11 +20,16 @@
 #include "include/core/SkRect.h"
 #pragma clang diagnostic pop
 
+#include "atr.h"
+#include "atr_pane.h"
 #include "bollinger.h"
 #include "candles.h"
 #include "chart_internal.h"
 #include "crosshair.h"
 #include "drawings.h"
+#include "footprints.h"
+#include "fvg_overlay.h"
+#include "ichimoku.h"
 #include "labels.h"
 #include "liquidity.h"
 #include "ma.h"
@@ -58,7 +63,8 @@ vroom::Layout VroomChart::layout() const {
     const float axis_w = axis_width_px > 0.f
         ? axis_width_px
         : width_px * theme.floats[VROOM_FLOAT_Y_AXIS_WIDTH_RATIO];
-    const int pane_count = (rsi.enabled ? 1 : 0) + (macd.enabled ? 1 : 0);
+    const int pane_count =
+        (rsi.enabled ? 1 : 0) + (macd.enabled ? 1 : 0) + (atr.enabled ? 1 : 0);
     const float indicator_h = static_cast<float>(pane_count) * height_px *
                               theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
     return vroom::Layout{
@@ -98,6 +104,90 @@ void VroomChart::ensure_macd() {
     macd_dirty = false;
 }
 
+void VroomChart::ensure_atr() {
+    if (!atr.enabled || !atr_dirty) return;
+    vroom::atr::compute(candles.data(), candles.size(), atr.period,
+                        atr.smoothing, atr_cache);
+    atr_dirty = false;
+}
+
+int VroomChart::indicator_panes(vroom::IndicatorPane out[vroom::kMaxPanes]) const {
+    int count = 0;
+    if (rsi.enabled) out[count++] = {rsi_order, vroom::PaneKind::Rsi};
+    if (macd.enabled) out[count++] = {macd_order, vroom::PaneKind::Macd};
+    if (atr.enabled) out[count++] = {atr_order, vroom::PaneKind::Atr};
+    // Insertion sort: at most three entries, already nearly ordered.
+    for (int i = 1; i < count; ++i) {
+        const vroom::IndicatorPane key = out[i];
+        int j = i - 1;
+        for (; j >= 0 && out[j].order > key.order; --j) out[j + 1] = out[j];
+        out[j + 1] = key;
+    }
+    return count;
+}
+
+void VroomChart::draw_indicator_panes(SkCanvas* canvas,
+                                      const vroom::Layout& lay,
+                                      const VroomCandle* visible,
+                                      std::size_t n, std::size_t first,
+                                      int64_t window_ms, float candle_right,
+                                      float pane_top, bool use_capture,
+                                      float morph_t) {
+    vroom::IndicatorPane panes[vroom::kMaxPanes];
+    const int count = indicator_panes(panes);
+    const float pane_h =
+        height_px * theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
+
+    // A cache only lines up with the candles once its ensure_* has run against
+    // the current series; until then there is nothing to plot.
+    const auto visible_slice = [&](const std::vector<double>& cache) -> const double* {
+        return cache.size() == candles.size() ? cache.data() + first : nullptr;
+    };
+    const auto capture = [&](vroom::LineKey key) -> const vroom::LineMorph* {
+        return use_capture ? vroom::find_line_morph(morph_lines, key) : nullptr;
+    };
+
+    for (int i = 0; i < count; ++i) {
+        const float pane_bottom = pane_top + pane_h;
+        switch (panes[i].kind) {
+            case vroom::PaneKind::Rsi: {
+                ensure_rsi();
+                vroom::rsi_pane::draw(
+                    canvas, *this, lay, visible, n, visible_slice(rsi_cache),
+                    rsi.ma_visible ? visible_slice(rsi_ma_cache) : nullptr,
+                    window_ms, visible_start_ms, candle_duration_ms,
+                    candle_right, pane_top, pane_bottom,
+                    capture({vroom::LineKind::Rsi}),
+                    rsi.ma_visible ? capture({vroom::LineKind::RsiMa}) : nullptr,
+                    morph_t);
+                break;
+            }
+            case vroom::PaneKind::Macd: {
+                ensure_macd();
+                vroom::macd_pane::draw(
+                    canvas, *this, lay, visible, n, visible_slice(macd_cache),
+                    visible_slice(macd_signal_cache),
+                    visible_slice(macd_hist_cache), window_ms, visible_start_ms,
+                    candle_duration_ms, candle_right, pane_top, pane_bottom,
+                    capture({vroom::LineKind::Macd}),
+                    capture({vroom::LineKind::MacdSignal}),
+                    capture({vroom::LineKind::MacdHistogram}), morph_t);
+                break;
+            }
+            case vroom::PaneKind::Atr: {
+                ensure_atr();
+                vroom::atr_pane::draw(canvas, *this, lay, visible, n,
+                                      visible_slice(atr_cache), window_ms,
+                                      visible_start_ms, candle_duration_ms,
+                                      candle_right, pane_top, pane_bottom,
+                                      capture({vroom::LineKind::Atr}), morph_t);
+                break;
+            }
+        }
+        pane_top = pane_bottom;
+    }
+}
+
 void VroomChart::ensure_overlays() {
     if (!overlays_dirty) return;
     overlay_caches.resize(overlays.size());
@@ -125,6 +215,326 @@ void VroomChart::ensure_bollinger() {
     bollinger_dirty = false;
 }
 
+void VroomChart::ensure_ichimoku() {
+    if (!ichimoku.enabled || !ichimoku_dirty) return;
+    vroom::ichimoku::compute(candles.data(), candles.size(),
+                             ichimoku.tenkan_period, ichimoku.kijun_period,
+                             ichimoku.senkou_b_period, ich_tenkan_cache,
+                             ich_kijun_cache, ich_senkou_a_cache,
+                             ich_senkou_b_cache, ich_chikou_cache);
+    ichimoku_dirty = false;
+}
+
+void VroomChart::ensure_fvg() {
+    if (!fvg.enabled || !fvg_dirty) return;
+    vroom::fvg::compute(candles.data(), candles.size(), fvg.max_bars_back,
+                        fvg.wait_for_close != 0, fvg.fill_type, fvg_cache);
+    fvg_dirty = false;
+}
+
+void VroomChart::ensure_footprint_buckets() {
+    if (!footprint_buckets_dirty) return;
+    footprint_buckets = vroom::footprints::build_buckets(
+        candles.data(), candles.size(), candle_duration_ms, footprints.data(),
+        footprints.size());
+    footprint_buckets_dirty = false;
+}
+
+vroom::IndexRange VroomChart::ichimoku_source_range(int64_t shift_ms) const {
+    return vroom::ichimoku::shifted_source_range(
+        candles.data(), candles.size(), visible_start_ms - candle_duration_ms,
+        visible_end_ms + candle_duration_ms, shift_ms);
+}
+
+void VroomChart::draw_overlay_fills(SkCanvas* canvas, const vroom::Layout& lay,
+                                    const vroom::PriceBounds& bounds,
+                                    const VroomCandle* visible, std::size_t n,
+                                    std::size_t first, int64_t window_ms,
+                                    float candle_right, float candle_area_h,
+                                    bool use_capture, float morph_t) {
+    const std::size_t sz = candles.size();
+    const auto capture = [&](vroom::LineKey key) -> const vroom::LineMorph* {
+        return use_capture ? vroom::find_line_morph(morph_lines, key) : nullptr;
+    };
+
+    if (bollinger.enabled) {
+        ensure_bollinger();
+        if (bollinger.fill_enabled && bb_upper_cache.size() == sz &&
+            bb_lower_cache.size() == sz) {
+            vroom::ma_overlay::fill_between(
+                canvas, lay, bounds, visible, n, bb_upper_cache.data() + first,
+                bb_lower_cache.data() + first, window_ms, visible_start_ms,
+                candle_duration_ms, candle_right, candle_area_h,
+                bollinger.upper_color, bollinger.fill_opacity,
+                capture({vroom::LineKind::BollingerUpper}),
+                capture({vroom::LineKind::BollingerLower}), morph_t);
+        }
+    }
+
+    if (ichimoku.enabled && ichimoku.cloud_enabled) {
+        ensure_ichimoku();
+        if (ich_senkou_a_cache.size() == sz && ich_senkou_b_cache.size() == sz) {
+            const int64_t shift_ms =
+                static_cast<int64_t>(ichimoku.displacement) * candle_duration_ms;
+            const auto r = ichimoku_source_range(shift_ms);
+            // A fade's outgoing half has no new data to slice, but its capture
+            // still has to paint.
+            const bool has_new = n > 0 && r.end > r.start;
+            vroom::ma_overlay::fill_cloud(
+                canvas, lay, bounds,
+                has_new ? candles.data() + r.start : candles.data(),
+                has_new ? r.end - r.start : 0,
+                has_new ? ich_senkou_a_cache.data() + r.start : nullptr,
+                has_new ? ich_senkou_b_cache.data() + r.start : nullptr,
+                window_ms, visible_start_ms, candle_duration_ms, candle_right,
+                candle_area_h, ichimoku.bullish_cloud_color,
+                ichimoku.bearish_cloud_color, ichimoku.cloud_opacity, shift_ms,
+                capture({vroom::LineKind::IchimokuSenkouA}),
+                capture({vroom::LineKind::IchimokuSenkouB}), morph_t);
+        }
+    }
+}
+
+void VroomChart::draw_overlay_lines(SkCanvas* canvas, const vroom::Layout& lay,
+                                    const vroom::PriceBounds& bounds,
+                                    const VroomCandle* visible, std::size_t n,
+                                    std::size_t first, int64_t window_ms,
+                                    float candle_right, float candle_area_h,
+                                    bool use_capture, float morph_t) {
+    const std::size_t sz = candles.size();
+    const auto capture = [&](vroom::LineKey key) -> const vroom::LineMorph* {
+        return use_capture ? vroom::find_line_morph(morph_lines, key) : nullptr;
+    };
+    // One price-pane line against the visible slice. `n == 0` (a fade's
+    // outgoing half) leaves only the capture to draw.
+    const auto stroke = [&](vroom::LineKey key, const std::vector<double>& cache,
+                            uint32_t color, float width,
+                            const unsigned char* breaks) {
+        if (cache.size() != sz) return;
+        vroom::ma_overlay::draw(canvas, lay, bounds, visible, n,
+                                cache.data() + first, window_ms,
+                                visible_start_ms, candle_duration_ms,
+                                candle_right, candle_area_h, color, width,
+                                breaks, 1.f, 0, capture(key), morph_t);
+    };
+
+    if (!overlays.empty()) {
+        ensure_overlays();
+        for (std::size_t k = 0; k < overlays.size(); ++k) {
+            stroke(vroom::overlay_line_key(overlays[k], k), overlay_caches[k],
+                   overlays[k].color, overlays[k].width, nullptr);
+        }
+    }
+
+    if (vwap.enabled) {
+        ensure_vwap();
+        stroke({vroom::LineKind::Vwap}, vwap_cache,
+               vroom::style::color_or(vwap.color, kVwapLine),
+               vroom::style::width_or(vwap.width, 1.5f),
+               vwap_breaks.size() == sz ? vwap_breaks.data() + first : nullptr);
+    }
+
+    if (bollinger.enabled) {
+        ensure_bollinger();
+        stroke({vroom::LineKind::BollingerUpper}, bb_upper_cache,
+               bollinger.upper_color, bollinger.upper_width, nullptr);
+        stroke({vroom::LineKind::BollingerLower}, bb_lower_cache,
+               bollinger.lower_color, bollinger.lower_width, nullptr);
+        stroke({vroom::LineKind::BollingerMiddle}, bb_middle_cache,
+               bollinger.middle_color, bollinger.middle_width, nullptr);
+    }
+
+    if (ichimoku.enabled) {
+        ensure_ichimoku();
+        const int64_t shift_ms =
+            static_cast<int64_t>(ichimoku.displacement) * candle_duration_ms;
+        // The displaced spans read from their own source slice, so they can't
+        // go through `stroke`: the query window shifts back by however far the
+        // drawing shifts forward.
+        const auto span = [&](vroom::LineKey key,
+                              const std::vector<double>& cache, uint32_t color,
+                              float width, int64_t line_shift_ms) {
+            if (cache.size() != sz) return;
+            const auto r = ichimoku_source_range(line_shift_ms);
+            const bool has_new = n > 0 && r.end > r.start;
+            vroom::ma_overlay::draw(
+                canvas, lay, bounds,
+                has_new ? candles.data() + r.start : candles.data(),
+                has_new ? r.end - r.start : 0,
+                has_new ? cache.data() + r.start : nullptr, window_ms,
+                visible_start_ms, candle_duration_ms, candle_right,
+                candle_area_h, color, width, nullptr, 1.f, line_shift_ms,
+                capture(key), morph_t);
+        };
+        // Span B under span A where the two edges touch, then the unshifted
+        // signal lines, then chikou on top of everything.
+        if (ichimoku.senkou_b_enabled) {
+            span({vroom::LineKind::IchimokuSenkouB}, ich_senkou_b_cache,
+                 ichimoku.senkou_b_color, ichimoku.senkou_b_width, shift_ms);
+        }
+        if (ichimoku.senkou_a_enabled) {
+            span({vroom::LineKind::IchimokuSenkouA}, ich_senkou_a_cache,
+                 ichimoku.senkou_a_color, ichimoku.senkou_a_width, shift_ms);
+        }
+        if (ichimoku.kijun_enabled) {
+            span({vroom::LineKind::IchimokuKijun}, ich_kijun_cache,
+                 ichimoku.kijun_color, ichimoku.kijun_width, 0);
+        }
+        if (ichimoku.tenkan_enabled) {
+            span({vroom::LineKind::IchimokuTenkan}, ich_tenkan_cache,
+                 ichimoku.tenkan_color, ichimoku.tenkan_width, 0);
+        }
+        if (ichimoku.chikou_enabled) {
+            span({vroom::LineKind::IchimokuChikou}, ich_chikou_cache,
+                 ichimoku.chikou_color, ichimoku.chikou_width, -shift_ms);
+        }
+    }
+}
+
+void VroomChart::capture_morph_lines(const vroom::Layout& lay,
+                                     const vroom::PriceBounds& bounds,
+                                     vroom::IndexRange range,
+                                     int64_t window_ms) {
+    morph_lines.clear();
+    const float area_w = vroom::candle_area_width(lay);
+    const std::size_t n = range.end - range.start;
+    if (area_w <= 0.f || window_ms <= 0 || n == 0) return;
+    const ::VroomCandle* visible = candles.data() + range.start;
+    const std::size_t sz = candles.size();
+
+    // Captures one series newest-first, matching the slot indexing every morph
+    // draw pairs on. `src` is the slice the values were drawn against — the
+    // visible one for everything except Ichimoku's displaced spans, which plot
+    // at `time_ms + shift_ms` from a window of their own. `frac` maps a value
+    // into its band; it's the only part that differs between the price pane and
+    // an indicator pane.
+    const auto capture = [&](vroom::LineKey key, const ::VroomCandle* src,
+                             std::size_t src_n, const double* values,
+                             int64_t shift_ms, double scale, auto&& frac) {
+        if (!values || src_n == 0) return;
+        vroom::LineMorph line;
+        line.key = key;
+        line.scale = scale;
+        line.pts.resize(src_n);
+        for (std::size_t k = 0; k < src_n; ++k) {
+            const std::size_t i = src_n - 1 - k;
+            const double v = values[i];
+            const bool defined = std::isfinite(v);
+            line.pts[k] = vroom::LineSnapshot{
+                vroom::candle_center_x(lay, src[i].time_ms + shift_ms,
+                                       candle_duration_ms, visible_start_ms,
+                                       window_ms) /
+                    area_w,
+                defined ? static_cast<float>(frac(v)) : 0.f,
+                defined,
+            };
+        }
+        morph_lines.push_back(std::move(line));
+    };
+
+    // Price-pane series share the band the candle capture was taken against, so
+    // they keep their position relative to the candles through the switch.
+    const auto price_frac = [&](double v) {
+        return vroom::price_fraction(bounds, v);
+    };
+    const auto price_series = [&](vroom::LineKey key,
+                                  const std::vector<double>& cache) {
+        if (cache.size() != sz) return;
+        capture(key, visible, n, cache.data() + range.start, 0, 0.0, price_frac);
+    };
+
+    if (!overlays.empty()) {
+        ensure_overlays();
+        for (std::size_t k = 0; k < overlays.size(); ++k) {
+            price_series(vroom::overlay_line_key(overlays[k], k),
+                         overlay_caches[k]);
+        }
+    }
+
+    if (vwap.enabled) {
+        ensure_vwap();
+        price_series({vroom::LineKind::Vwap}, vwap_cache);
+    }
+
+    if (bollinger.enabled) {
+        ensure_bollinger();
+        price_series({vroom::LineKind::BollingerUpper}, bb_upper_cache);
+        price_series({vroom::LineKind::BollingerMiddle}, bb_middle_cache);
+        price_series({vroom::LineKind::BollingerLower}, bb_lower_cache);
+    }
+
+    if (ichimoku.enabled) {
+        ensure_ichimoku();
+        const int64_t shift_ms =
+            static_cast<int64_t>(ichimoku.displacement) * candle_duration_ms;
+        // Same source windows draw_chart uses, so slot 0 is the same rightmost
+        // vertex on both sides of the switch even for a span running past the
+        // newest candle into empty time.
+        const auto span = [&](vroom::LineKey key,
+                              const std::vector<double>& cache,
+                              int64_t line_shift_ms) {
+            if (cache.size() != sz) return;
+            const auto r = ichimoku_source_range(line_shift_ms);
+            if (r.end <= r.start) return;
+            capture(key, candles.data() + r.start, r.end - r.start,
+                    cache.data() + r.start, line_shift_ms, 0.0, price_frac);
+        };
+        span({vroom::LineKind::IchimokuTenkan}, ich_tenkan_cache, 0);
+        span({vroom::LineKind::IchimokuKijun}, ich_kijun_cache, 0);
+        span({vroom::LineKind::IchimokuSenkouA}, ich_senkou_a_cache, shift_ms);
+        span({vroom::LineKind::IchimokuSenkouB}, ich_senkou_b_cache, shift_ms);
+        span({vroom::LineKind::IchimokuChikou}, ich_chikou_cache, -shift_ms);
+    }
+
+    // Pane series normalize against their pane's own band rather than the price
+    // one, so each pane's auto-fit is free to change across the switch without
+    // the capture moving.
+    const auto pane_slice = [&](const std::vector<double>& cache) -> const double* {
+        return cache.size() == sz ? cache.data() + range.start : nullptr;
+    };
+
+    if (rsi.enabled) {
+        ensure_rsi();
+        const auto frac = [&](double v) {
+            return vroom::rsi::band_fraction(v, rsi_y_scale);
+        };
+        capture({vroom::LineKind::Rsi}, visible, n, pane_slice(rsi_cache), 0, 0.0,
+                frac);
+        if (rsi.ma_visible) {
+            capture({vroom::LineKind::RsiMa}, visible, n,
+                    pane_slice(rsi_ma_cache), 0, 0.0, frac);
+        }
+    }
+
+    if (macd.enabled) {
+        ensure_macd();
+        const double* line = pane_slice(macd_cache);
+        const double* signal = pane_slice(macd_signal_cache);
+        const double* hist = pane_slice(macd_hist_cache);
+        const double scale = vroom::macd::autoscale(
+            macd.line_visible ? line : nullptr,
+            macd.signal_visible ? signal : nullptr,
+            macd.hist_visible ? hist : nullptr, n);
+        const auto frac = [&](double v) {
+            return vroom::macd::band_fraction(v, scale, macd_y_scale);
+        };
+        capture({vroom::LineKind::Macd}, visible, n, line, 0, scale, frac);
+        capture({vroom::LineKind::MacdSignal}, visible, n, signal, 0, scale, frac);
+        capture({vroom::LineKind::MacdHistogram}, visible, n, hist, 0, scale,
+                frac);
+    }
+
+    if (atr.enabled) {
+        ensure_atr();
+        const double* line = pane_slice(atr_cache);
+        const double scale = vroom::atr::autoscale(line, n);
+        capture({vroom::LineKind::Atr}, visible, n, line, 0, scale,
+                [&](double v) {
+                    return vroom::atr::band_fraction(v, scale, atr_y_scale);
+                });
+    }
+}
+
 void VroomChart::draw_chart(SkCanvas* canvas) {
     begin_frame();
     const auto lay = layout();
@@ -197,12 +607,28 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     const float morph_t = reshape ? interval_morph_t : 1.f;
 
     if (fade_out) {
-        // First half: only the captured series, at the axis envelope opacity.
-        // Layers with no snapshot (volume, overlays, indicators, drawings)
-        // would already be the new data, so they stay hidden until the incoming
-        // half. morph_t = 0 draws the capture pixel-identically.
+        // First half: only what was captured, at the axis envelope opacity.
+        // Layers with no snapshot (volume, liquidity, FVG, drawings) would
+        // already be the new data, so they stay hidden until the incoming half.
+        // morph_t = 0 draws every capture pixel-identically.
         const float layer = axis_phase.opacity;
+        // Groups the captured indicators into one layer rather than threading
+        // the envelope through as a per-paint alpha, so overlapping strokes
+        // composite once and the panes keep their signatures. The price series
+        // below fades per-paint, as it always has.
+        const auto push_fade_layer = [&]() -> bool {
+            if (layer >= 0.999f) return false;
+            canvas->saveLayerAlpha(nullptr,
+                                   static_cast<U8CPU>(layer * 255.f + 0.5f));
+            return true;
+        };
         if (layer > 0.f) {
+            // Behind the candles, as in the settled z-order.
+            const bool fills_wrapped = push_fade_layer();
+            draw_overlay_fills(canvas, lay, bounds, visible, 0, range.start,
+                               window_ms, candle_right, candle_area_h, true, 0.f);
+            if (fills_wrapped) canvas->restore();
+
             if (fade > 0.f) {
                 vroom::ma_overlay::draw_close_gradient(
                     canvas, lay, bounds, visible, 0, window_ms,
@@ -239,6 +665,18 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
                         morph_from.data(), morph_n, 0.f);
                 }
             }
+
+            // Over the candles, and the panes below them. One layer for both:
+            // they occupy disjoint bands, so nothing overlaps across the two.
+            const bool lines_wrapped = push_fade_layer();
+            draw_overlay_lines(canvas, lay, bounds, visible, 0, range.start,
+                               window_ms, candle_right, candle_area_h, true, 0.f);
+            if (lay.indicator_area_h > 0.f) {
+                draw_indicator_panes(canvas, lay, visible, 0, range.start,
+                                     window_ms, candle_right, candle_area_h,
+                                     true, 0.f);
+            }
+            if (lines_wrapped) canvas->restore();
         }
     } else {
         // Incoming fade: the new scene at envelope opacity, no slot lerp
@@ -275,22 +713,20 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
             vroom::liquidity::draw(canvas, *this, lay, bounds, candle_right,
                                    candle_area_h);
 
-            // 4.7. Bollinger Band fill.
-            if (bollinger.enabled) {
-                ensure_bollinger();
-                if (bollinger.fill_enabled &&
-                    bb_upper_cache.size() == candles.size() &&
-                    bb_lower_cache.size() == candles.size()) {
-                    vroom::ma_overlay::fill_between(
-                        canvas, lay, bounds, visible, n,
-                        bb_upper_cache.data() + range.start,
-                        bb_lower_cache.data() + range.start, window_ms,
-                        visible_start_ms, candle_duration_ms, candle_right,
-                        candle_area_h, bollinger.upper_color,
-                        bollinger.fill_opacity);
-                }
+            // 4.65. Fair Value Gap boxes — behind the candles, so the bars that
+            // formed each imbalance still read over their own shading.
+            if (fvg.enabled) {
+                ensure_fvg();
+                vroom::fvg_overlay::draw_boxes(canvas, *this, lay, bounds,
+                                               window_ms, candle_right,
+                                               candle_area_h);
             }
 
+            // 4.7 / 4.75. Bollinger fill and Ichimoku cloud, behind the candles.
+            draw_overlay_fills(canvas, lay, bounds, visible, n, range.start,
+                               window_ms, candle_right, candle_area_h, reshape,
+                               morph_t);
+
             // 5. Price series — candles, a close-price line, or a blend.
             if (fade < 1.f) {
                 vroom::candles::draw(canvas, visible, n, lay, theme, bounds,
@@ -308,59 +744,10 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
                     theme.floats[VROOM_FLOAT_LINE_TENSION]);
             }
 
-            // 5.5. Moving-average overlay lines.
-            if (!overlays.empty()) {
-                ensure_overlays();
-                for (std::size_t k = 0; k < overlays.size(); ++k) {
-                    if (overlay_caches[k].size() != candles.size()) continue;
-                    const double* vis = overlay_caches[k].data() + range.start;
-                    vroom::ma_overlay::draw(
-                        canvas, lay, bounds, visible, n, vis, window_ms,
-                        visible_start_ms, candle_duration_ms, candle_right,
-                        candle_area_h, overlays[k].color, overlays[k].width);
-                }
-            }
-
-            // 5.6. VWAP overlay.
-            if (vwap.enabled) {
-                ensure_vwap();
-                if (vwap_cache.size() == candles.size()) {
-                    const double* vis = vwap_cache.data() + range.start;
-                    const unsigned char* brk =
-                        vwap_breaks.size() == candles.size()
-                            ? vwap_breaks.data() + range.start
-                            : nullptr;
-                    vroom::ma_overlay::draw(
-                        canvas, lay, bounds, visible, n, vis, window_ms,
-                        visible_start_ms, candle_duration_ms, candle_right,
-                        candle_area_h,
-                        vroom::style::color_or(vwap.color, kVwapLine),
-                        vroom::style::width_or(vwap.width, 1.5f), brk);
-                }
-            }
-
-            // 5.65. Bollinger Band lines.
-            if (bollinger.enabled) {
-                ensure_bollinger();
-                const std::size_t sz = candles.size();
-                if (bb_upper_cache.size() == sz && bb_lower_cache.size() == sz &&
-                    bb_middle_cache.size() == sz) {
-                    const auto stroke = [&](const std::vector<double>& cache,
-                                              uint32_t color, float width) {
-                        vroom::ma_overlay::draw(
-                            canvas, lay, bounds, visible, n,
-                            cache.data() + range.start, window_ms,
-                            visible_start_ms, candle_duration_ms, candle_right,
-                            candle_area_h, color, width);
-                    };
-                    stroke(bb_upper_cache, bollinger.upper_color,
-                           bollinger.upper_width);
-                    stroke(bb_lower_cache, bollinger.lower_color,
-                           bollinger.lower_width);
-                    stroke(bb_middle_cache, bollinger.middle_color,
-                           bollinger.middle_width);
-                }
-            }
+            // 5.5 - 5.67. Moving averages, VWAP, Bollinger and Ichimoku lines.
+            draw_overlay_lines(canvas, lay, bounds, visible, n, range.start,
+                               window_ms, candle_right, candle_area_h, reshape,
+                               morph_t);
 
             // 5.7. Drawing annotations.
             vroom::drawings::draw(canvas, *this, lay, bounds, candle_right,
@@ -386,62 +773,9 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
             // paint before axis masks so overflow still clips). Transforms
             // keep the settled z-order after the price indicator.
             if (fade_in && lay.indicator_area_h > 0.f) {
-                struct ActivePane {
-                    int order;
-                    int type;
-                };
-                ActivePane panes[2];
-                int count = 0;
-                if (rsi.enabled) panes[count++] = {rsi_order, 0};
-                if (macd.enabled) panes[count++] = {macd_order, 1};
-                if (count == 2 && panes[0].order > panes[1].order) {
-                    const ActivePane tmp = panes[0];
-                    panes[0] = panes[1];
-                    panes[1] = tmp;
-                }
-
-                const float pane_h =
-                    height_px * theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
-                float pane_top = candle_area_h;
-                for (int i = 0; i < count; ++i) {
-                    const float pane_bottom = pane_top + pane_h;
-                    if (panes[i].type == 0) {
-                        ensure_rsi();
-                        const double* rsi_vis =
-                            rsi_cache.size() == candles.size()
-                                ? rsi_cache.data() + range.start
-                                : nullptr;
-                        const double* rsi_ma_vis =
-                            (rsi.ma_visible &&
-                             rsi_ma_cache.size() == candles.size())
-                                ? rsi_ma_cache.data() + range.start
-                                : nullptr;
-                        vroom::rsi_pane::draw(
-                            canvas, *this, lay, visible, n, rsi_vis, rsi_ma_vis,
-                            window_ms, visible_start_ms, candle_duration_ms,
-                            candle_right, pane_top, pane_bottom);
-                    } else {
-                        ensure_macd();
-                        const double* macd_vis =
-                            macd_cache.size() == candles.size()
-                                ? macd_cache.data() + range.start
-                                : nullptr;
-                        const double* sig_vis =
-                            macd_signal_cache.size() == candles.size()
-                                ? macd_signal_cache.data() + range.start
-                                : nullptr;
-                        const double* hist_vis =
-                            macd_hist_cache.size() == candles.size()
-                                ? macd_hist_cache.data() + range.start
-                                : nullptr;
-                        vroom::macd_pane::draw(
-                            canvas, *this, lay, visible, n, macd_vis, sig_vis,
-                            hist_vis, window_ms, visible_start_ms,
-                            candle_duration_ms, candle_right, pane_top,
-                            pane_bottom);
-                    }
-                    pane_top = pane_bottom;
-                }
+                draw_indicator_panes(canvas, lay, visible, n, range.start,
+                                     window_ms, candle_right, candle_area_h,
+                                     false, 1.f);
             }
         }
 
@@ -474,12 +808,24 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
         vroom::price_indicator::draw(canvas, *this, lay, bounds,
                                      candle_right, candle_area_h);
 
+        // 7.54. Fair Value Gap labels — the boxes themselves are back behind
+        //       the candles, but their text has to clear the bars it sits over.
+        vroom::fvg_overlay::draw_labels(canvas, *this, lay, bounds, window_ms,
+                                        candle_right, candle_area_h);
+
         // 7.55. Consumer-supplied price status lines — same tier as the
         //       current-price indicator (their badges must cover the labels
         //       underneath), but after it so a resting order at the last close
         //       stays readable.
         vroom::price_lines::draw(canvas, *this, lay, bounds, candle_right,
                                    candle_area_h);
+
+        // 7.56. Footprint badges — data-anchored chrome that must not be hidden
+        //       by candles or overlays, so it draws with the price lines rather
+        //       than back at the drawings layer. Below the crosshair, which the
+        //       user is actively pointing with.
+        ensure_footprint_buckets();
+        vroom::footprints::draw(canvas, *this, lay, bounds, window_ms);
     }
 
     // 7.6. Indicator panes stacked below the candles, ordered by enable
@@ -487,50 +833,9 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     //      INDICATOR_HEIGHT_FRAC of the height; the candle pane already shrank
     //      to fit them (see layout()). A fade already drew them with the scene.
     if (!fade_swap && lay.indicator_area_h > 0.f) {
-        struct ActivePane { int order; int type; };  // type: 0 = RSI, 1 = MACD
-        ActivePane panes[2];
-        int count = 0;
-        if (rsi.enabled) panes[count++] = {rsi_order, 0};
-        if (macd.enabled) panes[count++] = {macd_order, 1};
-        if (count == 2 && panes[0].order > panes[1].order) {
-            const ActivePane tmp = panes[0];
-            panes[0] = panes[1];
-            panes[1] = tmp;
-        }
-
-        const float pane_h =
-            height_px * theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
-        float pane_top = candle_area_h;  // == price_pane_bottom(lay)
-        for (int i = 0; i < count; ++i) {
-            const float pane_bottom = pane_top + pane_h;
-            if (panes[i].type == 0) {
-                ensure_rsi();
-                const double* rsi_vis = rsi_cache.size() == candles.size()
-                    ? rsi_cache.data() + range.start : nullptr;
-                const double* rsi_ma_vis =
-                    (rsi.ma_visible && rsi_ma_cache.size() == candles.size())
-                        ? rsi_ma_cache.data() + range.start : nullptr;
-                vroom::rsi_pane::draw(canvas, *this, lay, visible, n, rsi_vis,
-                                      rsi_ma_vis, window_ms, visible_start_ms,
-                                      candle_duration_ms, candle_right, pane_top,
-                                      pane_bottom);
-            } else {
-                ensure_macd();
-                const double* macd_vis = macd_cache.size() == candles.size()
-                    ? macd_cache.data() + range.start : nullptr;
-                const double* sig_vis =
-                    macd_signal_cache.size() == candles.size()
-                        ? macd_signal_cache.data() + range.start : nullptr;
-                const double* hist_vis =
-                    macd_hist_cache.size() == candles.size()
-                        ? macd_hist_cache.data() + range.start : nullptr;
-                vroom::macd_pane::draw(canvas, *this, lay, visible, n, macd_vis,
-                                       sig_vis, hist_vis, window_ms,
-                                       visible_start_ms, candle_duration_ms,
-                                       candle_right, pane_top, pane_bottom);
-            }
-            pane_top = pane_bottom;
-        }
+        // candle_area_h == price_pane_bottom(lay), the top of the band.
+        draw_indicator_panes(canvas, lay, visible, n, range.start, window_ms,
+                             candle_right, candle_area_h, reshape, morph_t);
     }
 
     // 7.7. Crosshair — drawn last so it sits on top of everything, including the