react-native-vroom-chart 0.13.0 → 0.14.0

package/cpp/_core_src/chart.cpp

@@ -178,160 +178,274 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     // 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.
+    //       fade 0 = pure candles, fade 1 = pure line.
+    //
+    //       An interval *transform* reshapes each slot from the geometry it held
+    //       before the timeframe switch (see `morph_from`). A host-chosen
+    //       *fade* skips the pairing and uses the same envelope as the axes
+    //       (`labels::interval_phase`): outgoing snapshot out, then new scene in.
     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,
-            theme.floats[VROOM_FLOAT_LINE_TENSION]);
-    }
+    const bool fade_swap = morphing && interval_morph_fade;
+    const bool fade_out = fade_swap && axis_phase.outgoing;
+    const bool fade_in = fade_swap && !axis_phase.outgoing;
+    const bool reshape = morphing && !fade_swap;
+    const vroom::CandleSnapshot* morph_src = reshape ? morph_from.data() : nullptr;
+    const std::size_t morph_n_draw = reshape ? morph_n : 0;
+    const float morph_t = reshape ? interval_morph_t : 1.f;
+
+    if (fade_out) {
+        // First half: only the captured series, at the axis envelope opacity.
+        // Layers with no snapshot (volume, overlays, indicators, drawings)
+        // would already be the new data, so they stay hidden until the incoming
+        // half. morph_t = 0 draws the capture pixel-identically.
+        const float layer = axis_phase.opacity;
+        if (layer > 0.f) {
+            if (fade > 0.f) {
+                vroom::ma_overlay::draw_close_gradient(
+                    canvas, lay, bounds, visible, 0, 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 * layer, morph_from.data(), morph_n, 0.f,
+                    theme.floats[VROOM_FLOAT_LINE_TENSION]);
+            }
+            if (fade < 1.f) {
+                vroom::candles::draw(canvas, visible, 0, lay, theme, bounds,
+                                     window_ms, visible_start_ms,
+                                     candle_duration_ms, collapse,
+                                     (1.f - fade) * layer, morph_from.data(),
+                                     morph_n, 0.f);
+            }
+            if (fade > 0.f) {
+                vroom::ma_overlay::draw_close_line(
+                    canvas, lay, bounds, visible, 0, 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], fade * layer,
+                    morph_from.data(), morph_n, 0.f,
+                    theme.floats[VROOM_FLOAT_LINE_TENSION]);
+                if (theme.floats[VROOM_FLOAT_LINE_TIP_DOT] > 0.5f) {
+                    vroom::ma_overlay::draw_close_tip(
+                        canvas, lay, bounds, visible, 0, window_ms,
+                        visible_start_ms, candle_duration_ms, candle_right,
+                        candle_area_h, theme.colors[VROOM_COLOR_LINE],
+                        theme.colors[VROOM_COLOR_BACKGROUND],
+                        theme.floats[VROOM_FLOAT_LINE_WIDTH_PX], fade * layer,
+                        theme.floats[VROOM_FLOAT_LINE_TIP_PULSE] > 0.5f,
+                        tip_pulse_elapsed_s / vroom::tip_pulse::kPeriodSeconds,
+                        morph_from.data(), morph_n, 0.f);
+                }
+            }
+        }
+    } else {
+        // Incoming fade: the new scene at envelope opacity, no slot lerp
+        // (`morph_t` is already 1). Transforms use the reshape path above.
+        const bool wrap = fade_in && axis_phase.opacity > 0.f &&
+                          axis_phase.opacity < 0.999f;
+        if (wrap) {
+            canvas->saveLayerAlpha(
+                nullptr, static_cast<U8CPU>(axis_phase.opacity * 255.f + 0.5f));
+        }
+        const bool draw_new = !fade_in || axis_phase.opacity > 0.f;
+
+        if (draw_new) {
+            // 4.4. Line-mode gradient fill — the wash under the close polyline.
+            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_draw, morph_t,
+                    theme.floats[VROOM_FLOAT_LINE_TENSION]);
+            }
 
