react-native-vroom-chart 0.5.0 → 0.7.0

package/cpp/_core_src/labels.cpp

@@ -15,6 +15,7 @@
 #include <cstdio>
 #include <cstring>
 #include <ctime>
+#include <vector>
 
 #include "chart.h"
 #include "fonts.h"
@@ -46,8 +47,25 @@ void advance(Fade& f, float step, float dt) {
     }
 }
 
+// Drives a whole axis off the morph envelope instead of the per-label fades:
+// everything in the phase's tick set shares one opacity, and anything outside it
+// is dropped outright. At the midpoint the axis is transparent, so swapping the
+// set there costs nothing visually.
+template <typename Fade>
+void apply_envelope(std::vector<Fade>& fades, float opacity) {
+    for (auto& f : fades) f.opacity = f.target > 0.f ? opacity : 0.f;
+}
+
 }  // namespace
 
+IntervalPhase interval_phase(const VroomChart& chart) {
+    if (chart.morph_from.empty() || chart.interval_morph_t >= 1.f) return {};
+    const float t = chart.interval_morph_t;
+    constexpr float kMid = 0.5f;
+    if (t < kMid) return {true, true, 1.f - t / kMid};
+    return {true, false, (t - kMid) / (1.f - kMid)};
+}
+
 // ----- Y-axis ---------------------------------------------------------------
 
 void update_y_fades(VroomChart& chart,
@@ -81,6 +99,11 @@ void update_y_fades(VroomChart& chart,
         }
     }
 
+    const auto phase = interval_phase(chart);
+    if (phase.active) {
+        apply_envelope(chart.y_fades, phase.opacity);
+        return;
+    }
     const float step = kFadeRate * chart.last_dt_seconds;
     for (auto& f : chart.y_fades) advance(f, step, chart.last_dt_seconds);
 }
