react-native-vroom-chart 0.15.0 → 0.16.0

package/cpp/_core_src/macd_pane.cpp

@@ -20,6 +20,9 @@
 
 #include "chart.h"
 #include "fonts.h"
+#include "line_morph.h"
+#include "macd.h"
+#include "pane_series.h"
 #include "style_inherit.h"
 #include "theme.h"
 #include "viewport.h"
@@ -34,7 +37,6 @@ constexpr SkColor kMacdLine = 0xff2962ff;    // blue MACD line
 constexpr SkColor kSignalLine = 0xffff6d00;  // orange signal line
 constexpr SkColor kZeroLine = 0xff484f58;    // zero reference
 constexpr SkColor kDivider = 0xff21262d;     // pane separator
-constexpr float kPadFrac = 0.85f;            // keep curves off the band edges
 constexpr float kLineWidth = 1.5f;           // default stroke for both lines
 constexpr float kFadedAlpha = 0.5f;          // easing histogram bars
 
@@ -58,34 +60,42 @@ void draw(SkCanvas* canvas,
           int64_t candle_duration_ms,
           float candle_right,
           float pane_top,
-          float pane_bottom) {
-    if (!canvas || n == 0 || candle_right <= 0.f) return;
+          float pane_bottom,
+          const vroom::LineMorph* macd_from,
+          const vroom::LineMorph* signal_from,
+          const vroom::LineMorph* hist_from,
+          float morph_t) {
+    if (!canvas || candle_right <= 0.f) return;
     const float band_h = pane_bottom - pane_top;
     if (band_h <= 0.f) return;
+    morph_t = std::clamp(morph_t, 0.f, 1.f);
+    // A fade's outgoing half has no new data at all, so the captures are the
+    // whole frame. Nothing on either side means nothing to paint, shell
+    // included.
+    const std::size_t hist_slots =
+        vroom::pane_series::slots(n, hist_from, morph_t);
+    if (n == 0 && hist_slots == 0 &&
+        vroom::morph_line_count(macd_from, morph_t) == 0 &&
+        vroom::morph_line_count(signal_from, morph_t) == 0) {
+        return;
+    }
 
     const VroomMACD& cfg = chart.macd;
     const float mid = (pane_top + pane_bottom) * 0.5f;
-    // User y-zoom scales the amplitude about the zero line (mid). 1.0 = the
-    // default auto-fit; >1 zooms in, <1 zooms out.
-    const float half =
-        band_h * 0.5f * kPadFrac * static_cast<float>(chart.macd_y_scale);
 
     // Auto-scale symmetric about zero across the finite values on show, so
-    // hiding a series lets the rest fill the pane.
-    double scale = 0.0;
-    auto track = [&](const double* s, bool shown) {
-        if (!s || !shown) return;
-        for (std::size_t i = 0; i < n; ++i) {
-            if (std::isfinite(s[i])) scale = std::max(scale, std::abs(s[i]));
-        }
-    };
-    track(macd_visible, cfg.line_visible != 0);
-    track(signal_visible, cfg.signal_visible != 0);
-    track(hist_visible, cfg.hist_visible != 0);
+    // hiding a series lets the rest fill the pane. User y-zoom scales the
+    // amplitude about the zero line; 1.0 is the default auto-fit.
+    const double scale = vroom::macd::autoscale(
+        cfg.line_visible ? macd_visible : nullptr,
+        cfg.signal_visible ? signal_visible : nullptr,
+        cfg.hist_visible ? hist_visible : nullptr, n);
 
     auto y_for = [&](double v) -> float {
-        if (scale <= 0.0) return mid;
-        return mid - static_cast<float>(v / scale) * half;
+        return pane_bottom -
+               static_cast<float>(
+                   vroom::macd::band_fraction(v, scale, chart.macd_y_scale)) *
+                   band_h;
     };
 
     // Mask the band (candles can overflow below the shortened price pane).
@@ -115,7 +125,9 @@ void draw(SkCanvas* canvas,
     // Histogram bars: from the zero line to y_for(hist), 4-color — above or
     // below zero, each in a building and an easing shade. A bar is building
     // while it grows away from zero and easing while it falls back toward it.
-    if (hist_visible && cfg.hist_visible) {
+    if ((hist_visible || hist_from) && cfg.hist_visible) {
+        // The new resolution's width from the first frame, matching how
+        // candles::draw widens its bodies while their positions still slide.
         const float body_w =
             vroom::candle_body_width(lay, window_ms, candle_duration_ms);
         const float half_body = body_w * 0.5f;
@@ -126,68 +138,65 @@ void draw(SkCanvas* canvas,
             color_or(cfg.hist_down_color, chart.theme.colors[VROOM_COLOR_ACCENT_BEAR]);
         const SkColor up_easing = faded_or(cfg.hist_up_fading_color, up);
         const SkColor down_easing = faded_or(cfg.hist_down_fading_color, down);
-        for (std::size_t i = 0; i < n; ++i) {
-            const double h = hist_visible[i];
-            if (!std::isfinite(h)) continue;
-            const bool have_prev = i > 0 && std::isfinite(hist_visible[i - 1]);
-            const double prev = have_prev ? hist_visible[i - 1] : h;
-            bool building = true;
-            if (have_prev) {
-                building = h >= 0.0 ? h >= prev : h <= prev;
+        const std::size_t hist_from_count =
+            vroom::morph_line_count(hist_from, morph_t);
+        // Bars read their sign and direction off the drawn geometry rather than
+        // the values: mid-morph a top is a blend of two resolutions' numbers,
+        // and only where it ended up says which side of zero it is on. y grows
+        // downward, so above zero is the smaller y.
+        MorphVertex prev;
+        for (std::size_t j = 0; j < hist_slots; ++j) {
+            const MorphVertex p = vroom::pane_series::vertex(
+                lay, visible, n, hist_visible, window_ms, visible_start_ms,
+                candle_duration_ms, pane_top, pane_bottom, hist_from,
+                hist_from_count, morph_t, hist_slots - 1 - j, y_for);
+            if (!p.valid) {
+                prev = MorphVertex{};
+                continue;
             }
+            const bool above = p.y <= zero_y;
+            // Building while the bar grows away from zero, easing while it
+            // falls back toward it.
+            const bool building =
+                !prev.valid || (above ? p.y <= prev.y : p.y >= prev.y);
             SkPaint bar;
             bar.setAntiAlias(true);
-            if (h >= 0.0) {
+            if (above) {
                 bar.setColor(building ? up : up_easing);
             } else {
                 bar.setColor(building ? down : down_easing);
             }
-            const float cx = vroom::candle_center_x(
-                lay, visible[i].time_ms, candle_duration_ms, visible_start_ms,
-                window_ms);
-            const float vy = y_for(h);
-            const float top = std::min(zero_y, vy);
-            const float bot = std::max(zero_y, vy);
-            canvas->drawRect(
-                SkRect::MakeLTRB(cx - half_body, top, cx + half_body, bot), bar);
+            canvas->drawRect(SkRect::MakeLTRB(p.x - half_body,
+                                              std::min(zero_y, p.y),
+                                              p.x + half_body,
+                                              std::max(zero_y, p.y)),
+                             bar);
+            prev = p;
         }
     }
 
     // MACD + signal lines.
-    auto stroke_series = [&](const double* series, SkColor color, float width) {
-        if (!series) return;
-        SkPathBuilder path;
-        bool pen_down = false;
-        for (std::size_t i = 0; i < n; ++i) {
-            const double v = series[i];
-            if (!std::isfinite(v)) {
-                pen_down = false;
-                continue;
-            }
-            const float x = vroom::candle_center_x(
-                lay, visible[i].time_ms, candle_duration_ms, visible_start_ms,
-                window_ms);
-            const float y = y_for(v);
-            if (pen_down) {
-                path.lineTo(x, y);
-            } else {
-                path.moveTo(x, y);
-                pen_down = true;
-            }
-        }
+    auto stroke_series = [&](const double* series, const vroom::LineMorph* from,
+                             SkColor color, float width) {
+        if (!series && !from) return;
         SkPaint line;
         line.setAntiAlias(true);
         line.setColor(color);
         line.setStyle(SkPaint::kStroke_Style);
         line.setStrokeWidth(width);
-        canvas->drawPath(path.detach(), line);
+        canvas->drawPath(
+            vroom::pane_series::build_path(
+                lay, visible, n, series, window_ms, visible_start_ms,
+                candle_duration_ms, pane_top, pane_bottom, from, morph_t, y_for),
+            line);
     };
     if (cfg.signal_visible) {
-        stroke_series(signal_visible, color_or(cfg.signal_color, kSignalLine),
+        stroke_series(signal_visible, signal_from,
+                      color_or(cfg.signal_color, kSignalLine),
                       width_or(cfg.signal_width, kLineWidth));
     }
     if (cfg.line_visible) {  // MACD over signal
-        stroke_series(macd_visible, color_or(cfg.line_color, kMacdLine),
+        stroke_series(macd_visible, macd_from, color_or(cfg.line_color, kMacdLine),
                       width_or(cfg.line_width, kLineWidth));
     }
 

package/cpp/_core_src/macd_pane.h

@@ -13,6 +13,7 @@ class SkCanvas;
 
 namespace vroom {
 struct Layout;
+struct LineMorph;
 }  // namespace vroom
 
 struct VroomChart;
@@ -23,6 +24,13 @@ namespace vroom::macd_pane {
 // series are aligned with `visible` (NaN where undefined). The vertical scale
 // auto-fits the visible values symmetrically about zero; shares the candles'
 // horizontal mapping (candle_center_x) so it scrolls in lock-step.
+//
+// The three `*_from` captures plus `morph_t` are the interval morph: each holds
+// its series' outgoing shape in fractions of the band, indexed from the right
+// (slot 0 = newest), so the pane can re-fit across the switch without the shape
+// moving. Histogram bars reshape the way candle bodies do — their tops slide
+// while the zero line, which is fixed to the band center, stays put. A fade's
+// outgoing half passes n = 0 with morph_t = 0, painting the captures alone.
 void draw(SkCanvas* canvas,
           const VroomChart& chart,
           const Layout& lay,
@@ -36,6 +44,10 @@ void draw(SkCanvas* canvas,
           int64_t candle_duration_ms,
           float candle_right,
           float pane_top,
-          float pane_bottom);
+          float pane_bottom,
+          const LineMorph* macd_from = nullptr,
+          const LineMorph* signal_from = nullptr,
+          const LineMorph* hist_from = nullptr,
+          float morph_t = 1.f);
 
 }  // namespace vroom::macd_pane

package/cpp/_core_src/pane_series.h

@@ -0,0 +1,169 @@
+// Polyline plotting shared by the indicator panes (RSI, MACD, ATR), including
+// the interval morph.
+//
+// Each pane maps values into its own band with its own auto-fit, so it hands
+// over its y mapping and everything from the slot pairing down is identical
+// across the three. The capture holds band *fractions* rather than values,
+// which is what lets a pane re-fit across a timeframe switch without its
+// outgoing shape moving.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
+#pragma clang diagnostic pop
+
+#include "line_morph.h"
+#include "viewport.h"
+#include "vroom/vroom_chart.h"
+
+namespace vroom::pane_series {
+
+// Slot `k` of a pane series in screen pixels, blended from the capture toward
+// the new value. Slot 0 is the rightmost vertex on both sides — the pairing a
+// timeframe switch preserves, the same one candles::draw uses.
+template <typename YFor>
+MorphVertex vertex(const Layout& lay,
+                   const ::VroomCandle* visible,
+                   std::size_t n,
+                   const double* values,
+                   int64_t window_ms,
+                   int64_t visible_start_ms,
+                   int64_t candle_duration_ms,
+                   float pane_top,
+                   float pane_bottom,
+                   const LineMorph* from,
+                   std::size_t from_count,
+                   float morph_t,
+                   std::size_t k,
+                   YFor&& y_for) {
+    MorphVertex to;
+    if (values && k < n) {
+        const std::size_t i = n - 1 - k;
+        const double v = values[i];
+        if (std::isfinite(v)) {
+            to = MorphVertex{
+                vroom::candle_center_x(lay, visible[i].time_ms,
+                                       candle_duration_ms, visible_start_ms,
+                                       window_ms),
+                y_for(v), true};
+        }
+    }
+    MorphVertex frm;
+    if (k < from_count) {
+        const LineSnapshot& s = from->pts[k];
+        if (s.valid) {
+            frm = MorphVertex{s.x * vroom::candle_area_width(lay),
+                              pane_bottom - s.y * (pane_bottom - pane_top),
+                              true};
+        }
+    }
+    return vroom::morph_vertex(to, frm, morph_t);
+}
+
+// How many vertices a morphing series spans: the new slice and the capture can
+// disagree on length, and every slot either defines has to be walked.
+inline std::size_t slots(std::size_t n, const LineMorph* from, float morph_t) {
+    return std::max(n, vroom::morph_line_count(from, morph_t));
+}
+
+// The series as a polyline, walked left to right. A slot neither side defines
+// lifts the pen, which is what leaves the warmup gap open.
+template <typename YFor>
+SkPath build_path(const Layout& lay,
+                  const ::VroomCandle* visible,
+                  std::size_t n,
+                  const double* values,
+                  int64_t window_ms,
+                  int64_t visible_start_ms,
+                  int64_t candle_duration_ms,
+                  float pane_top,
+                  float pane_bottom,
+                  const LineMorph* from,
+                  float morph_t,
+                  YFor&& y_for) {
+    const std::size_t from_count = vroom::morph_line_count(from, morph_t);
+    const std::size_t count = std::max(n, from_count);
+    SkPathBuilder path;
+    bool pen_down = false;
+    for (std::size_t j = 0; j < count; ++j) {
+        const MorphVertex p =
+            vertex(lay, visible, n, values, window_ms, visible_start_ms,
+                   candle_duration_ms, pane_top, pane_bottom, from, from_count,
+                   morph_t, count - 1 - j, y_for);
+        if (!p.valid) {
+            pen_down = false;
+            continue;
+        }
+        if (pen_down) {
+            path.lineTo(p.x, p.y);
+        } else {
+            path.moveTo(p.x, p.y);
+            pen_down = true;
+        }
+    }
+    return path.detach();
+}
+
+// The region between the series and a horizontal rule at `y_band`, as the
+// closed counterpart to build_path. Callers clip to one side of the rule to keep
+// only the stretches that reach past it, which puts the crossings exactly where
+// Skia cuts the geometry rather than anywhere this has to solve for.
+//
+// Each run of vertices gets its own contour, tied down to the rule at both
+// ends. One contour spanning the whole series would close a warmup gap by
+// running straight through it, filling a span the line never drew.
+template <typename YFor>
+SkPath build_band_area(const Layout& lay,
+                       const ::VroomCandle* visible,
+                       std::size_t n,
+                       const double* values,
+                       int64_t window_ms,
+                       int64_t visible_start_ms,
+                       int64_t candle_duration_ms,
+                       float pane_top,
+                       float pane_bottom,
+                       const LineMorph* from,
+                       float morph_t,
+                       float y_band,
+                       YFor&& y_for) {
+    const std::size_t from_count = vroom::morph_line_count(from, morph_t);
+    const std::size_t count = std::max(n, from_count);
+    SkPathBuilder path;
+    bool open = false;
+    float last_x = 0.f;
+    for (std::size_t j = 0; j < count; ++j) {
+        const MorphVertex p =
+            vertex(lay, visible, n, values, window_ms, visible_start_ms,
+                   candle_duration_ms, pane_top, pane_bottom, from, from_count,
+                   morph_t, count - 1 - j, y_for);
+        if (!p.valid) {
+            if (open) {
+                path.lineTo(last_x, y_band);
+                path.close();
+                open = false;
+            }
+            continue;
+        }
+        if (!open) {
+            path.moveTo(p.x, y_band);
+            open = true;
+        }
+        path.lineTo(p.x, p.y);
+        last_x = p.x;
+    }
+    if (open) {
+        path.lineTo(last_x, y_band);
+        path.close();
+    }
+    return path.detach();
+}
+
+}  // namespace vroom::pane_series

package/cpp/_core_src/rsi.cpp

@@ -53,4 +53,8 @@ void compute_ma(const std::vector<double>& rsi, int ma_period, int kind,
     vroom::series_ma::smooth(rsi, kind, ma_period, out);
 }
 
+double band_fraction(double v, double y_scale) {
+    return 0.5 + ((v - 50.0) / 100.0) * y_scale;
+}
+
 }  // namespace vroom::rsi

package/cpp/_core_src/rsi.h

@@ -29,4 +29,11 @@ void compute(const ::VroomCandle* candles, std::size_t n, int period,
 void compute_ma(const std::vector<double>& rsi, int ma_period, int kind,
                 std::vector<double>& out);
 
+// Where an RSI value sits in the pane band, as a fraction of its height — 0 at
+// the bottom edge, 1 at the top. The fixed 0..100 domain maps about the band
+// center so the user's y-axis zoom (`y_scale`, 1 = the default fit) stretches
+// symmetrically around 50. Split out of the renderer so the interval-morph
+// capture maps its geometry through the same math.
+double band_fraction(double v, double y_scale);
+
 }  // namespace vroom::rsi

package/cpp/_core_src/rsi_pane.cpp

@@ -9,17 +9,24 @@
 #include "include/core/SkPaint.h"
 #include "include/core/SkPath.h"
 #include "include/core/SkPathBuilder.h"
+#include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
+#include "include/core/SkShader.h"
 #include "include/core/SkTypeface.h"
 #include "include/effects/SkDashPathEffect.h"
 #pragma clang diagnostic pop
 
+#include <algorithm>
 #include <cmath>
 #include <cstdio>
 #include <cstring>
 
 #include "chart.h"
 #include "fonts.h"
+#include "gradient.h"
+#include "line_morph.h"
+#include "pane_series.h"
+#include "rsi.h"
 #include "style_inherit.h"
 #include "theme.h"
 #include "viewport.h"
@@ -36,6 +43,11 @@ constexpr SkColor kRefLine = 0xff30363d;    // band reference lines
 constexpr SkColor kDivider = 0xff21262d;    // pane separator
 constexpr SkScalar kDash[2] = {3.f, 3.f};
 constexpr float kLineWidth = 1.5f;          // default stroke for both lines
+// Alpha the extreme shading reaches at the end of the scale. Only a reading
+// pinned at 100 or 0 collects all of it, which is why this sits higher than the
+// wash typically paints. Still short of opaque: the RSI line and the band rule
+// sit on top of it and have to stay readable at its deepest.
+constexpr float kExtremeFillAlpha = 0.7f;
 }  // namespace
 
 void draw(SkCanvas* canvas,
@@ -50,19 +62,31 @@ void draw(SkCanvas* canvas,
           int64_t candle_duration_ms,
           float candle_right,
           float pane_top,
-          float pane_bottom) {
-    if (!canvas || n == 0 || candle_right <= 0.f) return;
+          float pane_bottom,
+          const vroom::LineMorph* rsi_from,
+          const vroom::LineMorph* rsi_ma_from,
+          float morph_t) {
+    if (!canvas || candle_right <= 0.f) return;
     const float band_h = pane_bottom - pane_top;
     if (band_h <= 0.f) return;
+    morph_t = std::clamp(morph_t, 0.f, 1.f);
+    // A fade's outgoing half has no new data at all, so the captures are the
+    // whole frame. Nothing on either side means nothing to paint, shell
+    // included.
+    if (n == 0 && vroom::morph_line_count(rsi_from, morph_t) == 0 &&
+        vroom::morph_line_count(rsi_ma_from, morph_t) == 0) {
+        return;
+    }
 
     // Map 0..100 about the pane center so the user y-zoom scales symmetrically
     // around 50. z == 1 reproduces the default fit (0 -> pane_bottom, 100 ->
     // pane_top); z > 1 zooms in (taller), z < 1 zooms out (flatter).
     const VroomRSI& cfg = chart.rsi;
-    const float center_y = (pane_top + pane_bottom) * 0.5f;
-    const float z = static_cast<float>(chart.rsi_y_scale);
     auto y_for = [&](double v) -> float {
-        return center_y - static_cast<float>((v - 50.0) / 100.0) * band_h * z;
+        return pane_bottom -
+               static_cast<float>(
+                   vroom::rsi::band_fraction(v, chart.rsi_y_scale)) *
+                   band_h;
     };
 
     // Mask the band with the background so candles/volume that overflow below
@@ -86,6 +110,52 @@ void draw(SkCanvas* canvas,
     // Configurable band reference lines (overbought / oversold).
     const float y_upper = y_for(cfg.upper_band);
     const float y_lower = y_for(cfg.lower_band);
+
+    // Shade the stretches that reach past a band, fading out at the rule itself
+    // and deepening toward the end of the scale — so how far the reading went
+    // past the threshold reads at a glance, not just that it did.
+    //
+    // Drawn before the rules and the lines so both stay legible on top. The
+    // region is built across the whole series and then clipped to the far side
+    // of the rule, which lands the crossings exactly without solving for them.
+    auto fill_extreme = [&](double band, double limit, SkColor base,
+                            bool above) {
+        // The ramp spans band -> limit. Pinned together (upper at 100, lower at
+        // 0) there is nothing to ramp through, and Skia would clamp the
+        // zero-length gradient to its end color: a flat slab at full alpha.
+        if (band == limit) return;
+        const float y_band = y_for(band);
+        const SkPath area = vroom::pane_series::build_band_area(
+            lay, visible, n, rsi_visible, window_ms, visible_start_ms,
+            candle_duration_ms, pane_top, pane_bottom, rsi_from, morph_t,
+            y_band, y_for);
+        if (area.isEmpty()) return;
+
+        // Anchored to the RSI value rather than the pane edge, so the shading
+        // means the same thing at any y-zoom and a shallow excursion stays
+        // faint instead of saturating on a short pane.
+        const SkPoint pts[2] = {SkPoint::Make(0.f, y_band),
+                                SkPoint::Make(0.f, y_for(limit))};
+        SkPaint fill;
+        fill.setAntiAlias(true);
+        fill.setStyle(SkPaint::kFill_Style);
+        fill.setShader(
+            vroom::linear_alpha_ramp(pts, base, 0.f, kExtremeFillAlpha));
+
+        canvas->save();
+        canvas->clipRect(
+            above ? SkRect::MakeLTRB(0.f, pane_top, candle_right, y_band)
+                  : SkRect::MakeLTRB(0.f, y_band, candle_right, pane_bottom));
+        canvas->drawPath(area, fill);
+        canvas->restore();
+    };
+    if (cfg.extreme_fill) {
+        fill_extreme(cfg.upper_band, 100.0,
+                     chart.theme.colors[VROOM_COLOR_ACCENT_BULL], true);
+        fill_extreme(cfg.lower_band, 0.0,
+                     chart.theme.colors[VROOM_COLOR_ACCENT_BEAR], false);
+    }
+
     if (cfg.bands_visible) {
         SkPaint ref;
         ref.setAntiAlias(true);
@@ -98,41 +168,27 @@ void draw(SkCanvas* canvas,
 
     // Strokes a value series as a polyline; a NaN lifts the pen so undefined
     // leading values (i < period) leave a gap.
-    auto stroke_series = [&](const double* series, SkColor color, float width) {
-        if (!series) return;
-        SkPathBuilder path;
-        bool pen_down = false;
-        for (std::size_t i = 0; i < n; ++i) {
-            const double v = series[i];
-            if (!std::isfinite(v)) {
-                pen_down = false;
-                continue;
-            }
-            const float x = vroom::candle_center_x(
-                lay, visible[i].time_ms, candle_duration_ms, visible_start_ms,
-                window_ms);
-            const float y = y_for(v);
-            if (pen_down) {
-                path.lineTo(x, y);
-            } else {
-                path.moveTo(x, y);
-                pen_down = true;
-            }
-        }
+    auto stroke_series = [&](const double* series, const vroom::LineMorph* from,
+                             SkColor color, float width) {
+        if (!series && !from) return;
         SkPaint line;
         line.setAntiAlias(true);
         line.setColor(color);
         line.setStyle(SkPaint::kStroke_Style);
         line.setStrokeWidth(width);
-        canvas->drawPath(path.detach(), line);
+        canvas->drawPath(
+            vroom::pane_series::build_path(
+                lay, visible, n, series, window_ms, visible_start_ms,
+                candle_duration_ms, pane_top, pane_bottom, from, morph_t, y_for),
+            line);
     };
     if (cfg.line_visible) {
-        stroke_series(rsi_visible, color_or(cfg.line_color, kRsiLine),
+        stroke_series(rsi_visible, rsi_from, color_or(cfg.line_color, kRsiLine),
                       width_or(cfg.line_width, kLineWidth));
     }
     // Trendline on top. Its own visibility is handled upstream: a hidden
     // trendline isn't computed, so the caller passes null.
-    stroke_series(rsi_ma_visible, color_or(cfg.ma_color, kRsiMaLine),
+    stroke_series(rsi_ma_visible, rsi_ma_from, color_or(cfg.ma_color, kRsiMaLine),
                   width_or(cfg.ma_width, kLineWidth));
 
     // Caption, top-left of the pane.

package/cpp/_core_src/rsi_pane.h

@@ -13,6 +13,7 @@ class SkCanvas;
 
 namespace vroom {
 struct Layout;
+struct LineMorph;
 }  // namespace vroom
 
 struct VroomChart;
@@ -22,6 +23,12 @@ namespace vroom::rsi_pane {
 // Draws the RSI pane spanning vertically [pane_top, pane_bottom]. `rsi_visible`
 // is the cached RSI series aligned with `visible` (NaN where undefined). Shares
 // the candles' horizontal mapping (candle_center_x) so it scrolls in lock-step.
+//
+// `rsi_from` / `rsi_ma_from` / `morph_t` are the interval morph: each capture
+// holds its line's outgoing shape indexed from the right (slot 0 = newest) and
+// every vertex slides from where it sat before the timeframe switch to where it
+// sits now. A fade's outgoing half passes n = 0 with morph_t = 0, which paints
+// the captures alone.
 void draw(SkCanvas* canvas,
           const VroomChart& chart,
           const Layout& lay,
@@ -34,6 +41,9 @@ void draw(SkCanvas* canvas,
           int64_t candle_duration_ms,
           float candle_right,
           float pane_top,
-          float pane_bottom);
+          float pane_bottom,
+          const LineMorph* rsi_from = nullptr,
+          const LineMorph* rsi_ma_from = nullptr,
+          float morph_t = 1.f);
 
 }  // namespace vroom::rsi_pane

package/cpp/_core_src/viewport.h

@@ -108,6 +108,41 @@ inline std::size_t morph_from_count(const CandleSnapshot* from,
 // anything else = fade the outgoing snapshot out then the new scene in.
 inline bool interval_morph_is_fade(int32_t mode) { return mode != 0; }
 
+// Rewrites a fresh capture so it starts from the shape currently on screen
+// rather than from the data underneath it. Live ticks arrive faster than a
+// morph lands, so every restart interrupts one; without this the bar would jump
+// back to its un-morphed position on each tick, which is the snap the animation
+// exists to remove.
+//
+// `interrupted` is the capture being replaced and `morph_t` the progress it had
+// reached, so `dst` becomes exactly the frame that was being painted: the draw
+// path interpolates in this same fraction space (see candles::draw), which is
+// what makes a plain lerp here land pixel-exact.
+//
+// Slot 0 is the newest in both, so a differing visible count only drops the
+// oldest slots — those keep the fresh capture, which is where they already are.
+inline void blend_candle_snapshots(CandleSnapshot* dst, std::size_t dst_n,
+                                   const CandleSnapshot* interrupted,
+                                   std::size_t interrupted_n, float morph_t) {
+    if (!dst || !interrupted) return;
+    const std::size_t n = dst_n < interrupted_n ? dst_n : interrupted_n;
+    for (std::size_t k = 0; k < n; ++k) {
+        const CandleSnapshot& from = interrupted[k];
+        CandleSnapshot& to = dst[k];
+        const auto mix = [morph_t](float a, float b) {
+            return a + (b - a) * morph_t;
+        };
+        to.open = mix(from.open, to.open);
+        to.high = mix(from.high, to.high);
+        to.low = mix(from.low, to.low);
+        to.close = mix(from.close, to.close);
+        to.x = mix(from.x, to.x);
+        // `bull` stays the fresh one: the draw path colors a paired slot from
+        // the live candle and only reads the capture's flag for a slot the next
+        // update drops, where the newer direction is the better answer.
+    }
+}
+
 // Returns the indices of candles whose time_ms falls in [start_ms, end_ms].
 // When both are 0, returns the full range (Phase 1 default-everything behavior).
 // Candles must be sorted ascending by time_ms (invariant of the public API).