react-native-vroom-chart 0.15.0 → 0.17.0

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/theme.cpp

@@ -23,6 +23,11 @@ constexpr uint32_t kDefaultColors[VROOM_COLOR_COUNT_] = {
     0xff26a69a,  // ACCENT_BULL — classic teal-green (price indicator, volume, MACD)
     0xffef5350,  // ACCENT_BEAR — classic red
     0xff8957e5,  // LINE — line-chart close polyline; violet, matching the RSI line
+    // SKELETON — transparent sentinel: inherit GRID, the way BORDER_BULL and
+    // the wick colors inherit their fills. The gridlines are already the
+    // chart's tone for structure rather than data, which is what the loading
+    // line is, so matching them keeps it from being read as a series.
+    0x00000000,
 };
 
 constexpr float kDefaultFloats[VROOM_FLOAT_COUNT_] = {

package/cpp/_core_src/tip_geometry.h

@@ -0,0 +1,55 @@
+// How big the line chart's tip marker is, and how much gutter it needs.
+//
+// The dot marks the newest close, which on a view pinned to the latest bar sits
+// half a slot from the right edge of the plot — a few pixels. The dot's own
+// radius is larger than that, so it can only be drawn in full if it is allowed
+// to spill into the gutter between the plot and the y-axis strip. That makes the
+// marker's size a layout input, not just a paint detail, so the renderer
+// (draw_close_tip in ma_overlay.cpp) and the layout (VroomChart::layout) read it
+// from here rather than each carrying its own copy.
+//
+// The pulse ring is deliberately not part of this. At its widest it is 3.5x the
+// border radius, and reserving that much gutter would eat the plot; it is
+// allowed to clip against the axis.
+//
+// Skia-free and header-only so the unit tests can cover it; see
+// tests/test_tip_geometry.cpp.
+
+#pragma once
+
+#include <algorithm>
+
+namespace vroom::tip_geometry {
+
+// Width of the background-colored ring that separates the tip dot from the line
+// and from the pulse expanding out behind it.
+constexpr float kBorderPx = 2.f;
+
+// Gap left between the dot's outer edge and the y-axis strip. The dot touching
+// the price labels reads as a rendering fault even when nothing is clipped.
+constexpr float kClearPx = 4.f;
+
+struct Geometry {
+    float dot_r;     // the filled dot in the line's color
+    float border_r;  // the dot plus its background-colored halo
+};
+
+// Scaling off the stroke keeps the marker proportionate at any line width; the
+// floor stops a hairline chart from getting an invisible dot.
+inline Geometry of(float line_width) {
+    const float w = line_width > 0.f ? line_width : 1.5f;
+    const float dot_r = std::max(2.f, w * 1.5f);
+    return Geometry{dot_r, dot_r + kBorderPx};
+}
+
+// Gutter width that lets the dot draw in full with `kClearPx` to spare.
+//
+// draw_close_tip drops the marker once its center passes the plot's right edge,
+// so the center is at worst flush with that edge and the dot overhangs it by
+// exactly `border_r`. A gutter of that plus the clearance therefore makes "the
+// dot never touches the axis strip" true by construction, whatever the window.
+inline float gutter_px(float line_width) {
+    return of(line_width).border_r + kClearPx;
+}
+
+}  // namespace vroom::tip_geometry

package/cpp/_core_src/viewport.h

@@ -92,6 +92,30 @@ struct CandleSnapshot {
     float x;
     float open, high, low, close;
     bool  bull;  // close >= open; selects the fill / wick / border color
+    // Set when the capture came from the loading skeleton. Such a slot starts
+    // out grey and semi-transparent rather than in its own bull/bear color, so
+    // the draw path has to blend from `skeleton_alpha`-scaled grey instead —
+    // that color blend is what makes the hand-off read as the placeholder
+    // *becoming* the data (see candles::draw).
+    bool  skeleton = false;
+    // The wave's alpha for this bar at capture time. Carried so the morph's
+    // first frame matches the skeleton frame it replaced; without it every bar
+    // would jump to full opacity the instant data landed.
+    float skeleton_alpha = 1.f;
+};
+
+// One vertex of the loading line's morph, holding both ends of the animation
+// so a frame is a plain lerp between them.
+//
+// The two y's are in different spaces on purpose. The sine knows nothing about
+// prices, so it's a fraction of the pane; the candle centre is a fraction of
+// the price band, the same space CandleSnapshot uses — which is what keeps the
+// line sitting exactly where the bars emerge from, since both resolve through
+// y_at_fraction.
+struct LinePoint {
+    float x;       // fraction of the candle-area width
+    float from_y;  // fraction of the pane height — the sine, frozen at capture
+    float to_y;    // fraction of the price band — the candle's vertical centre
 };
 
 // How many captured slots still contribute to a frame — 0 once the morph is
@@ -108,6 +132,50 @@ 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.
+        //
+        // The skeleton state, by contrast, carries over from the interrupted
+        // capture: a tick landing mid-hand-off must not abandon the grey blend
+        // partway, or the bar would snap to full color while its geometry is
+        // still moving. Its alpha follows the same lerp as the geometry.
+        if (from.skeleton) {
+            to.skeleton = true;
+            to.skeleton_alpha = mix(from.skeleton_alpha, 1.f);
+        }
+    }
+}
+
 // 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).