-    // 4.5. Volume bars — drawn under the candles so candles z-index above.
-    //      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.5. Volume bars — drawn under the candles so candles z-index above.
+            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
-    //      space, so they scale with the y-axis.
-    vroom::liquidity::draw(canvas, *this, lay, bounds, candle_right,
-                           candle_area_h);
-
-    // 4.7. Bollinger Band fill — the translucent region between the upper and
-    //      lower bands, behind the candles so their bull/bear colors stay
-    //      untinted. The band lines themselves draw above the candles (5.65).
-    if (bollinger.enabled) {
-        ensure_bollinger();
-        if (bollinger.fill_enabled &&
-            bb_upper_cache.size() == candles.size() &&
-            bb_lower_cache.size() == candles.size()) {
-            vroom::ma_overlay::fill_between(
-                canvas, lay, bounds, visible, n,
-                bb_upper_cache.data() + range.start,
-                bb_lower_cache.data() + range.start, window_ms,
-                visible_start_ms, candle_duration_ms, candle_right,
-                candle_area_h, bollinger.upper_color, bollinger.fill_opacity);
-        }
-    }
+            // 4.6. Liquidity bands (resting-order depth).
+            vroom::liquidity::draw(canvas, *this, lay, bounds, candle_right,
+                                   candle_area_h);
+
+            // 4.7. Bollinger Band fill.
+            if (bollinger.enabled) {
+                ensure_bollinger();
+                if (bollinger.fill_enabled &&
+                    bb_upper_cache.size() == candles.size() &&
+                    bb_lower_cache.size() == candles.size()) {
+                    vroom::ma_overlay::fill_between(
+                        canvas, lay, bounds, visible, n,
+                        bb_upper_cache.data() + range.start,
+                        bb_lower_cache.data() + range.start, window_ms,
+                        visible_start_ms, candle_duration_ms, candle_right,
+                        candle_area_h, bollinger.upper_color,
+                        bollinger.fill_opacity);
+                }
+            }
 
-    // 5. Price series — candles, a close-price line, or a blend of the two during
-    //    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, morph_src, morph_n, morph_t);
-    }
-    if (fade > 0.f) {
-        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],
-            fade, morph_src, morph_n, morph_t,
-            theme.floats[VROOM_FLOAT_LINE_TENSION]);
-    }
+            // 5. Price series — candles, a close-price line, or a blend.
+            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,
+                                     morph_src, morph_n_draw, morph_t);
+            }
+            if (fade > 0.f) {
+                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], fade, morph_src,
+                    morph_n_draw, morph_t,
+                    theme.floats[VROOM_FLOAT_LINE_TENSION]);
+            }
 
-    // 5.5. Moving-average overlay lines (SMA/EMA) on the price pane, over the
-    //      candles. They share the candle price scale and don't reserve a pane.
-    if (!overlays.empty()) {
-        ensure_overlays();
-        for (std::size_t k = 0; k < overlays.size(); ++k) {
-            if (overlay_caches[k].size() != candles.size()) continue;
-            const double* vis = overlay_caches[k].data() + range.start;
-            vroom::ma_overlay::draw(canvas, lay, bounds, visible, n, vis,
-                                    window_ms, visible_start_ms,
-                                    candle_duration_ms, candle_right,
-                                    candle_area_h, overlays[k].color,
-                                    overlays[k].width);
-        }
-    }
+            // 5.5. Moving-average overlay lines.
+            if (!overlays.empty()) {
+                ensure_overlays();
+                for (std::size_t k = 0; k < overlays.size(); ++k) {
+                    if (overlay_caches[k].size() != candles.size()) continue;
+                    const double* vis = overlay_caches[k].data() + range.start;
+                    vroom::ma_overlay::draw(
+                        canvas, lay, bounds, visible, n, vis, window_ms,
+                        visible_start_ms, candle_duration_ms, candle_right,
+                        candle_area_h, overlays[k].color, overlays[k].width);
+                }
+            }
 
-    // 5.6. VWAP overlay (session, configurable reset) — a single price-pane line
-    //      that breaks at each session reset (vwap_breaks).
-    if (vwap.enabled) {
-        ensure_vwap();
-        if (vwap_cache.size() == candles.size()) {
-            const double* vis = vwap_cache.data() + range.start;
-            const unsigned char* brk = vwap_breaks.size() == candles.size()
-                ? vwap_breaks.data() + range.start
-                : nullptr;
-            vroom::ma_overlay::draw(canvas, lay, bounds, visible, n, vis,
-                                    window_ms, visible_start_ms,
-                                    candle_duration_ms, candle_right,
-                                    candle_area_h,
-                                    vroom::style::color_or(vwap.color, kVwapLine),
-                                    vroom::style::width_or(vwap.width, 1.5f),
-                                    brk);
-        }
-    }
+            // 5.6. VWAP overlay.
+            if (vwap.enabled) {
+                ensure_vwap();
+                if (vwap_cache.size() == candles.size()) {
+                    const double* vis = vwap_cache.data() + range.start;
+                    const unsigned char* brk =
+                        vwap_breaks.size() == candles.size()
+                            ? vwap_breaks.data() + range.start
+                            : nullptr;
+                    vroom::ma_overlay::draw(
+                        canvas, lay, bounds, visible, n, vis, window_ms,
+                        visible_start_ms, candle_duration_ms, candle_right,
+                        candle_area_h,
+                        vroom::style::color_or(vwap.color, kVwapLine),
+                        vroom::style::width_or(vwap.width, 1.5f), brk);
+                }
+            }
 
