react-native-vroom-chart 0.14.0 → 0.16.0

package/cpp/_core_src/chart.h

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <chrono>
+#include <cstddef>
 #include <string>
 #include <vector>
 
@@ -22,13 +23,33 @@
 #include "include/core/SkRefCnt.h"
 #pragma clang diagnostic pop
 
+#include "fair_value_gaps.h"
+#include "footprints_layout.h"
 #include "labels.h"
+#include "line_morph.h"
 #include "price_format.h"
 #include "theme.h"
 #include "viewport.h"
 
 class SkCanvas;
 
+namespace vroom {
+
+// Which indicator owns a below-chart pane. Panes are otherwise
+// interchangeable: they are all the same height and stack in enable order.
+enum class PaneKind { Rsi, Macd, Atr };
+
+// Count of PaneKind values — the most panes that can be stacked at once.
+constexpr int kMaxPanes = 3;
+
+// One enabled pane and the sequence number it claimed when it was turned on.
+struct IndicatorPane {
+    int order;
+    PaneKind kind;
+};
+
+}  // namespace vroom
+
 struct VroomChart {
     // --- bridge / lifecycle -------------------------------------------------
     VroomCallbacks cb{};
@@ -81,6 +102,19 @@ struct VroomChart {
     std::vector<vroom::CandleSnapshot> morph_from;
     float interval_morph_t = 1.f;  // 1 = not morphing
     bool interval_morph_fade = false;
+    // Set when the capture came from a live update rather than a timeframe
+    // switch. Same slot machinery, but the axis holds still: a stream morph
+    // only reshapes the last bar, and the ticks it sits between don't move, so
+    // running them through the interval envelope would flash the whole axis on
+    // every tick (see labels::interval_phase).
+    bool morph_is_stream = false;
+    // The outgoing shape of every indicator series that was on screen, captured
+    // alongside the candles and keyed by identity so a toggle landing in the
+    // same commit as the switch can't pair two different lines (see
+    // line_morph.h). A timeframe switch invalidates every indicator cache at
+    // once, so without this the lines would pop to their new values while the
+    // candles under them reshape.
+    std::vector<vroom::LineMorph> morph_lines;
     // The pre-switch price scale and time window. The candle capture above is
     // normalized against these, and the axes keep rendering their old ticks from
     // them while fading out (see labels::interval_phase), so a label is never
@@ -122,7 +156,8 @@ struct VroomChart {
     VroomRSI rsi{0, 14, 70.0, 30.0, 14, 0, 1,
                  0u, -1.f, 1,  // RSI line
                  0u, -1.f,     // trendline
-                 0u, 1};       // band rules
+                 0u, 1,        // band rules
+                 1};           // extreme shading
     std::vector<double> rsi_cache;     // RSI per candle (NaN where undefined)
     std::vector<double> rsi_ma_cache;  // MA of rsi_cache (empty if MA off)
     bool rsi_dirty = true;
@@ -146,11 +181,23 @@ struct VroomChart {
     // default auto-fit amplitude; >1 zooms in, <1 zooms out. Anchored at zero.
     double macd_y_scale = 1.0;
 
+    // ATR, drawn in its own pane. atr_cache is aligned to `candles` (NaN
+    // warmup), recomputed lazily by ensure_atr() when atr_dirty.
+    // Defaults: 14-period true range under Wilder smoothing, style fields on
+    // their inherit sentinel.
+    VroomATR atr{0, 14, 0, 0u, -1.f};
+    std::vector<double> atr_cache;
+    bool atr_dirty = true;
+    // User y-axis zoom for the ATR pane (drag on its y-axis strip). 1.0 = the
+    // default 0..peak fit; >1 zooms in, <1 zooms out. Anchored at the baseline.
+    double atr_y_scale = 1.0;
+
     // Stacking order for the indicator panes: each indicator gets the next
     // sequence number on its off->on transition, so the most recently enabled
     // pane sorts last (bottom). -1 = not currently enabled.
     int rsi_order = -1;
     int macd_order = -1;
+    int atr_order = -1;
     int pane_seq = 0;
 
     // Moving-average overlay lines (SMA/EMA) drawn on the price pane. Not panes
@@ -182,6 +229,46 @@ struct VroomChart {
     std::vector<double> bb_lower_cache;
     bool bollinger_dirty = true;
 
+    // Ichimoku overlay (price pane; no pane reserved). Caches aligned to
+    // `candles` (NaN warmup) and indexed by the bar each value was computed
+    // from — displacement is applied when drawing, so the caches survive a
+    // change to it. Recomputed lazily by ensure_ichimoku() when ichimoku_dirty.
+    // Defaults: the standard 9/26/52/26, blue tenkan / red kijun, green span A
+    // over orange span B, teal chikou, 15% cloud.
+    VroomIchimoku ichimoku{0, 9, 26, 52, 26,
+                           0xff2962ff, 1.f, 1,   // tenkan:   blue
+                           0xffef5350, 1.f, 1,   // kijun:    red
+                           0xff26a69a, 1.f, 1,   // senkou A: green
+                           0xffff6d00, 1.f, 1,   // senkou B: orange
+                           0xff00bcd4, 1.f, 1,   // chikou:   teal
+                           1, 0xff26a69a, 0xffef5350, 0.15f};
+    std::vector<double> ich_tenkan_cache;
+    std::vector<double> ich_kijun_cache;
+    std::vector<double> ich_senkou_a_cache;
+    std::vector<double> ich_senkou_b_cache;
+    std::vector<double> ich_chikou_cache;
+    bool ichimoku_dirty = true;
+
+    // Fair Value Gap overlay (price pane; no pane reserved). The cache holds the
+    // detected imbalances in absolute time/price, oldest first, so box geometry
+    // and style are free to change without re-scanning — only the detection
+    // inputs below dirty it. Recomputed lazily by ensure_fvg() when fvg_dirty.
+    //
+    // Defaults: 300 bars back, close-settled fills, deleted once filled, 20-slot
+    // boxes in green/red at 15%, solid 1px border, labels on.
+    VroomFairValueGaps fvg{0, 300, 0, 0, 1, 0, 20,
+                           0xff26a69a, 0xffef5350, 0.15f,
+                           1, 0, 1.f, 0xff26a69a, 0xffef5350,
+                           1, nullptr, 10, 0u, 0.f,
+                           0, 0xff26a69a, 0xffef5350, nullptr};
+    // Owns the label texts, so the caller may free theirs as soon as the setter
+    // returns. `fvg.label` and `fvg.inverse_label` are left null and these are
+    // what the renderer reads.
+    std::string fvg_label = "FVG";
+    std::string fvg_inverse_label = "iFVG";
+    std::vector<vroom::fvg::Gap> fvg_cache;
+    bool fvg_dirty = true;
+
     // Volume bars (price pane, under the candles). On by default with every
     // style field left on its inherit sentinel, so an untouched chart looks
     // exactly as it did before the config existed. No cache — bar heights come
@@ -280,6 +367,28 @@ struct VroomChart {
     int32_t dragged_price_line = -1;
     double  dragged_price_line_price = 0.0;
 
+    // --- footprints (executed-trade badges) ---------------------------------
+    // Kept in the *host's* order so the indices reported by
+    // vroom_chart_footprints_at map straight back to its own trade objects.
+    std::vector<VroomFootprint> footprints;
+    VroomFootprintStyle         footprint_style{};
+
+    // Footprints grouped onto candles, which is what the renderer and hit-test
+    // actually walk. Derived from `footprints` + `candles`, so it is rebuilt
+    // lazily (see ensure_footprint_buckets) whenever either changes — that
+    // rebuild is what re-groups badges onto the right bars after an interval
+    // switch, with no involvement from the host.
+    std::vector<vroom::footprints::Bucket> footprint_buckets;
+    bool                                   footprint_buckets_dirty = true;
+
+    // Which badge renders highlighted, keyed the way the hit-test reports it.
+    // side -1 = none.
+    int64_t hovered_footprint_time_ms = 0;
+    int32_t hovered_footprint_side = -1;
+
+    // Rebuilds footprint_buckets if either input changed since the last call.
+    void ensure_footprint_buckets();
+
     // --- theme --------------------------------------------------------------
     vroom::Theme theme;
 
@@ -325,6 +434,69 @@ struct VroomChart {
     // indicator is enabled.
     void ensure_bollinger();
 
+    // Recomputes the Ichimoku caches when ichimoku_dirty and the indicator is
+    // enabled.
+    void ensure_ichimoku();
+
+    // Redetects the Fair Value Gaps when fvg_dirty and the indicator is enabled.
+    void ensure_fvg();
+
+    // Recomputes the ATR cache when atr_dirty and the indicator is enabled.
+    void ensure_atr();
+
+    // Fills morph_lines with the outgoing shape of every enabled indicator,
+    // normalized the way morph_from is. Called by begin_interval_morph while
+    // the pre-switch candles and caches are still resident — after the swap
+    // there is nothing left to capture. `range` is the visible slice and
+    // `bounds` the price band the capture is taken against, both shared with
+    // the candle capture so the two land on the same pixels.
+    void capture_morph_lines(const vroom::Layout& lay,
+                             const vroom::PriceBounds& bounds,
+                             vroom::IndexRange range, int64_t window_ms);
+
+    // Source indices whose *displaced* plot time lands in the visible window,
+    // for an Ichimoku span drawn at `time_ms + shift_ms`. A bar of padding
+    // either side keeps a run reaching the pane edge instead of stopping at the
+    // last bar strictly inside it. Shared by the cloud, the lines and the
+    // interval-morph capture so all three slice the same bars.
+    vroom::IndexRange ichimoku_source_range(int64_t shift_ms) const;
+
+    // The enabled panes written to `out` top to bottom, returning how many.
+    // Both the draw pass and the y-axis hit test read this, so the stack they
+    // see can't drift apart.
+    int indicator_panes(vroom::IndicatorPane out[vroom::kMaxPanes]) const;
+
+    // Draws the pane stack into the band below the candles, starting at
+    // `pane_top`. Shared by the settled draw and the interval-morph fade, which
+    // paint the panes at different points in the z-order.
+    void 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);
+
+    // The price-pane indicator overlays, split where the candles sit in the
+    // z-order: the Bollinger band and Ichimoku cloud go behind them, the moving
+    // averages, VWAP, Bollinger and Ichimoku lines over them.
+    //
+    // `use_capture` and `morph_t` carry the interval morph, on the same terms
+    // the candles take it. A transform pairs each series with its capture (see
+    // morph_lines) and eases toward the new shape. A fade's outgoing half
+    // passes n = 0 with morph_t = 0, replaying the capture alone. A settled
+    // frame passes no capture at all.
+    void 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);
+    void 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);
+
     // The main drawing pass. Calls into the labels and candles modules, and owns
     // the per-frame animation clock (see begin_frame) so every host gets it —
     // the web build draws straight through vroom_chart_draw rather than the