react-native-vroom-chart 0.6.0 → 0.8.0

package/cpp/_core_src/chart.cpp

@@ -33,11 +33,16 @@
 #include "price_lines.h"
 #include "rsi.h"
 #include "rsi_pane.h"
+#include "style_inherit.h"
 #include "volume.h"
 #include "vwap.h"
 #include "theme.h"
 #include "viewport.h"
 
+namespace {
+constexpr SkColor kVwapLine = 0xff00bcd4;  // cyan
+}  // namespace
+
 VroomChart::VroomChart() : theme(vroom::default_theme()) {}
 
 void VroomChart::mark_dirty() {
@@ -49,7 +54,7 @@ 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);
     const float indicator_h = static_cast<float>(pane_count) * height_px *
                               theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
     return vroom::Layout{
@@ -66,10 +71,11 @@ vroom::Layout VroomChart::layout() const {
 }
 
 void VroomChart::ensure_rsi() {
-    if (!rsi_enabled || !rsi_dirty) return;
-    vroom::rsi::compute(candles.data(), candles.size(), rsi_period, rsi_cache);
-    if (rsi_ma_enabled) {
-        vroom::rsi::compute_ma(rsi_cache, rsi_ma_period, rsi_ma_cache);
+    if (!rsi.enabled || !rsi_dirty) return;
+    vroom::rsi::compute(candles.data(), candles.size(), rsi.period, rsi_cache);
+    if (rsi.ma_visible) {
+        vroom::rsi::compute_ma(rsi_cache, rsi.ma_period, rsi.ma_kind,
+                               rsi_ma_cache);
     } else {
         rsi_ma_cache.clear();
     }
@@ -77,9 +83,10 @@ void VroomChart::ensure_rsi() {
 }
 
 void VroomChart::ensure_macd() {
-    if (!macd_enabled || !macd_dirty) return;
-    vroom::macd::compute(candles.data(), candles.size(), macd_fast, macd_slow,
-                         macd_signal, macd_cache, macd_signal_cache,
+    if (!macd.enabled || !macd_dirty) return;
+    vroom::macd::compute(candles.data(), candles.size(), macd.fast, macd.slow,
+                         macd.signal, macd.source, macd.ma_kind,
+                         macd.signal_ma_kind, macd_cache, macd_signal_cache,
                          macd_hist_cache);
     macd_dirty = false;
 }
@@ -96,8 +103,8 @@ void VroomChart::ensure_overlays() {
 }
 
 void VroomChart::ensure_vwap() {
-    if (!vwap_enabled || !vwap_dirty) return;
-    vroom::vwap::compute(candles.data(), candles.size(), vwap_reset_offset_min,
+    if (!vwap.enabled || !vwap_dirty) return;
+    vroom::vwap::compute(candles.data(), candles.size(), vwap.reset_offset_min,
                          vwap_cache, vwap_breaks);
     vwap_dirty = false;
 }
@@ -112,6 +119,7 @@ void VroomChart::ensure_bollinger() {
 }
 
 void VroomChart::draw_chart(SkCanvas* canvas) {
+    begin_frame();
     const auto lay = layout();
 
     // 1. Background
@@ -140,19 +148,60 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
 
     // 3. Update label fade state ONCE per frame — both gridlines and labels
     //    share these opacities so their animations stay in lockstep.
-    vroom::labels::update_y_fades(*this, lay, bounds);
-    vroom::labels::update_x_fades(*this, lay);
+    //    While an interval morph fades the old ticks out, the axes are still laid
+    //    out against the pre-switch scale and window so nothing appears to move;
+    //    they adopt the new ones at the midpoint, invisible. Every axis call in
+    //    the frame has to agree on which of the two it's using.
+    const auto axis_phase = vroom::labels::interval_phase(*this);
+    const auto& axis_bounds = axis_phase.outgoing ? morph_from_bounds : bounds;
+    const int64_t axis_start_ms =
+        axis_phase.outgoing ? morph_from_start_ms : visible_start_ms;
+    const int64_t axis_end_ms =
+        axis_phase.outgoing ? morph_from_end_ms : visible_end_ms;
+    vroom::labels::update_y_fades(*this, lay, axis_bounds);
+    vroom::labels::update_x_fades(*this, lay, axis_start_ms, axis_end_ms);
 
     // 4. Gridlines — drawn before candles so candle bodies overlay them.
     //    Vertical (time) gridlines are intentionally disabled for now —
     //    re-enable by adding `vroom::labels::draw_x_gridlines(canvas, *this,
-    //    candle_right, candle_area_h);` here.
-    vroom::labels::draw_y_gridlines(canvas, *this, lay, bounds,
+    //    axis_start_ms, axis_end_ms, candle_right, candle_area_h);` here.
+    vroom::labels::draw_y_gridlines(canvas, *this, lay, axis_bounds,
                                     candle_right, candle_area_h);
 
+    // 4.35. Price-series morph state, shared by the gradient fill below and the
+    //       series itself (5). `morph_fade` crossfades candles→line and
+    //       `morph_collapse` folds each candle toward its close (the line vertex);
+    //       fade 0 = pure candles, fade 1 = pure line. An interval morph
+    //       additionally reshapes each slot from the geometry it held before the
+    //       timeframe switch (see `morph_from`) — candle bodies, line vertices and
+    //       the fill alike, so every layer stays in step mid-crossfade.
+    const float fade = morph_fade;
+    const float collapse = morph_collapse;
+    const bool morphing = interval_morph_t < 1.f && !morph_from.empty();
+    const vroom::CandleSnapshot* morph_src = morphing ? morph_from.data() : nullptr;
+    const std::size_t morph_n = morphing ? morph_from.size() : 0;
+    const float morph_t = morphing ? interval_morph_t : 1.f;
+
+    // 4.4. Line-mode gradient fill — the wash under the close polyline. Behind the
+    //      volume bars so they stay legible on top of it, which puts it at the
+    //      back of the price pane's content.
+    if (fade > 0.f) {
+        vroom::ma_overlay::draw_close_gradient(
+            canvas, lay, bounds, visible, n, window_ms,
+            visible_start_ms, candle_duration_ms, candle_right, candle_area_h,
+            theme.colors[VROOM_COLOR_LINE],
+            theme.floats[VROOM_FLOAT_LINE_GRADIENT_OPACITY],
+            fade, morph_src, morph_n, morph_t);
+    }
+
     // 4.5. Volume bars — drawn under the candles so candles z-index above.
-    vroom::volume::draw(canvas, visible, n, lay, theme,
-                        window_ms, visible_start_ms, candle_duration_ms);
+    //      A fully collapsed chart has no bars left to draw, which is also how
+    //      "volume disabled" is represented (set_volume snaps the scalar).
+    if (volume_collapse_t < 1.f) {
+        vroom::volume::draw(canvas, visible, n, lay, theme, volume,
+                            volume_collapse_t, volume_collapse_easing,
+                            window_ms, visible_start_ms, candle_duration_ms);
+    }
 
     // 4.6. Liquidity bands (resting-order depth) — behind the candles so the
     //      candle bodies paint over the volume-driven tint. Anchored in price
@@ -178,25 +227,19 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     }
 
     // 5. Price series — candles, a close-price line, or a blend of the two during
-    //    the candle↔line morph. `morph_fade` crossfades candles→line and
-    //    `morph_collapse` folds each candle toward its close (the line vertex).
-    //    fade 0 = pure candles, fade 1 = pure line. The line reuses the MA-overlay
-    //    polyline routine, fed the visible closes and styled by theme.LINE.
-    const float fade = morph_fade;
-    const float collapse = morph_collapse;
+    //    the candle↔line morph (state hoisted to 4.35 for the gradient fill). The
+    //    line is styled by theme.LINE.
     if (fade < 1.f) {
         vroom::candles::draw(canvas, visible, n, lay, theme, bounds, window_ms,
                              visible_start_ms, candle_duration_ms, collapse,
-                             1.f - fade);
+                             1.f - fade, morph_src, morph_n, morph_t);
     }
     if (fade > 0.f) {
-        std::vector<double> closes(n);
-        for (std::size_t i = 0; i < n; ++i) closes[i] = visible[i].close;
-        vroom::ma_overlay::draw(
-            canvas, lay, bounds, visible, n, closes.data(), window_ms,
+        vroom::ma_overlay::draw_close_line(
+            canvas, lay, bounds, visible, n, window_ms,
             visible_start_ms, candle_duration_ms, candle_right, candle_area_h,
             theme.colors[VROOM_COLOR_LINE], theme.floats[VROOM_FLOAT_LINE_WIDTH_PX],
-            nullptr, fade);
+            fade, morph_src, morph_n, morph_t);
     }
 
     // 5.5. Moving-average overlay lines (SMA/EMA) on the price pane, over the
@@ -216,7 +259,7 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
 
     // 5.6. VWAP overlay (session, configurable reset) — a single price-pane line
     //      that breaks at each session reset (vwap_breaks).
-    if (vwap_enabled) {
+    if (vwap.enabled) {
         ensure_vwap();
         if (vwap_cache.size() == candles.size()) {
             const double* vis = vwap_cache.data() + range.start;
@@ -226,7 +269,10 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
             vroom::ma_overlay::draw(canvas, lay, bounds, visible, n, vis,
                                     window_ms, visible_start_ms,
                                     candle_duration_ms, candle_right,
-                                    candle_area_h, vwap_color, vwap_width, brk);
+                                    candle_area_h,
+                                    vroom::style::color_or(vwap.color, kVwapLine),
+                                    vroom::style::width_or(vwap.width, 1.5f),
+                                    brk);
         }
     }
 
@@ -272,8 +318,8 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
         axis_bg);
 
     // 7. Labels (read from y_fades / x_fades, no state mutation here)
-    vroom::labels::draw_y_labels(canvas, *this, lay, bounds);
-    vroom::labels::draw_x_labels(canvas, *this, lay);
+    vroom::labels::draw_y_labels(canvas, *this, lay, axis_bounds);
+    vroom::labels::draw_x_labels(canvas, *this, lay, axis_start_ms, axis_end_ms);
 
     // 7.5. Current-price line + box — above labels so the box covers any label
     //      it overlaps; tracks the latest close as the price scale moves.
@@ -294,8 +340,8 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
         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 (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];
@@ -312,7 +358,7 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
                 const double* rsi_vis = rsi_cache.size() == candles.size()
                     ? rsi_cache.data() + range.start : nullptr;
                 const double* rsi_ma_vis =
-                    (rsi_ma_enabled && rsi_ma_cache.size() == candles.size())
+                    (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,
@@ -361,19 +407,24 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     vroom::labels::gc_x_fades(*this);
 }
 
-void VroomChart::rebuild_chart_picture() {
-    // Compute dt for fade animations. We cap large gaps (resume from
-    // background, long idle) so we don't snap animations to completion.
-    auto now = std::chrono::steady_clock::now();
+void VroomChart::begin_frame() {
+    // dt for the fade animations. A large gap (resume from background, or an idle
+    // chart that a click just woke up) is clamped to a nominal frame rather than
+    // zeroed: dt == 0 means "snap" to the fade updaters, which would finish every
+    // fade in the first frame after any idle period.
+    constexpr float kNominalFrameSeconds = 1.f / 60.f;
+    const auto now = std::chrono::steady_clock::now();
     float dt = 0.f;
     if (anim_started) {
         dt = std::chrono::duration<float>(now - last_anim_tick).count();
-        if (dt > 0.1f) dt = 0.f;
+        if (dt > 0.1f) dt = kNominalFrameSeconds;
     }
     last_anim_tick = now;
     anim_started = true;
     last_dt_seconds = dt;
+}
 
+void VroomChart::rebuild_chart_picture() {
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(SkRect::MakeWH(width_px, height_px));
     draw_chart(canvas);

package/cpp/_core_src/chart.h

@@ -64,6 +64,21 @@ struct VroomChart {
     float morph_collapse = 0.f;
     float morph_fade = 0.f;
 
+    // Interval morph: the outgoing candle geometry captured when a timeframe
+    // switch begins, indexed from the right of the visible slice (slot 0 =
+    // newest) — the pairing the preserved slot grid guarantees. Stored as
+    // normalized fractions so it survives the new bounds and a resize.
+    // Empty when not morphing.
+    std::vector<vroom::CandleSnapshot> morph_from;
+    float interval_morph_t = 1.f;  // 1 = not morphing
+    // 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
+    // drawn at a position it didn't already occupy.
+    vroom::PriceBounds morph_from_bounds{0.0, 1.0};
+    int64_t morph_from_start_ms = 0;
+    int64_t morph_from_end_ms = 0;
+
     // Cached y-axis width in pixels, sized to fit the widest formatted price
     // label. 0 = uncomputed; layout() falls back to a width ratio.
     float axis_width_px = 0.f;
@@ -86,24 +101,27 @@ struct VroomChart {
     // RSI, drawn in a pane below the candles. rsi_cache is aligned to `candles`
     // (one value per candle, NaN where undefined) and recomputed lazily by
     // ensure_rsi() when rsi_dirty (set on any data or config change).
-    bool rsi_enabled = false;
-    int  rsi_period = 14;
-    double rsi_upper = 70.0;   // overbought band
-    double rsi_lower = 30.0;   // oversold band
-    bool rsi_ma_enabled = true;  // RSI-based moving average (trendline)
-    int  rsi_ma_period = 14;
+    // Defaults: 14-period RSI with 70/30 bands and a 14-period SMA trendline,
+    // every style field on its inherit sentinel.
+    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
     std::vector<double> rsi_cache;     // RSI per candle (NaN where undefined)
-    std::vector<double> rsi_ma_cache;  // SMA of rsi_cache (empty if MA off)
+    std::vector<double> rsi_ma_cache;  // MA of rsi_cache (empty if MA off)
     bool rsi_dirty = true;
     // User y-axis zoom for the RSI pane (drag on its y-axis strip). 1.0 = the
     // default 0..100 fit; >1 zooms in (taller), <1 zooms out. Anchored at 50.
     double rsi_y_scale = 1.0;
 
     // MACD, drawn in its own pane. Caches aligned to `candles` (NaN warmup).
-    bool macd_enabled = false;
-    int  macd_fast = 12;
-    int  macd_slow = 26;
-    int  macd_signal = 9;
+    // Defaults: 12/26/9 EMAs of close, every style field on its inherit
+    // sentinel so an untouched chart keeps the stock look.
+    VroomMACD macd{0, 12, 26, 9, 0, 1, 1,
+                   0u, -1.f, 1,  // MACD line
+                   0u, -1.f, 1,  // signal line
+                   1, 0u, 0u, 0u, 0u,  // histogram
+                   0u, 1};             // zero line
     std::vector<double> macd_cache;
     std::vector<double> macd_signal_cache;
     std::vector<double> macd_hist_cache;
@@ -128,10 +146,8 @@ struct VroomChart {
 
     // VWAP overlay (session anchor, configurable reset time). Single line on the
     // price pane; vwap_breaks marks session resets so the line lifts the pen.
-    bool vwap_enabled = false;
-    int  vwap_reset_offset_min = 0;       // session boundary offset from UTC midnight
-    uint32_t vwap_color = 0xff00bcd4;     // cyan
-    float vwap_width = 1.5f;
+    // Style fields sit on their inherit sentinel (cyan, 1.5px).
+    VroomVWAP vwap{0, 0, 0u, -1.f};
     std::vector<double> vwap_cache;
     std::vector<unsigned char> vwap_breaks;
     bool vwap_dirty = true;
@@ -150,13 +166,26 @@ struct VroomChart {
     std::vector<double> bb_lower_cache;
     bool bollinger_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
+    // straight off the visible candles' volume.
+    VroomVolume volume{1, -1.f, -1.f, -1.f, 0u, 0u};
+    // Staggered collapse of those bars, driven per-frame by the host animation
+    // loop: 0 = full height, 1 = all flat. Doubles as the visibility gate, since
+    // a fully collapsed chart draws nothing — set_volume snaps it to match
+    // `volume.enabled`, and the host overrides it while animating.
+    float volume_collapse_t = 0.f;
+    int32_t volume_collapse_easing = VROOM_EASING_IN_OUT;
+
     // --- drawings (annotations) --------------------------------------------
     // Committed drawings, anchored in data space so they track the candles on
     // pan/zoom. Drawn on the price pane above candles/overlays.
     //
-    // Mirrors the public VroomDrawing but *owns* its points, so a pencil path
-    // (kind 2) can carry a variable number of them. For line/box `points` is
-    // empty and only a/b are used; for pencil a/b mirror the first/last point.
+    // Mirrors the public VroomDrawing but *owns* its points, so a pencil stroke
+    // (kind 2) or path (kind 3) can carry a variable number of them. For
+    // line/box `points` is empty and only a/b are used; for pencil/path a/b
+    // mirror the first/last point.
     struct StoredDrawing {
         VroomDrawPoint              a{};
         VroomDrawPoint              b{};
@@ -171,7 +200,9 @@ struct VroomChart {
     // draft_a is always drawn (node dot); draft_b is drawn when draft_has_b.
     // draft_guide draws the live guideline A->B; when false only node dots show
     // (the committed segment renders via `drawings`). draft_color/draft_width
-    // style the guideline to match the eventual line.
+    // style the guideline to match the eventual line. For a path (draft_kind 3)
+    // draft_points holds the vertices placed so far and draft_b is the cursor
+    // the rubber-band segment runs to (when draft_has_b).
     bool           draft_active = false;
     VroomDrawPoint draft_a{};
     bool           draft_has_b = false;
@@ -179,14 +210,16 @@ struct VroomChart {
     bool           draft_guide = false;
     uint32_t       draft_color = 0xff2962ff;
     float          draft_width = 2.f;
-    int32_t        draft_kind = 0;  // 0 = line, 1 = box, 2 = pencil (VroomDrawing)
-    // Freehand stroke in progress (draft_kind 2), grown one point at a time.
+    int32_t        draft_kind = 0;  // 0 = line, 1 = box, 2 = pencil, 3 = path
+    // Points of the in-progress stroke (draft_kind 2, grown one at a time) or
+    // path (draft_kind 3, restated per click/move).
     std::vector<VroomDrawPoint> draft_points;
 
     // Selection/editing state for committed drawings. selected_drawing indexes
-    // `drawings` (or -1); its endpoints render as handles. grabbed_endpoint is
-    // 0 (A) or 1 (B) while that handle is being dragged (rendered 50% larger),
-    // else -1.
+    // `drawings` (or -1); its handles render on top. grabbed_endpoint is the
+    // handle being dragged — 0 (A) or 1 (B) for a line, 0 for a box (the host
+    // normalizes the grabbed corner to endpoint 0), the vertex index for a path
+    // — rendered 50% larger; -1 when none.
     int32_t        selected_drawing = -1;
     int32_t        grabbed_endpoint = -1;
 
@@ -235,9 +268,9 @@ struct VroomChart {
     std::chrono::steady_clock::time_point last_anim_tick{};
     bool anim_started = false;
 
-    // dt of the current rebuild — populated by rebuild_chart_picture and
-    // consumed by the label-fade updaters. Public so the labels namespace
-    // can read it without a getter.
+    // dt of the current frame — populated by begin_frame and consumed by the
+    // label-fade updaters. Public so the labels namespace can read it without a
+    // getter.
     float last_dt_seconds = 0.f;
 
     // --- methods ------------------------------------------------------------
@@ -267,11 +300,18 @@ struct VroomChart {
     // indicator is enabled.
     void ensure_bollinger();
 
-    // The main drawing pass. Calls into the labels and candles modules.
+    // 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
+    // SkPicture cache below.
     void draw_chart(SkCanvas* canvas);
 
+    // Per-frame animation bookkeeping: computes `last_dt_seconds`, which paces
+    // the label fades. Called at the top of draw_chart.
+    void begin_frame();
+
     // Re-records `chart_picture` by invoking draw_chart on a fresh
-    // SkPictureRecorder. Also computes `last_dt_seconds` for fade animation.
+    // SkPictureRecorder.
     void rebuild_chart_picture();
 
     // True if any axis label is mid-fade. Used by the JS-side animation loop