-    // 5.65. Bollinger Band lines — upper, lower, then the basis last so it
-    //       reads on top where the bands pinch. Same price scale as the
-    //       candles; the fill went down in 4.7.
-    if (bollinger.enabled) {
-        ensure_bollinger();
-        const std::size_t sz = candles.size();
-        if (bb_upper_cache.size() == sz && bb_lower_cache.size() == sz &&
-            bb_middle_cache.size() == sz) {
-            const auto stroke = [&](const std::vector<double>& cache,
-                                    uint32_t color, float width) {
-                vroom::ma_overlay::draw(canvas, lay, bounds, visible, n,
-                                        cache.data() + range.start, window_ms,
-                                        visible_start_ms, candle_duration_ms,
-                                        candle_right, candle_area_h, color,
-                                        width);
-            };
-            stroke(bb_upper_cache, bollinger.upper_color, bollinger.upper_width);
-            stroke(bb_lower_cache, bollinger.lower_color, bollinger.lower_width);
-            stroke(bb_middle_cache, bollinger.middle_color, bollinger.middle_width);
-        }
-    }
+            // 5.65. Bollinger Band lines.
+            if (bollinger.enabled) {
+                ensure_bollinger();
+                const std::size_t sz = candles.size();
+                if (bb_upper_cache.size() == sz && bb_lower_cache.size() == sz &&
+                    bb_middle_cache.size() == sz) {
+                    const auto stroke = [&](const std::vector<double>& cache,
+                                              uint32_t color, float width) {
+                        vroom::ma_overlay::draw(
+                            canvas, lay, bounds, visible, n,
+                            cache.data() + range.start, window_ms,
+                            visible_start_ms, candle_duration_ms, candle_right,
+                            candle_area_h, color, width);
+                    };
+                    stroke(bb_upper_cache, bollinger.upper_color,
+                           bollinger.upper_width);
+                    stroke(bb_lower_cache, bollinger.lower_color,
+                           bollinger.lower_width);
+                    stroke(bb_middle_cache, bollinger.middle_color,
+                           bollinger.middle_width);
+                }
+            }
 
-    // 5.7. Drawing annotations (committed line tools + the in-progress draft).
-    //      On the price pane above the candles/overlays, below the axis labels.
-    vroom::drawings::draw(canvas, *this, lay, bounds, candle_right,
-                          candle_area_h);
+            // 5.7. Drawing annotations.
+            vroom::drawings::draw(canvas, *this, lay, bounds, candle_right,
+                                  candle_area_h);
+
+            // 5.8. Line-mode tip marker.
+            if (fade > 0.f && theme.floats[VROOM_FLOAT_LINE_TIP_DOT] > 0.5f) {
+                const auto anchor = vroom::tip_anchor::at(
+                    range.start, range.end, candles.size(), reshape);
+                vroom::ma_overlay::draw_close_tip(
+                    canvas, lay, bounds, visible, anchor.slot_count, window_ms,
+                    visible_start_ms, candle_duration_ms, candle_right,
+                    candle_area_h, theme.colors[VROOM_COLOR_LINE],
+                    theme.colors[VROOM_COLOR_BACKGROUND],
+                    theme.floats[VROOM_FLOAT_LINE_WIDTH_PX], fade,
+                    theme.floats[VROOM_FLOAT_LINE_TIP_PULSE] > 0.5f,
+                    tip_pulse_elapsed_s / vroom::tip_pulse::kPeriodSeconds,
+                    anchor.use_morph ? morph_src : nullptr,
+                    anchor.use_morph ? morph_n_draw : 0, morph_t);
+            }
 