@@ -162,24 +185,27 @@ void gc_y_fades(VroomChart& chart) {
 
 // ----- X-axis ---------------------------------------------------------------
 
-void update_x_fades(VroomChart& chart, const Layout& lay) {
+void update_x_fades(VroomChart& chart,
+                    const Layout& lay,
+                    int64_t start_ms,
+                    int64_t end_ms) {
     if (chart.candles.empty()) return;
-    if (chart.visible_end_ms <= chart.visible_start_ms) return;
+    if (end_ms <= start_ms) return;
 
     const float candle_area_w =
         lay.width_px - lay.y_axis_width_px - lay.right_padding_px;
     if (candle_area_w <= 0.f) return;
 
-    const int64_t window_ms = chart.visible_end_ms - chart.visible_start_ms;
+    const int64_t window_ms = end_ms - start_ms;
     const vroom::TimeTick tick =
         vroom::pick_time_tick(window_ms, candle_area_w);
 
     for (auto& f : chart.x_fades) f.target = 0.f;
 
-    int64_t t = vroom::first_tick_at_or_after(chart.visible_start_ms, tick);
+    int64_t t = vroom::first_tick_at_or_after(start_ms, tick);
     constexpr int kMaxLabels = 64;
     int promoted = 0;
-    for (; t <= chart.visible_end_ms && promoted < kMaxLabels;
+    for (; t <= end_ms && promoted < kMaxLabels;
          t = vroom::next_tick(t, tick), ++promoted) {
         bool found = false;
         for (auto& f : chart.x_fades) {
@@ -194,16 +220,23 @@ void update_x_fades(VroomChart& chart, const Layout& lay) {
         }
     }
 
+    const auto phase = interval_phase(chart);
+    if (phase.active) {
+        apply_envelope(chart.x_fades, phase.opacity);
+        return;
+    }
     const float step = kFadeRate * chart.last_dt_seconds;
     for (auto& f : chart.x_fades) advance(f, step, chart.last_dt_seconds);
 }
 
 void draw_x_gridlines(SkCanvas* canvas,
                       const VroomChart& chart,
+                      int64_t start_ms,
+                      int64_t end_ms,
                       float candle_area_w,
                       float candle_area_h) {
-    if (chart.visible_end_ms <= chart.visible_start_ms) return;
-    const int64_t window_ms = chart.visible_end_ms - chart.visible_start_ms;
+    if (end_ms <= start_ms) return;
+    const int64_t window_ms = end_ms - start_ms;
     if (window_ms <= 0 || candle_area_w <= 0.f) return;
 
     SkPaint grid;
@@ -212,9 +245,8 @@ void draw_x_gridlines(SkCanvas* canvas,
     grid.setAntiAlias(true);
     for (const auto& f : chart.x_fades) {
         if (f.opacity <= 1e-3f) continue;
-        const float frac =
-            static_cast<float>(f.time_ms - chart.visible_start_ms) /
-            static_cast<float>(window_ms);
+        const float frac = static_cast<float>(f.time_ms - start_ms) /
+                           static_cast<float>(window_ms);
         const float x = frac * candle_area_w;
         if (x < 0.f || x > candle_area_w) continue;
         grid.setAlphaf(f.opacity);
@@ -224,10 +256,12 @@ void draw_x_gridlines(SkCanvas* canvas,
 
 void draw_x_labels(SkCanvas* canvas,
                    const VroomChart& chart,
-                   const Layout& lay) {
+                   const Layout& lay,
+                   int64_t start_ms,
+                   int64_t end_ms) {
     auto tf = vroom::axis_typeface();
     if (!tf || chart.candles.empty()) return;
-    if (chart.visible_end_ms <= chart.visible_start_ms) return;
+    if (end_ms <= start_ms) return;
 
     // X-axis labels live in the bottom strip, which stays anchored regardless
     // of any indicator pane above it.
@@ -236,7 +270,7 @@ void draw_x_labels(SkCanvas* canvas,
         lay.width_px - lay.y_axis_width_px - lay.right_padding_px;
     if (candle_area_w <= 0.f) return;
 
-    const int64_t window_ms = chart.visible_end_ms - chart.visible_start_ms;
+    const int64_t window_ms = end_ms - start_ms;
     // Recompute the cadence here just to decide label formatting.
     const vroom::TimeTick tick =
         vroom::pick_time_tick(window_ms, candle_area_w);
@@ -262,9 +296,8 @@ void draw_x_labels(SkCanvas* canvas,
         tick.step_ms >= 24LL * 60 * 60 * 1000;
     for (const auto& f : chart.x_fades) {
         if (f.opacity <= 1e-3f) continue;
-        const float frac =
-            static_cast<float>(f.time_ms - chart.visible_start_ms) /
-            static_cast<float>(window_ms);
+        const float frac = static_cast<float>(f.time_ms - start_ms) /
+                           static_cast<float>(window_ms);
         const float x_center = frac * candle_area_w;
 
         char buf[16];

package/cpp/_core_src/labels.h

@@ -34,14 +34,33 @@ struct XLabelFade {
     float target = 1.f;
 };
 
-// Opacity step per second (1 / 0.2s ≈ 200ms full fade).
+// Opacity step per second (1 / 0.2s ≈ 200ms full fade). Paces the incremental
+// per-label fades; an interval morph overrides them with the envelope below.
 inline constexpr float kFadeRate = 5.f;
 
+// How an axis behaves during an interval morph: the pre-switch ticks fade out
+// over the first half, the new ones fade in over the second. Nothing translates
+// — the tick set is swapped at the midpoint, while the axis is fully
+// transparent, so a label is never seen moving between two positions.
+//
+// Both halves are clocked off the morph's own eased progress, so the axes take
+// `transitionMs`, follow `transitionEasing`, and land with the candles.
+struct IntervalPhase {
+    bool active = false;    // false: fade per-label at kFadeRate as usual
+    bool outgoing = false;  // true: first half — pre-switch ticks and scale
+    float opacity = 1.f;    // whole-axis multiplier, 1 → 0 → 1
+};
+
+// Derived purely from the chart's morph state, so callers can ask for it freely.
+IntervalPhase interval_phase(const VroomChart& chart);
+
 // Y-axis (price) -----------------------------------------------------------
 
 // Sets targets, walks the active price-interval set, advances opacities by
 // `chart.last_dt_seconds`. Must be called once per frame before either
-// `draw_y_gridlines` or `draw_y_labels`.
+// `draw_y_gridlines` or `draw_y_labels`. `bounds` is the scale to lay ticks out
+// against, which during an interval morph's outgoing half is the pre-switch one
+// (`chart.morph_from_bounds`) — pass the same value to the draw calls.
 void update_y_fades(VroomChart& chart,
                     const Layout& lay,
                     const PriceBounds& bounds);
@@ -62,16 +81,26 @@ void gc_y_fades(VroomChart& chart);
 
 // X-axis (time) ------------------------------------------------------------
 
-void update_x_fades(VroomChart& chart, const Layout& lay);
+// `start_ms`/`end_ms` are the window to lay ticks out against — the pre-switch
+// one during an interval morph's outgoing half, `chart.visible_*` otherwise.
+// Every x-axis call in a frame must be given the same window.
+void update_x_fades(VroomChart& chart,
+                    const Layout& lay,
+                    int64_t start_ms,
+                    int64_t end_ms);
 
 void draw_x_gridlines(SkCanvas* canvas,
                       const VroomChart& chart,
+                      int64_t start_ms,
+                      int64_t end_ms,
                       float candle_area_w,
                       float candle_area_h);
 
 void draw_x_labels(SkCanvas* canvas,
                    const VroomChart& chart,
-                   const Layout& lay);
+                   const Layout& lay,
+                   int64_t start_ms,
+                   int64_t end_ms);
 
 void gc_x_fades(VroomChart& chart);
 

package/cpp/_core_src/liquidity.cpp

@@ -11,47 +11,12 @@
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkShader.h"
-#include "include/core/SkTileMode.h"
-// Skia's linear-gradient API differs across the Skia versions we build against:
-// the WASM build uses a newer Skia (SkGradient.h + SkShaders::LinearGradient),
-// while react-native-skia bundles an older one (SkGradientShader::MakeLinear).
-// Neither ships both headers, so select whichever is present.
-#if __has_include("include/effects/SkGradient.h")
-#  include "include/core/SkSpan.h"
-#  include "include/effects/SkGradient.h"
-#  define VROOM_SK_MODERN_GRADIENT 1
-#else
-#  include "include/effects/SkGradientShader.h"
-#  define VROOM_SK_MODERN_GRADIENT 0
-#endif
 #pragma clang diagnostic pop
 
 #include "chart.h"
+#include "gradient.h"
 
 namespace vroom::liquidity {
-namespace {
-
-// A horizontal shader fading from transparent at the left of `pts` to `base` at
-// opacity `alpha` on the right, keeping RGB constant so the faded edge doesn't
-// darken toward black. Abstracts over the two Skia gradient APIs above.
-sk_sp<SkShader> left_fade_shader(const SkPoint pts[2], SkColor base, float alpha) {
-#if VROOM_SK_MODERN_GRADIENT
-    const float r = SkColorGetR(base) / 255.f;
-    const float g = SkColorGetG(base) / 255.f;
-    const float b = SkColorGetB(base) / 255.f;
-    const SkColor4f colors[2] = {SkColor4f{r, g, b, 0.f}, SkColor4f{r, g, b, alpha}};
-    const SkGradient::Colors grad_colors(
-        SkSpan<const SkColor4f>(colors, 2), SkTileMode::kClamp);
-    const SkGradient grad(grad_colors, SkGradient::Interpolation{});
-    return SkShaders::LinearGradient(pts, grad);
-#else
-    const auto a = static_cast<U8CPU>(alpha * 255.f + 0.5f);
-    const SkColor colors[2] = {SkColorSetA(base, 0), SkColorSetA(base, a)};
-    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
-#endif
-}
-
-}  // namespace
 
 void draw(SkCanvas* canvas,
           const VroomChart& chart,
@@ -102,7 +67,8 @@ void draw(SkCanvas* canvas,
 
         SkPaint paint;
         paint.setAntiAlias(true);
-        paint.setShader(left_fade_shader(pts, base, alpha));
+        // Transparent at the left of the band's reach, full `alpha` at the axis.
+        paint.setShader(vroom::linear_alpha_ramp(pts, base, 0.f, alpha));
         canvas->drawRect(SkRect::MakeLTRB(left_x, y_top, candle_right, y_bot), paint);
     }
 

package/cpp/_core_src/ma_overlay.cpp

@@ -7,16 +7,107 @@
 #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"
 #pragma clang diagnostic pop
 
 #include <algorithm>
 #include <cmath>
 
+#include "gradient.h"
 #include "viewport.h"
 
 namespace vroom::ma_overlay {
 
+namespace {
+// Strokes a built polyline, clipped to the candle area so a line that runs off
+// range doesn't bleed into the axis strips or any indicator pane below.
+void stroke_path(SkCanvas* canvas,
+                 const SkPath& path,
+                 float candle_right,
+                 float candle_area_h,
+                 uint32_t color,
+                 float width,
+                 float opacity) {
+    SkPaint line;
+    line.setAntiAlias(true);
+    line.setColor(static_cast<SkColor>(color));
+    // Fade the line in during the candle→line morph (multiplies the color alpha).
+    if (opacity < 1.f) {
+        line.setAlphaf(line.getAlphaf() * opacity);
+    }
+    line.setStyle(SkPaint::kStroke_Style);
+    line.setStrokeWidth(width > 0.f ? width : 1.5f);
+
+    canvas->save();
+    canvas->clipRect(SkRect::MakeLTRB(0.f, 0.f, candle_right, candle_area_h));
+    canvas->drawPath(path, line);
+    canvas->restore();
+}
+
+inline float lerp(float a, float b, float t) { return a + (b - a) * t; }
+
+// The close-price polyline, walked left to right. Shared by the stroke and the
+// gradient fill so both derive from identical geometry, mid-morph included.
+//
+// Descending slots — position counting back from the right edge, the pairing a
+// timeframe switch preserves — which walks the line left to right, so the vertex
+// order matches draw()'s at morph_t == 1. Every candle has a close, so there are
+// no gaps to break the subpath on.
+SkPath build_close_path(const Layout& lay,
+                        const PriceBounds& bounds,
+                        const ::VroomCandle* visible,
+                        std::size_t n,
+                        int64_t window_ms,
+                        int64_t visible_start_ms,
+                        int64_t candle_duration_ms,
+                        const CandleSnapshot* from,
+                        std::size_t from_n,
+                        float morph_t) {
+    const std::size_t from_count = vroom::morph_from_count(from, from_n, morph_t);
+    const std::size_t slots = std::max(n, from_count);
+    if (slots == 0) return SkPath();
+    const float area_w = vroom::candle_area_width(lay);
+
+    SkPathBuilder path;
+    bool pen_down = false;
+    for (std::size_t k = slots; k-- > 0;) {
+        const ::VroomCandle* to = (k < n) ? &visible[n - 1 - k] : nullptr;
+        const CandleSnapshot* frm = (k < from_count) ? &from[k] : nullptr;
+
+        float x, y;
+        if (to) {
+            const float tx = vroom::candle_center_x(
+                lay, to->time_ms, candle_duration_ms, visible_start_ms, window_ms);
+            const float ty = vroom::price_to_y(lay, bounds, to->close);
+            if (frm) {
+                // The capture is in band fractions, so it lands on the same pixels
+                // it occupied pre-switch even though the bounds changed.
+                x = lerp(frm->x * area_w, tx, morph_t);
+                y = lerp(vroom::y_at_fraction(lay, frm->close), ty, morph_t);
+            } else {
+                x = tx;
+                y = ty;
+            }
+        } else {
+            // A slot only the outgoing data had. Counts match in practice, so this
+            // just keeps gappy or short-history data from breaking the line.
+            x = frm->x * area_w;
+            y = vroom::y_at_fraction(lay, frm->close);
+        }
+
+        if (pen_down) {
+            path.lineTo(x, y);
+        } else {
+            path.moveTo(x, y);
+            pen_down = true;
+        }
+    }
+    return path.detach();
+}
+}  // namespace
+
 void draw(SkCanvas* canvas,
           const Layout& lay,
           const PriceBounds& bounds,
@@ -60,21 +151,92 @@ void draw(SkCanvas* canvas,
         }
     }
 
-    SkPaint line;
-    line.setAntiAlias(true);
-    line.setColor(static_cast<SkColor>(color));
-    // Fade the line in during the candle→line morph (multiplies the color alpha).
-    if (opacity < 1.f) {
-        line.setAlphaf(line.getAlphaf() * opacity);
-    }
-    line.setStyle(SkPaint::kStroke_Style);
-    line.setStrokeWidth(width > 0.f ? width : 1.5f);
+    stroke_path(canvas, path.detach(), candle_right, candle_area_h, color, width,
+                opacity);
+}
+
+void draw_close_line(SkCanvas* canvas,
+                     const Layout& lay,
+                     const PriceBounds& bounds,
+                     const ::VroomCandle* visible,
+                     std::size_t n,
+                     int64_t window_ms,
+                     int64_t visible_start_ms,
+                     int64_t candle_duration_ms,
+                     float candle_right,
+                     float candle_area_h,
+                     uint32_t color,
+                     float width,
+                     float opacity,
+                     const CandleSnapshot* from,
+                     std::size_t from_n,
+                     float morph_t) {
+    if (!canvas || candle_right <= 0.f || candle_area_h <= 0.f) return;
+    opacity = std::clamp(opacity, 0.f, 1.f);
+    if (opacity <= 0.f) return;
+    morph_t = std::clamp(morph_t, 0.f, 1.f);
+
+    const SkPath path = build_close_path(lay, bounds, visible, n, window_ms,
+                                        visible_start_ms, candle_duration_ms,
+                                        from, from_n, morph_t);
+    if (path.isEmpty()) return;
+
+    stroke_path(canvas, path, candle_right, candle_area_h, color, width, opacity);
+}
+
+void draw_close_gradient(SkCanvas* canvas,
+                         const Layout& lay,
+                         const PriceBounds& bounds,
+                         const ::VroomCandle* visible,
+                         std::size_t n,
+                         int64_t window_ms,
+                         int64_t visible_start_ms,
+                         int64_t candle_duration_ms,
+                         float candle_right,
+                         float candle_area_h,
+                         uint32_t color,
+                         float gradient_opacity,
+                         float opacity,
+                         const CandleSnapshot* from,
+                         std::size_t from_n,
+                         float morph_t) {
+    if (!canvas || candle_right <= 0.f || candle_area_h <= 0.f) return;
+    gradient_opacity = std::clamp(gradient_opacity, 0.f, 1.f);
+    opacity = std::clamp(opacity, 0.f, 1.f);
+    const float alpha = gradient_opacity * opacity;
+    if (alpha <= 0.f) return;
+    morph_t = std::clamp(morph_t, 0.f, 1.f);
+
+    const SkPath line = build_close_path(lay, bounds, visible, n, window_ms,
+                                        visible_start_ms, candle_duration_ms,
+                                        from, from_n, morph_t);
+    if (line.isEmpty()) return;
+
+    // The polyline runs strictly left to right, so its bounds give the first and
+    // last vertex x plus the peak the ramp starts from. A peak above the pane
+    // (line zoomed off the top) would stretch the ramp, so anchor at the pane.
+    const SkRect b = line.getBounds();
+    const float top = std::max(b.top(), 0.f);
+    if (top >= candle_area_h) return;
+
+    // Drop from the last vertex to the pane bottom and back along it, turning the
+    // polyline into the closed region beneath the line.
+    SkPathBuilder area(line);
+    area.lineTo(b.right(), candle_area_h);
+    area.lineTo(b.left(), candle_area_h);
+    area.close();
+
+    const SkPoint pts[2] = {SkPoint::Make(0.f, top),
+                            SkPoint::Make(0.f, candle_area_h)};
+    SkPaint fill;
+    fill.setAntiAlias(true);
+    fill.setStyle(SkPaint::kFill_Style);
+    fill.setShader(
+        vroom::linear_alpha_ramp(pts, static_cast<SkColor>(color), alpha, 0.f));
 
-    // Clip to the candle area so a line that runs off-range doesn't bleed into
-    // the axis strips or any indicator pane below.
     canvas->save();
     canvas->clipRect(SkRect::MakeLTRB(0.f, 0.f, candle_right, candle_area_h));
-    canvas->drawPath(path.detach(), line);
+    canvas->drawPath(area.detach(), fill);
     canvas->restore();
 }
 

package/cpp/_core_src/ma_overlay.h

@@ -11,6 +11,7 @@
 class SkCanvas;
 
 namespace vroom {
+struct CandleSnapshot;
 struct Layout;
 struct PriceBounds;
 }  // namespace vroom
@@ -40,12 +41,63 @@ void draw(SkCanvas* canvas,
           const unsigned char* break_before = nullptr,
           float opacity = 1.f);
 
+// The close-price polyline of line-chart mode. Equivalent to draw() fed the
+// visible closes, plus the interval morph: `from` / `from_n` is the outgoing
+// geometry indexed from the right of the visible slice (slot 0 = newest) and
+// `morph_t` (0..1) is the eased progress, so each vertex slides from the close it
+// had before the timeframe switch to its new one. `morph_t == 1` (the default)
+// draws `visible` alone.
+//
+// Separate from draw() because the capture holds candle closes — it can't stand
+// in for an indicator's values.
+void draw_close_line(SkCanvas* canvas,
+                     const Layout& lay,
+                     const PriceBounds& bounds,
+                     const ::VroomCandle* visible,
+                     std::size_t n,
+                     int64_t window_ms,
+                     int64_t visible_start_ms,
+                     int64_t candle_duration_ms,
+                     float candle_right,
+                     float candle_area_h,
+                     uint32_t color,
+                     float width,
+                     float opacity = 1.f,
+                     const CandleSnapshot* from = nullptr,
+                     std::size_t from_n = 0,
+                     float morph_t = 1.f);
+
+// The area beneath the close-price polyline, filled with `color` ramping from
+// `gradient_opacity` at the line's peak to fully transparent at the pane bottom.
+// Takes the same geometry and morph arguments as draw_close_line and builds the
+// identical polyline, so the fill tracks the line through a timeframe switch.
+//
+// `opacity` multiplies the ramp, which is what fades the fill in alongside the
+// line during the candle→line morph. Draws nothing when either opacity is 0.
+// Belongs behind the volume bars, so it's a separate call rather than part of
+// draw_close_line.
+void draw_close_gradient(SkCanvas* canvas,
+                         const Layout& lay,
+                         const PriceBounds& bounds,
+                         const ::VroomCandle* visible,
+                         std::size_t n,
+                         int64_t window_ms,
+                         int64_t visible_start_ms,
+                         int64_t candle_duration_ms,
+                         float candle_right,
+                         float candle_area_h,
+                         uint32_t color,
+                         float gradient_opacity,
+                         float opacity = 1.f,
+                         const CandleSnapshot* from = nullptr,
+                         std::size_t from_n = 0,
+                         float morph_t = 1.f);
+
 // Fills the closed region between two aligned series (NaN where undefined)
 // with `color` at its alpha × `opacity` — used for the Bollinger Band fill.
 // Runs where either series is NaN are skipped, so the fill never bridges the
-// warmup gap. Plain-alpha SkPaint fill, no gradient shader (the Skia gradient
-// APIs diverge across our pinned versions; see liquidity.cpp). Clipped to the
-// candle area like draw().
+// warmup gap. Plain-alpha SkPaint fill, no gradient ramp (see gradient.h).
+// Clipped to the candle area like draw().
 void fill_between(SkCanvas* canvas,
                   const Layout& lay,
                   const PriceBounds& bounds,

package/cpp/_core_src/macd.cpp

@@ -2,61 +2,32 @@
 
 #include <cmath>  // std::nan, std::isfinite
 
-namespace vroom::macd {
-
-namespace {
-// SMA-seeded EMA over `src` (which may have a leading NaN run). Fills `out`
-// (resized to src.size()): NaN until the seed index, the seed = SMA of the
-// first `period` finite values, then ema = alpha*src + (1-alpha)*prev.
-void ema_seeded(const std::vector<double>& src, int period,
-                std::vector<double>& out) {
-    const std::size_t n = src.size();
-    out.assign(n, std::nan(""));
-    if (period < 1) return;
-    const std::size_t P = static_cast<std::size_t>(period);
-
-    std::size_t f = 0;
-    while (f < n && !std::isfinite(src[f])) ++f;
-    if (f >= n || f + P > n) return;  // not enough finite values to seed
-
-    const std::size_t seed = f + P - 1;
-    double sum = 0.0;
-    for (std::size_t k = f; k <= seed; ++k) sum += src[k];
-    double prev = sum / static_cast<double>(P);
-    out[seed] = prev;
+#include "ma.h"
+#include "series_ma.h"
 
-    const double alpha = 2.0 / (static_cast<double>(P) + 1.0);
-    for (std::size_t i = seed + 1; i < n; ++i) {
-        if (!std::isfinite(src[i])) break;  // series are contiguous after f
-        prev = alpha * src[i] + (1.0 - alpha) * prev;
-        out[i] = prev;
-    }
-}
-}  // namespace
+namespace vroom::macd {
 
 void compute(const ::VroomCandle* candles, std::size_t n, int fast, int slow,
-             int signal, std::vector<double>& macd_out,
-             std::vector<double>& signal_out, std::vector<double>& hist_out) {
+             int signal, int source, int ma_kind, int signal_ma_kind,
+             std::vector<double>& macd_out, std::vector<double>& signal_out,
+             std::vector<double>& hist_out) {
     macd_out.assign(n, std::nan(""));
     signal_out.assign(n, std::nan(""));
     hist_out.assign(n, std::nan(""));
     if (!candles || fast < 1 || slow < 1 || signal < 1) return;
 
-    std::vector<double> closes(n);
-    for (std::size_t i = 0; i < n; ++i) closes[i] = candles[i].close;
-
-    std::vector<double> ema_fast;
-    std::vector<double> ema_slow;
-    ema_seeded(closes, fast, ema_fast);
-    ema_seeded(closes, slow, ema_slow);
+    std::vector<double> ma_fast;
+    std::vector<double> ma_slow;
+    vroom::ma::compute(candles, n, ma_kind, fast, source, ma_fast);
+    vroom::ma::compute(candles, n, ma_kind, slow, source, ma_slow);
 
     for (std::size_t i = 0; i < n; ++i) {
-        if (std::isfinite(ema_fast[i]) && std::isfinite(ema_slow[i])) {
-            macd_out[i] = ema_fast[i] - ema_slow[i];
+        if (std::isfinite(ma_fast[i]) && std::isfinite(ma_slow[i])) {
+            macd_out[i] = ma_fast[i] - ma_slow[i];
         }
     }
 
-    ema_seeded(macd_out, signal, signal_out);
+    vroom::series_ma::smooth(macd_out, signal_ma_kind, signal, signal_out);
 
     for (std::size_t i = 0; i < n; ++i) {
         if (std::isfinite(macd_out[i]) && std::isfinite(signal_out[i])) {

package/cpp/_core_src/macd.h

@@ -1,8 +1,8 @@
 // MACD — pure computation, no Skia. Kept Skia-free so it builds into the
 // unit-test target. Mirrors rsi.cpp's NaN-warmup convention.
 //
-// MACD line   = EMA(fast) - EMA(slow) of close
-// Signal line = EMA(signal) of the MACD line
+// MACD line   = MA(fast) - MA(slow) of the chosen price source
+// Signal line = MA(signal) of the MACD line
 // Histogram   = MACD - Signal
 // EMAs are SMA-seeded: NaN until the first `period` values exist (the seed is
 // their simple average), then ema = alpha*src + (1-alpha)*prev, alpha=2/(p+1).
@@ -16,14 +16,17 @@
 
 namespace vroom::macd {
 
-// Computes MACD over the closes of [candles, candles+n). fast/slow/signal are
-// clamped to >= 1 (callers pass 12/26/9 by default; slow should exceed fast).
+// Computes MACD over [candles, candles+n). fast/slow/signal are clamped to >= 1
+// (callers pass 12/26/9 by default; slow should exceed fast). `source` selects
+// the price series (vroom::ma::Source); `ma_kind` picks the averaging for the
+// fast/slow legs and `signal_ma_kind` for the signal line (vroom::ma::Kind).
 // Fills three series (each resized to n, NaN where undefined):
-//   macd_out   — EMA(fast) - EMA(slow), defined from index slow-1
-//   signal_out — EMA(signal) of macd_out, defined from (slow-1)+(signal-1)
+//   macd_out   — MA(fast) - MA(slow), defined from index slow-1
+//   signal_out — MA(signal) of macd_out, defined from (slow-1)+(signal-1)
 //   hist_out   — macd_out - signal_out, defined where both are
 void compute(const ::VroomCandle* candles, std::size_t n, int fast, int slow,
-             int signal, std::vector<double>& macd_out,
-             std::vector<double>& signal_out, std::vector<double>& hist_out);
+             int signal, int source, int ma_kind, int signal_ma_kind,
+             std::vector<double>& macd_out, std::vector<double>& signal_out,
+             std::vector<double>& hist_out);
 
 }  // namespace vroom::macd