react-native-vroom-chart 0.15.0 → 0.17.0

package/cpp/_core_src/chart.h

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <chrono>
+#include <cstddef>
 #include <string>
 #include <vector>
 
@@ -22,14 +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{};
@@ -72,6 +92,42 @@ struct VroomChart {
     // is_animating_now keeps the host's redraw loop alive (see tip_pulse.h).
     float tip_pulse_elapsed_s = 0.f;
 
+    // --- loading line -------------------------------------------------------
+    // See loading_line.h for the three stages this state drives.
+    //
+    // Authoritative, not inferred: the host tells us it's loading *and* that it
+    // has no data, because an empty `candles` alone can't be trusted here. The
+    // hosts' data effects skip pushing an empty array (it would read as "hold
+    // the last frame"), so a chart mid-asset-switch can be loading while still
+    // holding the previous asset's bars — inferring from emptiness would show
+    // that stale series as if it were the new one's.
+    //
+    // True for stages 1 and 2 both: the line stands in for the chart until the
+    // candles actually take over in stage 3.
+    bool loading = false;
+    // Whether the wave travels. Cleared for reduced motion, which both freezes
+    // the line at phase 0 and keeps is_animating_now from pinning a host loop.
+    bool loading_animate = true;
+    // Phase of the wave, in seconds, advanced by begin_frame like the tip pulse
+    // above and wrapped for the same reason.
+    float loading_elapsed_s = 0.f;
+    // Fades the line in on arrival, so a chart that resolves instantly from
+    // cache doesn't flash a placeholder.
+    float loading_fade_in = 0.f;
+
+    // The line's morph vertices, left to right, captured when the data lands.
+    // Empty means stage 1 — nothing to morph toward yet — which is what
+    // loading_line::draw switches on.
+    std::vector<vroom::LinePoint> loading_line;
+    // Stage 2's progress, 0 = the frozen sine, 1 = through the candle centres.
+    // Parked at 1 when no morph is running.
+    float loading_line_t = 1.f;
+    // Set for stage 3, where the line rides `interval_morph_t` out on the same
+    // clock as the candles growing out of it. A flag rather than its own float
+    // because the two have to finish together to avoid a line left hanging over
+    // a settled chart.
+    bool loading_line_revealing = false;
+
     // Interval morph: the outgoing candle geometry captured when a timeframe
     // switch begins, indexed from the right of the visible slice (slot 0 =
     // newest). `interval_morph_fade` is the host's choice at capture time:
@@ -82,6 +138,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
@@ -123,7 +192,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;
@@ -147,11 +217,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
@@ -183,6 +265,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
@@ -348,6 +470,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
@@ -359,6 +544,38 @@ struct VroomChart {
     // draw_chart.
     void begin_frame();
 
+    // Enters or leaves the loading line. `animate` false pins it still for
+    // reduced motion. Entering restarts the phase and the fade-in; leaving
+    // outright (rather than through the two calls below) drops the line with no
+    // hand-off, which is what an error or a cancelled fetch wants.
+    void set_loading(bool on, bool animate);
+
+    // Stage 2. Call *after* pushing the real candles: it needs them to know
+    // where the line is heading. Freezes the sine at its current phase and
+    // pairs each vertex with the vertical centre of the candle that will occupy
+    // that column, then hands `loading_line_t` to the host to drive 0 → 1.
+    //
+    // Freezing rather than letting the wave run underneath is deliberate — a
+    // moving source makes the morph read as two animations fighting instead of
+    // one shape resolving.
+    void begin_loading_morph();
+
+    // The visible slice and price bounds the hand-off aims at, as draw_chart
+    // would resolve them. `n == 0` when there is nothing to hand off to.
+    struct LoadingTarget {
+        const ::VroomCandle* visible = nullptr;
+        std::size_t n = 0;
+        vroom::PriceBounds bounds{};
+    };
+    LoadingTarget loading_target() const;
+
+    // Stage 3. Captures every candle collapsed onto its own vertical centre at
+    // zero alpha and hands it to the interval-morph machinery, so the existing
+    // slot lerp grows each bar outward from the line while candles::draw blends
+    // its colour up out of nothing. Also releases `loading`, letting the axes,
+    // price badge and panes come back.
+    void begin_loading_reveal();
+
     // True when the line tip's pulse ring is on screen and looping. Gated on
     // line mode and on having data, so a chart that isn't showing the ring can
     // still go idle.
@@ -368,7 +585,8 @@ struct VroomChart {
     // SkPictureRecorder.
     void rebuild_chart_picture();
 
-    // True if any axis label is mid-fade, or the tip pulse is running. Used by
-    // the JS-side animation loop to know when to keep ticking.
+    // True if any axis label is mid-fade, the tip pulse is running, or the
+    // loading skeleton is waving. Used by the JS-side animation loop to know
+    // when to keep ticking.
     bool is_animating_now() const;
 };