-    // 5.8. Line-mode tip marker — the dot (and optional pulse) at the newest
-    //      close. Above the overlays so it stays the eye's anchor, but before the
-    //      axis masks, which trim the ring at the price scale.
-    //
-    //      Unlike every layer above, this one anchors to the newest candle in
-    //      the series rather than the newest on screen, so panning into history
-    //      carries the dot off the right edge with its candle (tip_anchor.h).
-    if (fade > 0.f && theme.floats[VROOM_FLOAT_LINE_TIP_DOT] > 0.5f) {
-        const auto anchor = vroom::tip_anchor::at(range.start, range.end,
-                                                  candles.size(), morphing);
-        vroom::ma_overlay::draw_close_tip(
-            canvas, lay, bounds, visible, anchor.slot_count, window_ms,
-            visible_start_ms, candle_duration_ms, candle_right, candle_area_h,
-            theme.colors[VROOM_COLOR_LINE],
-            theme.colors[VROOM_COLOR_BACKGROUND],
-            theme.floats[VROOM_FLOAT_LINE_WIDTH_PX], fade,
-            theme.floats[VROOM_FLOAT_LINE_TIP_PULSE] > 0.5f,
-            tip_pulse_elapsed_s / vroom::tip_pulse::kPeriodSeconds,
-            anchor.use_morph ? morph_src : nullptr,
-            anchor.use_morph ? morph_n : 0, morph_t);
+            // Incoming fade: indicator panes share the scene opacity (and
+            // paint before axis masks so overflow still clips). Transforms
+            // keep the settled z-order after the price indicator.
+            if (fade_in && lay.indicator_area_h > 0.f) {
+                struct ActivePane {
+                    int order;
+                    int type;
+                };
+                ActivePane panes[2];
+                int count = 0;
+                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];
+                    panes[1] = tmp;
+                }
+
+                const float pane_h =
+                    height_px * theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
+                float pane_top = candle_area_h;
+                for (int i = 0; i < count; ++i) {
+                    const float pane_bottom = pane_top + pane_h;
+                    if (panes[i].type == 0) {
+                        ensure_rsi();
+                        const double* rsi_vis =
+                            rsi_cache.size() == candles.size()
+                                ? rsi_cache.data() + range.start
+                                : nullptr;
+                        const double* rsi_ma_vis =
+                            (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, candle_duration_ms,
+                            candle_right, pane_top, pane_bottom);
+                    } else {
+                        ensure_macd();
+                        const double* macd_vis =
+                            macd_cache.size() == candles.size()
+                                ? macd_cache.data() + range.start
+                                : nullptr;
+                        const double* sig_vis =
+                            macd_signal_cache.size() == candles.size()
+                                ? macd_signal_cache.data() + range.start
+                                : nullptr;
+                        const double* hist_vis =
+                            macd_hist_cache.size() == candles.size()
+                                ? macd_hist_cache.data() + range.start
+                                : nullptr;
+                        vroom::macd_pane::draw(
+                            canvas, *this, lay, visible, n, macd_vis, sig_vis,
+                            hist_vis, window_ms, visible_start_ms,
+                            candle_duration_ms, candle_right, pane_top,
+                            pane_bottom);
+                    }
+                    pane_top = pane_bottom;
+                }
+            }
+        }
+
+        if (wrap) canvas->restore();
     }
 
     // 6. Axis backgrounds (mask any candle overflow). The x-axis separator
@@ -354,20 +468,25 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
 
     // 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.
-    vroom::price_indicator::draw(canvas, *this, lay, bounds,
-                                 candle_right, candle_area_h);
-
-    // 7.55. Consumer-supplied price status lines — same tier as the current-price
-    //       indicator (their badges must cover the labels underneath), but after
-    //       it so a resting order at the last close stays readable.
-    vroom::price_lines::draw(canvas, *this, lay, bounds, candle_right,
-                             candle_area_h);
+    //      Hidden during a fade's outgoing half: the close is already the new
+    //      series and there is no snapshot to fade.
+    if (!fade_out) {
+        vroom::price_indicator::draw(canvas, *this, lay, bounds,
+                                     candle_right, candle_area_h);
+
+        // 7.55. Consumer-supplied price status lines — same tier as the
+        //       current-price indicator (their badges must cover the labels
+        //       underneath), but after it so a resting order at the last close
+        //       stays readable.
+        vroom::price_lines::draw(canvas, *this, lay, bounds, candle_right,
+                                   candle_area_h);
+    }
 
     // 7.6. Indicator panes stacked below the candles, ordered by enable
     //      sequence (most recently enabled at the bottom). Each pane is
     //      INDICATOR_HEIGHT_FRAC of the height; the candle pane already shrank
-    //      to fit them (see layout()).
-    if (lay.indicator_area_h > 0.f) {
+    //      to fit them (see layout()). A fade already drew them with the scene.
+    if (!fade_swap && lay.indicator_area_h > 0.f) {
         struct ActivePane { int order; int type; };  // type: 0 = RSI, 1 = MACD
         ActivePane panes[2];
         int count = 0;

package/cpp/_core_src/chart.h

@@ -73,11 +73,14 @@ struct VroomChart {
 
     // 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.
+    // newest). `interval_morph_fade` is the host's choice at capture time:
+    // false = slot-lerp each column into its counterpart; true = fade the
+    // snapshot out then the new scene in (see labels::interval_phase).
+    // 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
+    bool interval_morph_fade = false;
     // 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

package/cpp/_core_src/chart_facade.cpp

@@ -299,6 +299,7 @@ extern "C" void vroom_chart_reset_view(VroomChart* chart) {
     // here — drop any capture rather than leaving it to reshape the wrong data.
     chart->morph_from.clear();
     chart->interval_morph_t = 1.f;
+    chart->interval_morph_fade = false;
     apply_default_framing(chart);
     vroom::labels::recompute_axis_width(*chart);
     if (chart->cb.on_viewport_changed) {
@@ -352,10 +353,11 @@ extern "C" void vroom_chart_preserve_price_envelope(VroomChart* chart,
     chart->mark_dirty();
 }
 
-extern "C" void vroom_chart_begin_interval_morph(VroomChart* chart) {
+extern "C" void vroom_chart_begin_interval_morph(VroomChart* chart, int32_t mode) {
     if (!chart) return;
     chart->morph_from.clear();
     chart->interval_morph_t = 1.f;
+    chart->interval_morph_fade = false;
 
     const auto lay = chart->layout();
     const float area_w = vroom::candle_area_width(lay);
@@ -400,6 +402,7 @@ extern "C" void vroom_chart_begin_interval_morph(VroomChart* chart) {
     // Open the morph at 0 rather than leaving it at 1: the caller still has to
     // push the new candles, and any frame painted in between should show the
     // captured geometry — which is what the pre-switch frame looked like.
+    chart->interval_morph_fade = vroom::interval_morph_is_fade(mode);
     chart->interval_morph_t = 0.f;
 }
 
@@ -409,6 +412,7 @@ extern "C" void vroom_chart_set_interval_morph(VroomChart* chart, float t) {
     if (chart->interval_morph_t >= 1.f) {
         chart->morph_from.clear();
         chart->morph_from.shrink_to_fit();
+        chart->interval_morph_fade = false;
     }
     chart->mark_dirty();
 }

package/cpp/_core_src/viewport.h

@@ -104,6 +104,10 @@ inline std::size_t morph_from_count(const CandleSnapshot* from,
     return (from && morph_t < 1.f) ? from_n : 0;
 }
 
+// C facade `vroom_chart_begin_interval_morph` mode: 0 = slot-lerp transform,
+// anything else = fade the outgoing snapshot out then the new scene in.
+inline bool interval_morph_is_fade(int32_t mode) { return mode != 0; }
+
 // 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).

package/lib/index.d.mts

@@ -187,6 +187,13 @@ type ChartType = 'candles' | 'line';
  * Defaults to `'ease-in-out'`.
  */
 type TransitionEasing = 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
+/**
+ * How a same-asset interval switch animates. `'transform'` (default) lerps
+ * each visible column into its counterpart. `'fade'` fades the old scene out
+ * then the new one in — use when the two windows don’t share a 1:1 pairing
+ * (e.g. a fixed lookback).
+ */
+type IntervalTransition = 'transform' | 'fade';
 /** Active drawing tool while in `draw` mode. `null` draws nothing. */
 type DrawTool = null | 'line' | 'box' | 'pencil' | 'path';
 /** A drawing anchor in data space, so it stays glued to the candles on pan/zoom. */
@@ -200,9 +207,12 @@ type DrawPoint = {
 type DrawingBase = {
     /** Stable unique id (the chart generates one for drawings it creates). */
     id: string;
-    /** Stroke color (hex string or packed ARGB number). Default solid blue. */
+    /**
+     * Stroke color (hex string or packed ARGB number). New drawings take
+     * `drawingStyle.color` when set; otherwise `#ff2962ff`.
+     */
     color?: VroomColor;
-    /** Stroke width in px. Default 2. */
+    /** Stroke width in px. New drawings take `drawingStyle.width` when set; otherwise 2. */
     width?: number;
     /**
      * Protect the drawing from editing. A locked drawing still renders and can
@@ -295,6 +305,29 @@ type DrawingStyle = {
     fill?: VroomColor;
     locked?: boolean;
 };
+/**
+ * Default appearance for drawings the user creates — the live draft and the
+ * object handed to `onDrawingComplete`. Paste copies the source drawing's
+ * style instead of this default.
+ *
+ * Omitted fields keep the library defaults: a 2px `#ff2962ff` stroke, and for
+ * boxes a 10% tint of the stroke as fill.
+ *
+ * Prefer 6-digit hex for `color` (`'#00FFFF'`). vroom treats that as opaque,
+ * and CSS swatches preview it correctly. 8-digit hex is `#aarrggbb`, not CSS
+ * `#rrggbbaa`.
+ */
+type DefaultDrawingStyle = {
+    /** Stroke color, used for the live draft and stamped onto the committed drawing. */
+    color?: VroomColor;
+    /** Stroke width in px. Default 2. */
+    width?: number;
+    /**
+     * Box interior fill. Omitted, new boxes keep the default 10% stroke tint.
+     * Ignored by line, pencil, and path.
+     */
+    fill?: VroomColor;
+};
 /**
  * Storage adapter for **managed** drawing persistence. Provide it via the
  * `drawingStore` prop and the chart owns the drawings array itself — loading and
@@ -720,16 +753,23 @@ type VroomChartCoreProps = {
     chartType?: ChartType;
     /**
      * Duration (ms) of the animated transitions: the candle↔line switch when
-     * `chartType` changes, and the candle reshape when the `candles` array is
+     * `chartType` changes, and the interval switch when the `candles` array is
      * swapped for a different interval of the same asset. Default ~300. `0` snaps
-     * instantly. Ignored (snaps) when the OS requests reduced motion, which
-     * instead uses a plain cross-fade.
+     * instantly. Ignored (snaps) when the OS requests reduced motion.
      */
     transitionMs?: number;
     /**
      * Easing curve applied to those transitions. Default `'ease-in-out'`.
      */
     transitionEasing?: TransitionEasing;
+    /**
+     * How a same-asset interval switch animates. `'transform'` (default) lerps
+     * each visible column into its counterpart. `'fade'` fades the old scene out
+     * then the new one in — use when the two windows don’t share a 1:1 pairing
+     * (e.g. a fixed lookback). Same duration/easing as `transitionMs`. Reduced
+     * motion still snaps.
+     */
+    intervalTransition?: IntervalTransition;
     theme?: VroomTheme;
     /** RSI indicator (pane below the candles). Omit/disable to hide it. */
     rsi?: RSIConfig;
@@ -802,6 +842,12 @@ type VroomChartCoreProps = {
     mode?: ChartMode;
     /** Active drawing tool while in `draw` mode. Default `null` (draws nothing). */
     tool?: DrawTool;
+    /**
+     * Default appearance for drawings the user creates (live draft + the object
+     * handed to `onDrawingComplete`). Paste copies the source drawing's style
+     * instead of this. Omitted fields keep the library defaults.
+     */
+    drawingStyle?: DefaultDrawingStyle;
     /**
      * Committed drawings to render, anchored to data so they track the candles on
      * pan/zoom. This is a controlled prop: append the value the chart hands you in
@@ -945,4 +991,4 @@ declare function classifyTransition(prev: Candle[] | null, next: Candle[], serie
  */
 declare function timeframeWindow(oldWindow: VisibleRange, oldStepMs: number, oldLastMs: number, newStepMs: number, newLastMs: number): VisibleRange;
 
-export { type BollingerBandsConfig, type Candle, type ChartType, type CrosshairEvent, type DataTransition, type MACDConfig, type MAKind, type MASource, type MovingAverageOverlay, type PriceLine, type PriceLinesStyle, type RSIConfig, type TransitionEasing, type VWAPConfig, type VisibleRange, type VolumeConfig, VroomChart, type VroomChartProps, type VroomColor, type VroomTheme, classifyTransition, inferStepMs, timeframeWindow };
+export { type BollingerBandsConfig, type Candle, type ChartType, type CrosshairEvent, type DataTransition, type DefaultDrawingStyle, type IntervalTransition, type MACDConfig, type MAKind, type MASource, type MovingAverageOverlay, type PriceLine, type PriceLinesStyle, type RSIConfig, type TransitionEasing, type VWAPConfig, type VisibleRange, type VolumeConfig, VroomChart, type VroomChartProps, type VroomColor, type VroomTheme, classifyTransition, inferStepMs, timeframeWindow };